@solana/rpc-api 6.3.1 → 6.3.2-canary-20260313112147

package/src/getBlockTime.ts

@@ -0,0 +1,21 @@
+import type { Slot, UnixTimestamp } from '@solana/rpc-types';
+
+type GetBlockTimeApiResponse = UnixTimestamp;
+
+export type GetBlockTimeApi = {
+    /**
+     * Returns the estimated production time of a block.
+     *
+     * Each validator reports their UTC time to the ledger on a regular interval by intermittently
+     * adding a timestamp to a vote for a particular block. A requested block's time is calculated
+     * from the stake-weighted mean of the vote timestamps in a set of recent blocks recorded on the
+     * ledger.
+     *
+     * @returns Estimated production time, as Unix timestamp (seconds since the Unix epoch)
+     * @see https://solana.com/docs/rpc/http/getblocktime
+     */
+    getBlockTime(
+        /** Block number, identified by slot */
+        blockNumber: Slot,
+    ): GetBlockTimeApiResponse;
+};

package/src/getBlocks.ts

@@ -0,0 +1,34 @@
+import type { Commitment, Slot } from '@solana/rpc-types';
+
+type GetBlocksApiResponse = Slot[];
+
+export type GetBlocksApi = {
+    /**
+     * Returns a list of confirmed blocks between two slots (inclusive).
+     *
+     * @see https://solana.com/docs/rpc/http/getblocks
+     */
+    getBlocks(
+        /** The first slot for which to return a confirmed block */
+        startSlotInclusive: Slot,
+        /**
+         * The last slot for which to return a confirmed block.
+         *
+         * Must be no more than 500,000 blocks higher than the start slot.
+         *
+         * @defaultValue If not provided, defaults to the latest confirmed slot.
+         */
+        endSlotInclusive?: Slot,
+        config?: Readonly<{
+            /**
+             * Include only blocks at slots that have reached at least this level of commitment.
+             *
+             * @defaultValue Whichever default is applied by the underlying {@link RpcApi} in use.
+             * For example, when using an API created by a `createSolanaRpc*()` helper, the default
+             * commitment is `"confirmed"` unless configured otherwise. Unmitigated by an API layer
+             * on the client, the default commitment applied by the server is `"finalized"`.
+             */
+            commitment?: Exclude<Commitment, 'processed'>;
+        }>,
+    ): GetBlocksApiResponse;
+};

package/src/getBlocksWithLimit.ts

@@ -0,0 +1,33 @@
+import type { Commitment, Slot } from '@solana/rpc-types';
+
+type GetBlocksWithLimitApiResponse = Slot[];
+
+export type GetBlocksWithLimitApi = {
+    /**
+     * Returns a list of confirmed blocks starting at the given slot (inclusive). Returns up to the
+     * number of blocks specified by the limit.
+     *
+     * @see https://solana.com/docs/rpc/http/getblockswithlimit
+     */
+    getBlocksWithLimit(
+        /** The first slot for which to return a confirmed block */
+        startSlotInclusive: Slot,
+        /**
+         * The maximum number of blocks to return (between 0 and 500,000).
+         *
+         * Specifying 0 will result in an empty array being returned.
+         */
+        limit: number,
+        config?: Readonly<{
+            /**
+             * Include only blocks at slots that have reached at least this level of commitment.
+             *
+             * @defaultValue Whichever default is applied by the underlying {@link RpcApi} in use.
+             * For example, when using an API created by a `createSolanaRpc*()` helper, the default
+             * commitment is `"confirmed"` unless configured otherwise. Unmitigated by an API layer
+             * on the client, the default commitment applied by the server is `"finalized"`.
+             */
+            commitment?: Exclude<Commitment, 'processed'>;
+        }>,
+    ): GetBlocksWithLimitApiResponse;
+};

package/src/getClusterNodes.ts

@@ -0,0 +1,49 @@
+import { Address } from '@solana/addresses';
+
+type ClusterNode = Readonly<{
+    /**
+     * The unique identifier of the node's feature set.
+     *
+     * This value is computed by sorting all feature addresses' byte arrays lexicographically,
+     * hashing them, then taking the first 4 bytes of the result. This keeps the feature set value
+     * stable across versions until a new feature is introduced.
+     */
+    featureSet: number | null;
+    /** Gossip network address for the node (host:port) */
+    gossip: string | null;
+    /** Node public key, as base-58 encoded string */
+    pubkey: Address;
+    /** WebSocket PubSub network address for the node (host:port) */
+    pubsub: string | null;
+    /** JSON RPC network address for the node, or `null` if the JSON RPC service is not enabled */
+    rpc: string | null;
+    /** Server repair UDP network address for the node (host:port) */
+    serveRepair: string | null;
+    /** The shred version the node has been configured to use */
+    shredVersion: number | null;
+    /** TPU network address for the node (host:port) */
+    tpu: string | null;
+    /** Tpu UDP forwards network address for the node (host:port) */
+    tpuForwards: string | null;
+    /** Tpu QUIC forwards network address for the node (host:port) */
+    tpuForwardsQuic: string | null;
+    /** Tpu QUIC network address for the node (host:port) */
+    tpuQuic: string | null;
+    /** Tpu UDP vote network address for the node (host:port) */
+    tpuVote: string | null;
+    /** Tvu UDP network address for the node (host:port) */
+    tvu: string | null;
+    /** The software version of the node, or `null` if the version information is not available */
+    version: string | null;
+}>;
+
+type GetClusterNodesApiResponse = readonly ClusterNode[];
+
+export type GetClusterNodesApi = {
+    /**
+     * Returns information about all the nodes participating in the cluster.
+     *
+     * @see https://solana.com/docs/rpc/http/getclusternodes
+     */
+    getClusterNodes(): GetClusterNodesApiResponse;
+};

package/src/getEpochInfo.ts

@@ -0,0 +1,43 @@
+import type { Commitment, Slot } from '@solana/rpc-types';
+
+type GetEpochInfoApiResponse = Readonly<{
+    /** The current slot */
+    absoluteSlot: Slot;
+    /** The current block height */
+    blockHeight: bigint;
+    /** The current epoch */
+    epoch: bigint;
+    /** The current slot relative to the start of the current epoch */
+    slotIndex: bigint;
+    /** The number of slots in this epoch */
+    slotsInEpoch: bigint;
+    /** Total number of transactions processed without error since genesis */
+    transactionCount: bigint | null;
+}>;
+
+export type GetEpochInfoApi = {
+    /**
+     * Returns information about the current epoch.
+     *
+     * @see https://solana.com/docs/rpc/http/getepochinfo
+     */
+    getEpochInfo(
+        config?: Readonly<{
+            /**
+             * Fetch epoch information as of the highest slot that has reached this level of
+             * commitment.
+             *
+             * @defaultValue Whichever default is applied by the underlying {@link RpcApi} in use.
+             * For example, when using an API created by a `createSolanaRpc*()` helper, the default
+             * commitment is `"confirmed"` unless configured otherwise. Unmitigated by an API layer
+             * on the client, the default commitment applied by the server is `"finalized"`.
+             */
+            commitment?: Commitment;
+            /**
+             * Prevents accessing stale data by enforcing that the RPC node has processed
+             * transactions up to this slot
+             */
+            minContextSlot?: Slot;
+        }>,
+    ): GetEpochInfoApiResponse;
+};

package/src/getEpochSchedule.ts

@@ -0,0 +1,29 @@
+type GetEpochScheduleApiResponse = Readonly<{
+    /**
+     * First normal-length epoch after the warmup period,
+     * log2(slotsPerEpoch) - log2(MINIMUM_SLOTS_PER_EPOCH)
+     */
+    firstNormalEpoch: bigint;
+    /**
+     * The first slot after the warmup period, MINIMUM_SLOTS_PER_EPOCH * (2^(firstNormalEpoch) - 1)
+     */
+    firstNormalSlot: bigint;
+    /**
+     * The number of slots before beginning of an epoch to calculate a leader schedule for that
+     * epoch
+     */
+    leaderScheduleSlotOffset: bigint;
+    /** The maximum number of slots in each epoch */
+    slotsPerEpoch: bigint;
+    /** Whether epochs start short and grow */
+    warmup: boolean;
+}>;
+
+export type GetEpochScheduleApi = {
+    /**
+     * Returns the epoch schedule information from this cluster's genesis config
+     *
+     * @see https://solana.com/docs/rpc/http/getepochschedule
+     */
+    getEpochSchedule(): GetEpochScheduleApiResponse;
+};

package/src/getFeeForMessage.ts

@@ -0,0 +1,35 @@
+import type { Commitment, Lamports, Slot, SolanaRpcResponse } from '@solana/rpc-types';
+import type { TransactionMessageBytesBase64 } from '@solana/transactions';
+
+type GetFeeForMessageApiResponse = Lamports | null;
+
+export type GetFeeForMessageApi = {
+    /**
+     * Returns the fee the network will charge for a particular message
+     *
+     * @returns The fee that the network will charge to process the message, in {@link Lamports}, as
+     * computed at the specified blockhash.
+     * @see https://solana.com/docs/rpc/http/getfeeformessage
+     */
+    getFeeForMessage(
+        /** A transaction message encoded as a base64 string */
+        message: TransactionMessageBytesBase64,
+        config?: Readonly<{
+            /**
+             * Fetch the fee information as of the highest slot that has reached this level of
+             * commitment.
+             *
+             * @defaultValue Whichever default is applied by the underlying {@link RpcApi} in use.
+             * For example, when using an API created by a `createSolanaRpc*()` helper, the default
+             * commitment is `"confirmed"` unless configured otherwise. Unmitigated by an API layer
+             * on the client, the default commitment applied by the server is `"finalized"`.
+             */
+            commitment?: Commitment;
+            /**
+             * Prevents accessing stale data by enforcing that the RPC node has processed
+             * transactions up to this slot
+             */
+            minContextSlot?: Slot;
+        }>,
+    ): SolanaRpcResponse<GetFeeForMessageApiResponse>;
+};

package/src/getFirstAvailableBlock.ts

@@ -0,0 +1,17 @@
+import type { Slot } from '@solana/rpc-types';
+
+type GetFirstAvailableBlockApiResponse = Slot;
+
+export type GetFirstAvailableBlockApi = {
+    /**
+     * Returns the slot of the lowest confirmed block available on the node.
+     *
+     * Different nodes may offer more or less historical block data, depending on their
+     * configuration. An appropriately configured node should be able to access all blocks, from
+     * genesis onward. When it is not, this method will tell you the slot of the lowest block
+     * available.
+     *
+     * @see https://solana.com/docs/rpc/http/getfirstavailableblock
+     */
+    getFirstAvailableBlock(): GetFirstAvailableBlockApiResponse;
+};

package/src/getGenesisHash.ts

@@ -0,0 +1,13 @@
+import type { Base58EncodedBytes } from '@solana/rpc-types';
+
+type GetGenesisHashApiResponse = Base58EncodedBytes;
+
+export type GetGenesisHashApi = {
+    /**
+     * Returns the genesis hash.
+     *
+     * @returns A SHA-256 hash of the network's genesis config.
+     * @see https://solana.com/docs/rpc/http/getgenesishash
+     */
+    getGenesisHash(): GetGenesisHashApiResponse;
+};

package/src/getHealth.ts

@@ -0,0 +1,17 @@
+type GetHealthApiResponse = 'ok';
+
+export type GetHealthApi = {
+    /**
+     * Returns the health status of the node.
+     *
+     * A healthy node is one that is within _n_ slots of the latest cluster-confirmed slot, where
+     * _n_ is a node-configurable parameter with a
+     * [default of 128](https://github.com/anza-xyz/agave/blob/a080c4bb157f48b268b74cf5dd2f3de39db7dc5d/rpc-client-types/src/request.rs#L157).
+     *
+     * @returns The string "ok" if the node is healthy.
+     * @throws {SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NODE_UNHEALTHY} if the node is unhealthy. The
+     * specifics of the error response are unstable and may change in the future.
+     * @see https://solana.com/docs/rpc/http/gethealth
+     */
+    getHealth(): GetHealthApiResponse;
+};

package/src/getHighestSnapshotSlot.ts

@@ -0,0 +1,23 @@
+import type { Slot } from '@solana/rpc-types';
+
+type GetHighestSnapshotSlotApiResponse = Readonly<{
+    /** The highest full snapshot slot */
+    full: Slot;
+    /**
+     * The highest incremental snapshot slot based on the slot indicated by
+     * {@link GetHighestSnapshotSlotApiResponse.full | full}
+     */
+    incremental: Slot | null;
+}>;
+
+export type GetHighestSnapshotSlotApi = {
+    /**
+     * Returns the highest slot information that the node has snapshots for.
+     *
+     * This will find the highest full snapshot slot, and the highest incremental snapshot slot
+     * based on the full snapshot slot, if there is one.
+     *
+     * @see https://solana.com/docs/rpc/http/gethighestsnapshotslot
+     */
+    getHighestSnapshotSlot(): GetHighestSnapshotSlotApiResponse;
+};

package/src/getIdentity.ts

@@ -0,0 +1,14 @@
+import type { Address } from '@solana/addresses';
+
+type GetIdentityApiResponse = Readonly<{
+    identity: Address;
+}>;
+
+export type GetIdentityApi = {
+    /**
+     * Returns the identity pubkey for the current node.
+     *
+     * @see https://solana.com/docs/rpc/http/getidentity
+     */
+    getIdentity(): GetIdentityApiResponse;
+};

package/src/getInflationGovernor.ts

@@ -0,0 +1,39 @@
+import type { Commitment, F64UnsafeSeeDocumentation } from '@solana/rpc-types';
+
+type GetInflationGovernorApiResponse = Readonly<{
+    /** Percentage of total inflation allocated to the foundation */
+    foundation: F64UnsafeSeeDocumentation;
+    /** Duration of foundation pool inflation in years */
+    foundationTerm: F64UnsafeSeeDocumentation;
+    /** The initial inflation percentage from time 0 */
+    initial: F64UnsafeSeeDocumentation;
+    /**
+     * Rate per year at which inflation is lowered. (Rate reduction is derived using the target slot
+     * time in genesis config)
+     */
+    taper: F64UnsafeSeeDocumentation;
+    /** Terminal inflation percentage */
+    terminal: F64UnsafeSeeDocumentation;
+}>;
+
+export type GetInflationGovernorApi = {
+    /**
+     * Returns the current inflation governor.
+     *
+     * @see https://solana.com/docs/rpc/http/getinflationgovernor
+     */
+    getInflationGovernor(
+        config?: Readonly<{
+            /**
+             * Return the inflation governor as of the highest slot that has reached this level of
+             * commitment.
+             *
+             * @defaultValue Whichever default is applied by the underlying {@link RpcApi} in use.
+             * For example, when using an API created by a `createSolanaRpc*()` helper, the default
+             * commitment is `"confirmed"` unless configured otherwise. Unmitigated by an API layer
+             * on the client, the default commitment applied by the server is `"finalized"`.
+             */
+            commitment?: Commitment;
+        }>,
+    ): GetInflationGovernorApiResponse;
+};

package/src/getInflationRate.ts

@@ -0,0 +1,21 @@
+import type { F64UnsafeSeeDocumentation } from '@solana/rpc-types';
+
+type GetInflationRateApiResponse = Readonly<{
+    /** Epoch for which these values are valid */
+    epoch: bigint;
+    /** Inflation allocated to the foundation */
+    foundation: F64UnsafeSeeDocumentation;
+    /** Total inflation */
+    total: F64UnsafeSeeDocumentation;
+    /** Inflation allocated to validators */
+    validator: F64UnsafeSeeDocumentation;
+}>;
+
+export type GetInflationRateApi = {
+    /**
+     * Returns the specific inflation values for the current epoch.
+     *
+     * @see https://solana.com/docs/rpc/http/getinflationrate
+     */
+    getInflationRate(): GetInflationRateApiResponse;
+};

package/src/getInflationReward.ts

@@ -0,0 +1,53 @@
+import type { Address } from '@solana/addresses';
+import type { Commitment, Lamports, Slot } from '@solana/rpc-types';
+
+type GetInflationRewardApiConfig = Readonly<{
+    /**
+     * Fetch the inflation reward details as of the highest slot that has reached this level of
+     * commitment.
+     *
+     * @defaultValue Whichever default is applied by the underlying {@link RpcApi} in use. For
+     * example, when using an API created by a `createSolanaRpc*()` helper, the default commitment
+     * is `"confirmed"` unless configured otherwise. Unmitigated by an API layer on the client, the
+     * default commitment applied by the server is `"finalized"`.
+     */
+    commitment?: Commitment;
+    /**
+     * An epoch for which the reward occurs.
+     *
+     * @defaultValue If omitted, the previous epoch will be used.
+     */
+    epoch?: bigint;
+    /**
+     * Prevents accessing stale data by enforcing that the RPC node has processed transactions up to
+     * this slot
+     */
+    minContextSlot?: Slot;
+}>;
+
+type InflationReward = Readonly<{
+    /** Reward amount in {@link Lamports} */
+    amount: Lamports;
+    /** Vote account commission when the reward was credited */
+    commission: number;
+    /** The slot in which the rewards are delivered */
+    effectiveSlot: Slot;
+    /** Epoch for which reward occurred */
+    epoch: bigint;
+    /** Post balance of the account in {@link Lamports} */
+    postBalance: Lamports;
+}>;
+
+type GetInflationRewardApiResponse = readonly (InflationReward | null)[];
+
+export type GetInflationRewardApi = {
+    /**
+     * Returns the inflation / staking reward for a list of addresses for an epoch.
+     *
+     * @see https://solana.com/docs/rpc/http/getinflationreward
+     */
+    getInflationReward(
+        addresses: readonly Address[],
+        config?: GetInflationRewardApiConfig,
+    ): GetInflationRewardApiResponse;
+};

package/src/getLargestAccounts.ts

@@ -0,0 +1,42 @@
+import type { Address } from '@solana/addresses';
+import type { Commitment, Lamports, SolanaRpcResponse } from '@solana/rpc-types';
+
+type GetLargestAccountsResponseItem = Readonly<{
+    /** Base-58 encoded address of the account */
+    address: Address;
+    /** Number of {@link Lamports} in the account */
+    lamports: Lamports;
+}>;
+
+type GetLargestAccountsApiResponse = readonly GetLargestAccountsResponseItem[];
+
+export type GetLargestAccountsApi = {
+    /**
+     * Returns the 20 largest accounts, by {@link Lamports | Lamport} balance.
+     *
+     * Results may be cached up to two hours.
+     *
+     * @see https://solana.com/docs/rpc/http/getlargestaccounts
+     */
+    getLargestAccounts(
+        config?: Readonly<{
+            /**
+             * Fetch the largest accounts as of the highest slot that has reached this level of
+             * commitment.
+             *
+             * @defaultValue Whichever default is applied by the underlying {@link RpcApi} in use.
+             * For example, when using an API created by a `createSolanaRpc*()` helper, the default
+             * commitment is `"confirmed"` unless configured otherwise. Unmitigated by an API layer
+             * on the client, the default commitment applied by the server is `"finalized"`.
+             */
+            commitment?: Commitment;
+            /**
+             * Filter results by account type.
+             *
+             * @defaultValue When not specified, all accounts will be considered regardless of their
+             * type.
+             */
+            filter?: 'circulating' | 'nonCirculating';
+        }>,
+    ): SolanaRpcResponse<GetLargestAccountsApiResponse>;
+};

package/src/getLatestBlockhash.ts

@@ -0,0 +1,40 @@
+import type { Blockhash, Commitment, Slot, SolanaRpcResponse } from '@solana/rpc-types';
+
+type GetLatestBlockhashApiResponse = Readonly<{
+    /** A SHA-256 hash as base-58 encoded string */
+    blockhash: Blockhash;
+    /**
+     * Last block height at which the blockhash will be considered a valid lifetime specifier with
+     * which to land a transaction.
+     *
+     * @see {@link setTransactionMessageLifetimeUsingBlockhash}
+     */
+    lastValidBlockHeight: bigint;
+}>;
+
+export type GetLatestBlockhashApi = {
+    /**
+     * Returns the blockhash of the latest block.
+     *
+     * @see https://solana.com/docs/rpc/http/getlatestblockhash
+     */
+    getLatestBlockhash(
+        config?: Readonly<{
+            /**
+             * Fetch the latest blockhash as of the highest slot that has reached this level of
+             * commitment.
+             *
+             * @defaultValue Whichever default is applied by the underlying {@link RpcApi} in use.
+             * For example, when using an API created by a `createSolanaRpc*()` helper, the default
+             * commitment is `"confirmed"` unless configured otherwise. Unmitigated by an API layer
+             * on the client, the default commitment applied by the server is `"finalized"`.
+             */
+            commitment?: Commitment;
+            /**
+             * Prevents accessing stale data by enforcing that the RPC node has processed
+             * transactions up to this slot
+             */
+            minContextSlot?: Slot;
+        }>,
+    ): SolanaRpcResponse<GetLatestBlockhashApiResponse>;
+};

package/src/getLeaderSchedule.ts

@@ -0,0 +1,103 @@
+import type { Address } from '@solana/addresses';
+import type { Commitment, Slot } from '@solana/rpc-types';
+
+type GetLeaderScheduleApiConfigBase = Readonly<{
+    /**
+     * Fetch the leader schedule as of the highest slot that has reached this level of commitment.
+     *
+     * @defaultValue Whichever default is applied by the underlying {@link RpcApi} in use. For
+     * example, when using an API created by a `createSolanaRpc*()` helper, the default commitment
+     * is `"confirmed"` unless configured otherwise. Unmitigated by an API layer on the client, the
+     * default commitment applied by the server is `"finalized"`.
+     */
+    commitment?: Commitment;
+}>;
+
+// A dictionary of validator identities as base-58 encoded strings, and their corresponding leader
+// slot indices as values relative to the first slot in the requested epoch.
+//
+// @example
+// ```json
+// {
+//   "4Qkev8aNZcqFNSRhQzwyLMFSsi94jHqE8WNVTJzTP99F": [
+//     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+//     21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
+//     39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
+//     57, 58, 59, 60, 61, 62, 63
+//   ]
+// }
+// ```
+type GetLeaderScheduleApiResponseWithAllIdentities = Record<Address, Slot[]>;
+
+type GetLeaderScheduleApiResponseWithSingleIdentity<TIdentity extends string> = Readonly<{
+    [TAddress in TIdentity]?: Slot[];
+}>;
+
+export type GetLeaderScheduleApi = {
+    /**
+     * Fetch the leader schedule of a particular validator.
+     *
+     * @param slot A slot that will be used to select the epoch for which to return the leader
+     * schedule.
+     *
+     * @returns A dictionary having a single key representing the specified validator identity, and
+     * its corresponding leader slot indices as values relative to the first slot in the requested
+     * epoch, or `null` if there is no epoch that corresponds to the given slot.
+     * @see https://solana.com/docs/rpc/http/getleaderschedule
+     */
+    getLeaderSchedule<TIdentity extends Address>(
+        slot: Slot,
+        config: GetLeaderScheduleApiConfigBase &
+            Readonly<{
+                /** Only return results for this validator identity (base58 encoded address) */
+                identity: Address;
+            }>,
+    ): GetLeaderScheduleApiResponseWithSingleIdentity<TIdentity> | null;
+    /**
+     * Fetch the leader schedule for all validators.
+     *
+     * @param slot A slot that will be used to select the epoch for which to return the leader
+     * schedule.
+     *
+     * @returns A dictionary of validator identities as base-58 encoded strings, and their
+     * corresponding leader slot indices as values relative to the first slot in the requested
+     * epoch, or `null` if there is no epoch that corresponds to the given slot.
+     * @see https://solana.com/docs/rpc/http/getleaderschedule
+     */
+    getLeaderSchedule(
+        slot: Slot,
+        config?: GetLeaderScheduleApiConfigBase,
+    ): GetLeaderScheduleApiResponseWithAllIdentities | null;
+    /**
+     * Fetch the leader schedule of a particular validator.
+     *
+     * @param slot When `null`, orders the leader schedule for the current epoch.
+     *
+     * @returns A dictionary having a single key representing the specified validator identity, and
+     * its corresponding leader slot indices as values relative to the first slot in the current
+     * epoch.
+     * @see https://solana.com/docs/rpc/http/getleaderschedule
+     */
+    getLeaderSchedule<TIdentity extends Address>(
+        slot: null,
+        config: GetLeaderScheduleApiConfigBase &
+            Readonly<{
+                /** Only return results for this validator identity (base58 encoded address) */
+                identity: Address;
+            }>,
+    ): GetLeaderScheduleApiResponseWithSingleIdentity<TIdentity>;
+    /**
+     * Fetch the leader schedule of all validators.
+     *
+     * @param slot When `null`, orders the leader schedule for the current epoch.
+     *
+     * @returns A dictionary of validator identities as base-58 encoded strings, and their
+     * corresponding leader slot indices as values relative to the first slot in the current
+     * epoch.
+     * @see https://solana.com/docs/rpc/http/getleaderschedule
+     */
+    getLeaderSchedule(
+        slot?: null,
+        config?: GetLeaderScheduleApiConfigBase,
+    ): GetLeaderScheduleApiResponseWithAllIdentities;
+};

package/src/getMaxRetransmitSlot.ts

@@ -0,0 +1,12 @@
+import type { Slot } from '@solana/rpc-types';
+
+type GetMaxRetransmitSlotApiResponse = Slot;
+
+export type GetMaxRetransmitSlotApi = {
+    /**
+     * Get the max slot seen from retransmit stage.
+     *
+     * @see https://solana.com/docs/rpc/http/getmaxretransmitslot
+     */
+    getMaxRetransmitSlot(): GetMaxRetransmitSlotApiResponse;
+};