@trezoa/rpc

This package contains utilities for creating objects that you can use to communicate with a Trezoa JSON RPC server. It can be used standalone, but it is also exported as part of Kit @trezoa/kit.

Unless you plan to create a custom RPC interface, you can use the createTrezoaRpc(clusterUrl) function to obtain a default implementation of the Trezoa JSON RPC API.

Types

RpcTransport{Devnet|Testnet|Mainnet}

These types refine the base RpcTransport type. Each describes a transport that is specific in some way to a particular Trezoa cluster.

For instance, a RpcTransportDevnet is understood to communicate with a RPC server related to devnet, and as such might only be accepted for use as the transport of a RpcDevnet.

This is useful in cases where you need to make assertions about what capabilities a RPC offers. For example, RPC methods like requestAirdrop are not available on mainnet. You can use the ability to assert on the type of RPC transport at compile time to prevent calling unimplemented methods or presuming the existence of unavailable capabilities.

RpcTransportFromClusterUrl<TClusterUrl extends ClusterUrl>

Given a ClusterUrl, this utility type will resolve to as specific a RpcTransport as possible.

function createCustomTransport<TClusterUrl extends ClusterUrl>(
    clusterUrl: TClusterUrl,
): RpcTransportFromClusterUrl<TClusterUrl> {
    /* ... */
}
const transport = createCustomTransport(testnet('http://api.testnet.trezoa.com'));
transport satisfies RpcTransportTestnet; // OK

Rpc{Devnet|Testnet|Mainnet}<TRpcMethods>

These types refine the base Rpc type. Each describes a RPC that is specific in some way to a particular Trezoa cluster and a corpus of RPC methods.

This is useful in cases where you need to make assertions about the suitability of a RPC for a given purpose. For example, you might like to make it a type error to combine certain types with RPCs belonging to certain clusters, at compile time.

async function getSpecialAccountInfo(
    address: Address<'ReAL1111111111111111111111111111'>,
    rpc: RpcMainnet<unknown>,
): Promise<SpecialAccountInfo>;
async function getSpecialAccountInfo(
    address: Address<'TeST1111111111111111111111111111'>,
    rpc: RpcDevnet<unknown> | RpcTestnet<unknown>,
): Promise<SpecialAccountInfo>;
async function getSpecialAccountInfo(address: Address, rpc: Rpc<unknown>): Promise<SpecialAccountInfo> {
    /* ... */
}
const rpc = createTrezoaRpc(devnet('https://api.devnet.trezoa.com'));
await getSpecialAccountInfo(address('ReAL1111111111111111111111111111'), rpc); // ERROR

RpcFromTransport<TRpcMethods, TRpcTransport extends RpcTransport>

Given a RpcTransport and a set of RPC methods denoted by TRpcMethods this utility type will resolve to a Rpc that supports those methods on as specific a cluster as possible.

function createCustomRpc<TRpcTransport extends RpcTransport>(
    transport: TRpcTransport,
): RpcFromTransport<MyCustomRpcMethods, TRpcTransport> {
    /* ... */
}
const transport = createDefaultRpcTransport({ url: mainnet('http://rpc.company') });
transport satisfies RpcTransportMainnet; // OK
const rpc = createCustomRpc(transport);
rpc satisfies RpcMainnet<MyCustomRpcMethods>; // OK

TrezoaRpcApiFromTransport

Given a RpcTransport this utility type will resolve to a union of all the methods of the Trezoa RPC API supported by the transport's cluster.

function createTrezoaRpcFromTransport<TTransport extends RpcTransport>(
    transport: TTransport,
): RpcFromTransport<TrezoaRpcApiFromTransport<TTransport>, TTransport> {
    /* ... */
}
const transport = createDefaultRpcTransport({ url: mainnet('http://rpc.company') });
transport satisfies RpcTransportMainnet; // OK
const rpc = createTrezoaRpcFromTransport(transport);
rpc satisfies RpcMainnet<TrezoaRpcApiMainnet>; // OK

Constants

DEFAULT_RPC_CONFIG

When you create Rpc instances with custom transports but otherwise the default RPC API behaviours, use this.

const myCustomRpc = createRpc({
    api: createTrezoaRpcApi(DEFAULT_RPC_CONFIG),
    transport: myCustomTransport,
});

Functions

createDefaultRpcTransport(config)

Creates a RpcTransport with some default behaviours.

The default behaviours include:

• An automatically-set Trezoa-Client request header, containing the version of @trezoa/kit
• Logic that coalesces multiple calls in the same runloop, for the same methods with the same arguments, into a single network request.
• [node-only] An automatically-set Accept-Encoding request header asking the server to compress responses

Arguments

A config object with the following properties:

• dispatcher_NODE_ONLY: An optional Undici.Dispatcher instance that governs how the networking stack should behave. This option is only relevant in Node applications. Consult the documentation for the various subclasses of Undici.Dispatcher, such as Agent, Client, and Pool, at https://undici.nodejs.org/#/docs/api/Client.
• headers: An optional object where the keys are HTTP header names and the values are HTTP header values. This parameter is typed to disallow certain headers from being overwritten.
• url: A ClusterUrl at which the RPC server can be contacted.

createTrezoaRpc(clusterUrl, config)

Creates a Rpc instance that exposes the Trezoa JSON RPC API given a cluster URL and some optional transport config. See createDefaultRpcTransport for the shape of the transport config.

createTrezoaRpcFromTransport(transport)

Creates a Rpc instance that exposes the Trezoa JSON RPC API given the supplied RpcTransport.