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

package/src/getMaxShredInsertSlot.ts

@@ -0,0 +1,12 @@
+import type { Slot } from '@solana/rpc-types';
+
+type GetMaxShredInsertSlotApiResponse = Slot;
+
+export type GetMaxShredInsertSlotApi = {
+    /**
+     * Get the max slot seen from after shred insert.
+     *
+     * @see https://solana.com/docs/rpc/http/getmaxshredinsertslot
+     */
+    getMaxShredInsertSlot(): GetMaxShredInsertSlotApiResponse;
+};

package/src/getMinimumBalanceForRentExemption.ts

@@ -0,0 +1,32 @@
+import type { Commitment, Lamports } from '@solana/rpc-types';
+
+type GetMinimumBalanceForRentExemptionApiResponse = Lamports;
+
+export type GetMinimumBalanceForRentExemptionApi = {
+    /**
+     * Returns the minimum balance required to exempt an account from rent collection.
+     *
+     * @returns The minimum {@link Lamports | Lamport} balance required to grant an account of the
+     * specified size an exemption from rent collection.
+     * @see https://solana.com/docs/rpc/http/getminimumbalanceforrentexemption
+     */
+    getMinimumBalanceForRentExemption(
+        /**
+         * The number of bytes of account data for which an exemption from rent collection is being
+         * sought.
+         */
+        size: bigint,
+        config?: Readonly<{
+            /**
+             * Return the minimum balance 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;
+        }>,
+    ): GetMinimumBalanceForRentExemptionApiResponse;
+};

package/src/getMultipleAccounts.ts

@@ -0,0 +1,156 @@
+import type { Address } from '@solana/addresses';
+import type {
+    AccountInfoBase,
+    AccountInfoWithBase58EncodedData,
+    AccountInfoWithBase64EncodedData,
+    AccountInfoWithBase64EncodedZStdCompressedData,
+    AccountInfoWithJsonData,
+    Commitment,
+    DataSlice,
+    Slot,
+    SolanaRpcResponse,
+} from '@solana/rpc-types';
+
+type GetMultipleAccountsApiResponseBase = AccountInfoBase | null;
+
+type GetMultipleAccountsApiCommonConfig = Readonly<{
+    /**
+     * Fetch the details of the 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;
+    /**
+     * Determines how the accounts' data should be encoded in the response.
+     *
+     * - `'base58'` returns a tuple whose first element is the data as a base58-encoded string. If
+     *   the account contains more than 129 bytes of data, an error will be raised.
+     * - `'base64'` returns a tuple whose first element is the data as a base64-encoded string.
+     * - `'base64+zstd'` returns a tuple whose first element is the
+     *   [ZStandard](https://facebook.github.io/zstd/)-compressed data as a base64-encoded string.
+     * - `'jsonParsed'` will cause the server to attempt to process the data using a parser specific
+     *   to each account's owning program. If successful, the parsed data will be returned in the
+     *   response as JSON. Otherwise, the raw account data will be returned in the response as a
+     *   tuple whose first element is a base64-encoded string.
+     */
+    encoding?: 'base58' | 'base64' | 'base64+zstd' | 'jsonParsed';
+    /**
+     * Prevents accessing stale data by enforcing that the RPC node has processed transactions up to
+     * this slot
+     */
+    minContextSlot?: Slot;
+}>;
+
+type GetMultipleAccountsApiSliceableCommonConfig = Readonly<{
+    /**
+     * Define which slice of the accounts' data you want the RPC to return.
+     *
+     * Use this to save network bandwidth and encoding time when you do not need the entire buffer.
+     *
+     * Data slicing is only available for `"base58"`, `"base64"`, and `"base64+zstd"` encodings.
+     */
+    dataSlice?: DataSlice;
+}>;
+
+export type GetMultipleAccountsApi = {
+    /**
+     * Fetches information associated with the accounts at the given addresses.
+     *
+     * If the accounts have data, it will be returned in the response as a tuple whose first element
+     * is a base64-encoded string.
+     *
+     * @param addresses A maximum of 100 addresses for which to fetch account data
+     *
+     * {@label base64}
+     * @see https://solana.com/docs/rpc/http/getmultipleaccounts
+     */
+    getMultipleAccounts(
+        addresses: readonly Address[],
+        config: GetMultipleAccountsApiCommonConfig &
+            GetMultipleAccountsApiSliceableCommonConfig &
+            Readonly<{
+                encoding: 'base64';
+            }>,
+    ): SolanaRpcResponse<(GetMultipleAccountsApiResponseBase & (AccountInfoWithBase64EncodedData | null))[]>;
+    /**
+     * Fetches information associated with the accounts at the given addresses.
+     *
+     * If the accounts have data, it will first be compressed using
+     * [ZStandard](https://facebook.github.io/zstd/) and the result will be returned in the response
+     * as a tuple whose first element is a base64-encoded string.
+     *
+     * @param addresses A maximum of 100 addresses for which to fetch account data
+     *
+     * {@label base64-zstd-compressed}
+     * @see https://solana.com/docs/rpc/http/getmultipleaccounts
+     */
+    getMultipleAccounts(
+        addresses: readonly Address[],
+        config: GetMultipleAccountsApiCommonConfig &
+            GetMultipleAccountsApiSliceableCommonConfig &
+            Readonly<{
+                encoding: 'base64+zstd';
+            }>,
+    ): SolanaRpcResponse<
+        (GetMultipleAccountsApiResponseBase & (AccountInfoWithBase64EncodedZStdCompressedData | null))[]
+    >;
+    /**
+     * Fetches information associated with the accounts at the given addresses.
+     *
+     * If the accounts have data, the server will attempt to process it using a parser specific to
+     * each account's owning program. If successful, the parsed data will be returned in the
+     * response as JSON. Otherwise, the raw account data will be returned in the response as a tuple
+     * whose first element is a base64-encoded string.
+     *
+     * @param addresses A maximum of 100 addresses for which to fetch account data
+     *
+     * {@label parsed}
+     * @see https://solana.com/docs/rpc/http/getmultipleaccounts
+     */
+    getMultipleAccounts(
+        addresses: readonly Address[],
+        config: GetMultipleAccountsApiCommonConfig &
+            Readonly<{
+                encoding: 'jsonParsed';
+            }>,
+    ): SolanaRpcResponse<(GetMultipleAccountsApiResponseBase & (AccountInfoWithJsonData | null))[]>;
+    /**
+     * Fetches information associated with the accounts at the given addresses.
+     *
+     * If the accounts have data, it will be returned in the response as a tuple whose first element
+     * is a base58-encoded string. If any account contains more than 129 bytes of data, this method
+     * will raise an error.
+     *
+     * @param addresses A maximum of 100 addresses for which to fetch account data
+     *
+     * {@label base58}
+     * @see https://solana.com/docs/rpc/http/getmultipleaccounts
+     */
+    getMultipleAccounts(
+        addresses: readonly Address[],
+        config: GetMultipleAccountsApiCommonConfig &
+            GetMultipleAccountsApiSliceableCommonConfig &
+            Readonly<{
+                encoding: 'base58';
+            }>,
+    ): SolanaRpcResponse<(GetMultipleAccountsApiResponseBase & (AccountInfoWithBase58EncodedData | null))[]>;
+    /**
+     * Fetches information associated with the accounts at the given addresses.
+     *
+     * If the accounts have data, it will be returned in the response as a base58-encoded string. If
+     * any account contains more than 129 bytes of data, this method will raise an error.
+     *
+     * @param addresses A maximum of 100 addresses for which to fetch account data
+     *
+     * {@label base58-legacy}
+     * @see https://solana.com/docs/rpc/http/getmultipleaccounts
+     */
+    getMultipleAccounts(
+        addresses: readonly Address[],
+        config?: GetMultipleAccountsApiCommonConfig,
+    ): SolanaRpcResponse<(GetMultipleAccountsApiResponseBase & (AccountInfoWithBase64EncodedData | null))[]>;
+};

package/src/getProgramAccounts.ts

@@ -0,0 +1,264 @@
+import type { Address } from '@solana/addresses';
+import type {
+    AccountInfoBase,
+    AccountInfoWithBase58Bytes,
+    AccountInfoWithBase58EncodedData,
+    AccountInfoWithBase64EncodedData,
+    AccountInfoWithBase64EncodedZStdCompressedData,
+    AccountInfoWithJsonData,
+    AccountInfoWithPubkey,
+    Commitment,
+    DataSlice,
+    GetProgramAccountsDatasizeFilter,
+    GetProgramAccountsMemcmpFilter,
+    Slot,
+    SolanaRpcResponse,
+} from '@solana/rpc-types';
+
+type GetProgramAccountsApiCommonConfig = Readonly<{
+    /**
+     * Fetch the details of the 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;
+    /**
+     * Determines how the accounts' data should be encoded in the response.
+     *
+     * - `'base58'` returns a tuple whose first element is the data as a base58-encoded string. If
+     *   the account contains more than 129 bytes of data, an error will be raised.
+     * - `'base64'` returns a tuple whose first element is the data as a base64-encoded string.
+     * - `'base64+zstd'` returns a tuple whose first element is the
+     *   [ZStandard](https://facebook.github.io/zstd/)-compressed data as a base64-encoded string.
+     * - `'jsonParsed'` will cause the server to attempt to process the data using a parser specific
+     *   to the owning program. If successful, the parsed data will be returned in the response as
+     *   JSON. Otherwise, the raw account data will be returned in the response as a tuple whose
+     *   first element is a base64-encoded string.
+     */
+    encoding?: 'base58' | 'base64' | 'base64+zstd' | 'jsonParsed';
+    /**
+     * Limits results to those that match all of these filters.
+     *
+     * This is useful when your aim is to find program accounts whose purpose is uniquely determined
+     * by having a data buffer of a known size, or whose data contains a known series of bytes (eg.
+     * a discriminator).
+     *
+     * You can specify up to 4 filters.
+     *
+     * @defaultValue When omitted, no filters are applied.
+     */
+    filters?: readonly (GetProgramAccountsDatasizeFilter | GetProgramAccountsMemcmpFilter)[];
+    /**
+     * Prevents accessing stale data by enforcing that the RPC node has processed transactions up to
+     * this slot
+     */
+    minContextSlot?: Slot;
+    /**
+     * Wraps the result in an {@link RpcResponse} when `true`
+     *
+     * @defaultValue false
+     */
+    withContext?: boolean;
+}>;
+
+type GetProgramAccountsApiSliceableCommonConfig = Readonly<{
+    /**
+     * Define which slice of the accounts' data you want the RPC to return.
+     *
+     * Use this to save network bandwidth and encoding time when you do not need the entire buffer.
+     *
+     * Data slicing is only available for `"base58"`, `"base64"`, and `"base64+zstd"` encodings.
+     */
+    dataSlice?: DataSlice;
+}>;
+
+export type GetProgramAccountsApi = {
+    /**
+     * Fetches information associated with all accounts owned by the program at the given address.
+     *
+     * If the accounts have data, it will be returned in the response as a tuple whose first element
+     * is a base64-encoded string.
+     *
+     * {@label base64-withcontext}
+     * @see https://solana.com/docs/rpc/http/getprogramaccounts
+     */
+    getProgramAccounts(
+        program: Address,
+        config: GetProgramAccountsApiCommonConfig &
+            GetProgramAccountsApiSliceableCommonConfig &
+            Readonly<{
+                encoding: 'base64';
+                withContext: true;
+            }>,
+    ): SolanaRpcResponse<AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase64EncodedData>[]>;
+    /**
+     * Fetches information associated with all accounts owned by the program at the given address.
+     *
+     * If the accounts have data, it will be returned in the response as a tuple whose first element
+     * is a base64-encoded string.
+     *
+     * {@label base64}
+     * @see https://solana.com/docs/rpc/http/getprogramaccounts
+     */
+    getProgramAccounts(
+        program: Address,
+        config: GetProgramAccountsApiCommonConfig &
+            GetProgramAccountsApiSliceableCommonConfig &
+            Readonly<{
+                encoding: 'base64';
+                withContext?: boolean;
+            }>,
+    ): AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase64EncodedData>[];
+    /**
+     * Fetches information associated with all accounts owned by the program at the given address.
+     *
+     * If the accounts have data, it will first be compressed using
+     * [ZStandard](https://facebook.github.io/zstd/) and the result will be returned in the response
+     * as a tuple whose first element is a base64-encoded string.
+     *
+     * {@label base64-zstd-compressed-withcontext}
+     * @see https://solana.com/docs/rpc/http/getprogramaccounts
+     */
+    getProgramAccounts(
+        program: Address,
+        config: GetProgramAccountsApiCommonConfig &
+            GetProgramAccountsApiSliceableCommonConfig &
+            Readonly<{
+                encoding: 'base64+zstd';
+                withContext: true;
+            }>,
+    ): SolanaRpcResponse<AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase64EncodedZStdCompressedData>[]>;
+    /**
+     * Fetches information associated with all accounts owned by the program at the given address.
+     *
+     * If the accounts have data, it will first be compressed using
+     * [ZStandard](https://facebook.github.io/zstd/) and the result will be returned in the response
+     * as a tuple whose first element is a base64-encoded string.
+     *
+     * {@label base64-zstd-compressed}
+     * @see https://solana.com/docs/rpc/http/getprogramaccounts
+     */
+    getProgramAccounts(
+        program: Address,
+        config: GetProgramAccountsApiCommonConfig &
+            GetProgramAccountsApiSliceableCommonConfig &
+            Readonly<{
+                encoding: 'base64+zstd';
+                withContext?: boolean;
+            }>,
+    ): AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase64EncodedZStdCompressedData>[];
+    /**
+     * Fetches information associated with all accounts owned by the program at the given address.
+     *
+     * If the accounts have data, the server will attempt to process it using a parser specific to
+     * the owning program. If successful, the parsed data will be returned in the response as JSON.
+     * Otherwise, the raw account data will be returned in the response as a tuple whose first
+     * element is a base64-encoded string.
+     *
+     * {@label parsed-withcontext}
+     * @see https://solana.com/docs/rpc/http/getprogramaccounts
+     */
+    getProgramAccounts(
+        program: Address,
+        config: GetProgramAccountsApiCommonConfig &
+            Readonly<{
+                encoding: 'jsonParsed';
+                withContext: true;
+            }>,
+    ): SolanaRpcResponse<AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithJsonData>[]>;
+    /**
+     * Fetches information associated with all accounts owned by the program at the given address.
+     *
+     * If the accounts have data, the server will attempt to process it using a parser specific to
+     * the owning program. If successful, the parsed data will be returned in the response as JSON.
+     * Otherwise, the raw account data will be returned in the response as a tuple whose first
+     * element is a base64-encoded string.
+     *
+     * {@label parsed}
+     * @see https://solana.com/docs/rpc/http/getprogramaccounts
+     */
+    getProgramAccounts(
+        program: Address,
+        config: GetProgramAccountsApiCommonConfig &
+            Readonly<{
+                encoding: 'jsonParsed';
+                withContext?: boolean;
+            }>,
+    ): AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithJsonData>[];
+    /**
+     * Fetches information associated with all accounts owned by the program at the given address.
+     *
+     * If the accounts have data, it will be returned in the response as a tuple whose first element
+     * is a base58-encoded string. If any account contains more than 129 bytes of data, this method
+     * will raise an error.
+     *
+     * {@label base58-withcontext}
+     * @see https://solana.com/docs/rpc/http/getprogramaccounts
+     */
+    getProgramAccounts(
+        program: Address,
+        config: GetProgramAccountsApiCommonConfig &
+            GetProgramAccountsApiSliceableCommonConfig &
+            Readonly<{
+                encoding: 'base58';
+                withContext: true;
+            }>,
+    ): SolanaRpcResponse<AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase58EncodedData>[]>;
+    /**
+     * Fetches information associated with all accounts owned by the program at the given address.
+     *
+     * If the accounts have data, it will be returned in the response as a tuple whose first element
+     * is a base58-encoded string. If any account contains more than 129 bytes of data, this method
+     * will raise an error.
+     *
+     * {@label base58}
+     * @see https://solana.com/docs/rpc/http/getprogramaccounts
+     */
+    getProgramAccounts(
+        program: Address,
+        config: GetProgramAccountsApiCommonConfig &
+            GetProgramAccountsApiSliceableCommonConfig &
+            Readonly<{
+                encoding: 'base58';
+                withContext?: boolean;
+            }>,
+    ): AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase58EncodedData>[];
+    /**
+     * Fetches information associated with all accounts owned by the program at the given address.
+     *
+     * If the accounts have data, it will be returned in the response as a base58-encoded string. If
+     * any account contains more than 129 bytes of data, this method will raise an error.
+     *
+     * {@label base58-legacy-withcontext}
+     * @see https://solana.com/docs/rpc/http/getprogramaccounts
+     */
+    getProgramAccounts(
+        program: Address,
+        config: GetProgramAccountsApiCommonConfig &
+            GetProgramAccountsApiSliceableCommonConfig &
+            Readonly<{
+                withContext: true;
+            }>,
+    ): SolanaRpcResponse<AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase58Bytes>[]>;
+    /**
+     * Fetches information associated with all accounts owned by the program at the given address.
+     *
+     * If the accounts have data, it will be returned in the response as a base58-encoded string. If
+     * any account contains more than 129 bytes of data, this method will raise an error.
+     *
+     * {@label base58-legacy-withcontext}
+     * @see https://solana.com/docs/rpc/http/getprogramaccounts
+     */
+    getProgramAccounts(
+        program: Address,
+        config?: GetProgramAccountsApiCommonConfig &
+            GetProgramAccountsApiSliceableCommonConfig &
+            Readonly<{
+                withContext?: boolean;
+            }>,
+    ): AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase58Bytes>[];
+};

package/src/getRecentPerformanceSamples.ts

@@ -0,0 +1,29 @@
+import type { Slot } from '@solana/rpc-types';
+
+type PerformanceSample = Readonly<{
+    /** Number of non-vote transactions in sample */
+    numNonVoteTransactions: bigint;
+    /** Number of slots in sample */
+    numSlots: bigint;
+    /** Number of transactions in sample */
+    numTransactions: bigint;
+    /** Number of seconds in a sample window */
+    samplePeriodSecs: number;
+    /** Slot in which sample was taken at */
+    slot: Slot;
+}>;
+
+type GetRecentPerformanceSamplesApiResponse = readonly PerformanceSample[];
+
+export type GetRecentPerformanceSamplesApi = {
+    /**
+     * Returns a list of recent performance samples, in reverse slot order.
+     *
+     * Performance samples are taken every 60 seconds and include the number of transactions and
+     * slots that occur in a given time window.
+     *
+     * @param limit Number of samples to return. Maximum of 720.
+     * @see https://solana.com/docs/rpc/http/getrecentperformancesamples
+     */
+    getRecentPerformanceSamples(limit?: number): GetRecentPerformanceSamplesApiResponse;
+};

package/src/getRecentPrioritizationFees.ts

@@ -0,0 +1,28 @@
+import type { Address } from '@solana/addresses';
+import type { MicroLamports, Slot } from '@solana/rpc-types';
+
+type RecentPrioritizationFee = Readonly<{
+    /**
+     * The smallest per-compute-unit fee paid by at least one successfully landed transaction,
+     * specified in increments of {@link MicroLamports} (0.000001 {@link Lamports}).
+     */
+    prioritizationFee: MicroLamports;
+    /** Slot in which the fee was observed */
+    slot: Slot;
+}>;
+
+type GetRecentPrioritizationFeesApiResponse = readonly RecentPrioritizationFee[];
+
+export type GetRecentPrioritizationFeesApi = {
+    /**
+     * Returns a list of the smallest prioritization fees paid in recent blocks.
+     *
+     * Currently, a node's prioritization-fee cache stores data from up to 150 blocks.
+     *
+     * @param addresses A maximum of 128 addresses. When supplied, the response will reflect the
+     * prioritization fee paid for transactions which take a write-lock on all of them.
+     *
+     * @see https://solana.com/docs/rpc/http/getrecentprioritizationfees
+     */
+    getRecentPrioritizationFees(addresses?: readonly Address[]): GetRecentPrioritizationFeesApiResponse;
+};

package/src/getSignatureStatuses.ts

@@ -0,0 +1,62 @@
+import type { Signature } from '@solana/keys';
+import type { Commitment, Slot, SolanaRpcResponse, TransactionError } from '@solana/rpc-types';
+
+/** @deprecated */
+type TransactionStatusOk = Readonly<{
+    Ok: null;
+}>;
+
+/** @deprecated */
+type TransactionStatusErr = Readonly<{
+    Err: TransactionError;
+}>;
+
+type SignatureStatusResult = Readonly<{
+    /**
+     * The transaction's cluster confirmation status; either `processed`, `confirmed`, or
+     * `finalized`.
+     */
+    confirmationStatus: Commitment | null;
+    /**
+     * Number of blocks since signature confirmation or `null` if rooted as well as finalized by a
+     * supermajority of the cluster.
+     */
+    confirmations: bigint | null;
+    /** If the transaction failed, this property will contain the error */
+    err: TransactionError | null;
+    /** The slot the transaction was processed */
+    slot: Slot;
+    /** @deprecated */
+    status: TransactionStatusErr | TransactionStatusOk;
+}>;
+
+type GetSignatureStatusesApiResponse = readonly (SignatureStatusResult | null)[];
+
+export type GetSignatureStatusesApi = {
+    /**
+     * Returns the statuses of a list of signatures.
+     *
+     * Each signature uniquely identifies a transaction by virtue of being the first or only
+     * signature in its list of signatures.
+     *
+     * @see https://solana.com/docs/rpc/http/getsignaturestatuses
+     */
+    getSignatureStatuses(
+        /**
+         * An array of transaction signatures to confirm, as base-58 encoded strings (up to a
+         * maximum of 256)
+         */
+        signatures: readonly Signature[],
+        config?: Readonly<{
+            /**
+             * Determines whether the search for a transaction with a given signature will consider
+             * any more than what is available in the recent status cache that retains statuses for
+             * the active slots plus `MAX_RECENT_BLOCKHASHES` rooted slots. When `true` the search
+             * will proceed into local block storage then, if available, archival storage.
+             *
+             * @defaultValue `false`
+             */
+            searchTransactionHistory?: boolean;
+        }>,
+    ): SolanaRpcResponse<GetSignatureStatusesApiResponse>;
+};

package/src/getSignaturesForAddress.ts

@@ -0,0 +1,88 @@
+import type { Address } from '@solana/addresses';
+import type { Signature } from '@solana/keys';
+import type { Commitment, Slot, TransactionError, UnixTimestamp } from '@solana/rpc-types';
+
+type GetSignaturesForAddressTransaction = Readonly<{
+    /** estimated production time of when transaction was processed. null if not available. */
+    blockTime: UnixTimestamp | null;
+    /** The transaction's cluster confirmation status */
+    confirmationStatus: Commitment | null;
+    /** Error if transaction failed, null if transaction succeeded. */
+    err: TransactionError | null;
+    /** Memo associated with the transaction, null if no memo is present */
+    memo: string | null;
+    /** transaction signature as base-58 encoded string */
+    signature: Signature;
+    /** The slot that contains the block with the transaction */
+    slot: Slot;
+}>;
+
+type GetSignaturesForAddressApiResponse = readonly GetSignaturesForAddressTransaction[];
+
+type AllowedCommitmentForGetSignaturesForAddress = Exclude<Commitment, 'processed'>;
+
+type GetSignaturesForAddressConfig = Readonly<{
+    /**
+     * Start the search from before, but excluding, this signature.
+     *
+     * @defaultValue When omitted, the search starts from the top of the latest confirmed block.
+     */
+    before?: Signature;
+    /**
+     * Fetch the signatures 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?: AllowedCommitmentForGetSignaturesForAddress;
+    /**
+     * Maximum transaction signatures to return (between 1 and 1,000).
+     *
+     * @defaultValue 1000
+     */
+    limit?: number;
+    /**
+     * Prevents accessing stale data by enforcing that the RPC node has processed transactions up to
+     * this slot
+     */
+    minContextSlot?: Slot;
+    /**
+     * Search, back in time, until this transaction signature.
+     *
+     * @defaultValue When omitted, search will proceed until the limit (if supplied) or until 1,000
+     * signatures have been found.
+     */
+    until?: Signature;
+}>;
+
+export type GetSignaturesForAddressApi = {
+    /**
+     * Returns signatures for confirmed transactions that load the given address.
+     *
+     * {@label before-signature}
+     * @returns Signatures in reverse chronological order starting from before, but excluding, the
+     * signature supplied.
+     * @see https://solana.com/docs/rpc/http/getsignaturesforaddress
+     */
+    getSignaturesForAddress(
+        address: Address,
+        config?: GetSignaturesForAddressConfig &
+            Readonly<{
+                before: Signature;
+            }>,
+    ): GetSignaturesForAddressApiResponse;
+    /**
+     * Returns signatures for confirmed transactions that load the given address.
+     *
+     * {@label all}
+     * @returns Signatures in reverse chronological order starting from the most recent confirmed
+     * block.
+     * @see https://solana.com/docs/rpc/http/getsignaturesforaddress
+     */
+    getSignaturesForAddress(
+        address: Address,
+        config?: GetSignaturesForAddressConfig,
+    ): GetSignaturesForAddressApiResponse;
+};