@thru/sdk 0.2.22

package/dist/client-worIo0a3.d.ts

@@ -0,0 +1,1247 @@
+import { Transport, createClient, CallOptions, Interceptor } from '@connectrpc/connect';
+import { GrpcWebTransportOptions } from '@connectrpc/connect-web';
+import { bx as Pubkey$1, ct as TaPubkey, bQ as Signature$1, cN as TsSignature, cL as TransactionVmError, cz as Transaction$1, cC as TransactionExecutionResult, L as ConsensusStatus, cH as TransactionStatus, c as AccountFlags$1, e as AccountMeta$1, a as AccountData$1, A as Account$1, Y as FilterParamValue$1, X as Filter$1, bv as PageResponse$1, bt as PageRequest$1, l as AccountView, cP as VersionContext, R as DataSlice, bC as RawAccount, V as ExecutionStatus, v as BlockFooter$1, z as BlockHeader$1, s as Block$1, E as BlockView, bE as RawBlock, ad as GetChainInfoResponse, T as Event, c8 as StreamEventsResponse, av as GetNodeStatusResponse, an as GetNodePubkeyResponse, ar as GetNodeRecordsResponse, bS as StateProof$1, bW as StateProofType, aJ as GetStateRootsResponse, aF as GetSlotMetricsResponse, b7 as ListSlotMetricsResponse, bp as NodeRecord, cJ as TransactionView, cr as SubmissionStatus, bG as RawTransaction, q as BatchSendTransactionsResponse, aR as GetVersionResponse } from './streaming_service_pb-DvCdJiCr.js';
+import { Timestamp } from '@bufbuild/protobuf/wkt';
+
+type PubkeyInput = Uint8Array | string | Pubkey;
+declare class Pubkey {
+    private readonly bytes;
+    private constructor();
+    static from(value: PubkeyInput): Pubkey;
+    static isThruFmt(value: string): boolean;
+    toBytes(): Uint8Array;
+    toBytesUnsafe(): Uint8Array;
+    toThruFmt(): string;
+    toHex(): string;
+    equals(other: PubkeyInput): boolean;
+    toProtoPubkey(): Pubkey$1;
+    toProtoTaPubkey(): TaPubkey;
+    static fromProtoPubkey(proto?: Pubkey$1): Pubkey;
+    static fromProtoTaPubkey(proto?: TaPubkey): Pubkey;
+    private static bytesFromString;
+}
+
+type SignatureInput = Uint8Array | string | Signature;
+declare class Signature {
+    private readonly bytes;
+    private constructor();
+    static from(value: SignatureInput): Signature;
+    static fromProto(proto?: Signature$1): Signature;
+    static isThruFmt(value: string): boolean;
+    toBytes(): Uint8Array;
+    toBytesUnsafe(): Uint8Array;
+    toThruFmt(): string;
+    toHex(): string;
+    equals(other: SignatureInput): boolean;
+    toProtoSignature(): Signature$1;
+    toProtoTsSignature(): TsSignature;
+    static fromProtoTsSignature(proto?: TsSignature): Signature;
+    static fromProtoSignature(proto?: Signature$1): Signature;
+    private static bytesFromString;
+}
+
+interface ResourceLimits {
+    computeUnits?: number;
+    stateUnits?: number;
+    memoryUnits?: number;
+}
+interface OptionalProofs {
+    feePayerStateProof?: Uint8Array;
+    feePayerAccountMetaRaw?: Uint8Array;
+}
+interface TransactionHeaderInput extends ResourceLimits {
+    fee: bigint;
+    nonce: bigint;
+    startSlot: bigint;
+    expiryAfter?: number;
+    chainId?: number;
+    flags?: number;
+}
+interface TransactionAccountsInput {
+    readWriteAccounts?: PubkeyInput[];
+    readOnlyAccounts?: PubkeyInput[];
+}
+/**
+ * Context provided to instruction data functions.
+ * Contains all transaction accounts in their final sorted order and helper functions
+ * for looking up account indexes.
+ */
+interface InstructionContext {
+    /** All accounts in final transaction order: [feePayer, program, ...readWrite, ...readOnly] */
+    accounts: Pubkey[];
+    /** Get the index of an account by its public key. Throws if account is not found in transaction. */
+    getAccountIndex: (pubkey: PubkeyInput) => number;
+}
+interface FeePayerInput {
+    publicKey: PubkeyInput;
+    privateKey?: Uint8Array;
+}
+/**
+ * Function that builds instruction data with access to the final account ordering.
+ * Use this when your instruction data contains account indices.
+ */
+type InstructionDataBuilder = (context: InstructionContext) => Uint8Array | string;
+interface BuildTransactionParams {
+    feePayer: FeePayerInput;
+    program: PubkeyInput;
+    header: TransactionHeaderInput;
+    accounts?: TransactionAccountsInput;
+    /**
+     * Static instruction data. Use this when your instruction data does not
+     * contain account indices, or when you've pre-computed the indices.
+     */
+    instructionData?: Uint8Array | string;
+    /**
+     * Builder function that receives the final account ordering.
+     * Use this when your instruction data contains account indices to ensure
+     * they match the post-sort transaction layout.
+     *
+     * @example
+     * ```typescript
+     * buildInstructionData: ({ getAccountIndex }) => {
+     *   return buildMyInstruction(
+     *     getAccountIndex(configAddress),
+     *     getAccountIndex(trancheAddress),
+     *   );
+     * }
+     * ```
+     */
+    buildInstructionData?: InstructionDataBuilder;
+    proofs?: OptionalProofs;
+}
+interface BuiltTransactionResult {
+    transaction: TransactionLike;
+}
+interface SignedTransactionResult extends BuiltTransactionResult {
+    signature: Signature;
+    rawTransaction: Uint8Array;
+}
+interface TransactionLike {
+    toWire(): Uint8Array;
+}
+
+interface TransactionExecutionEvent {
+    eventId: string;
+    callIdx: number;
+    programIdx: number;
+    program?: Pubkey;
+    payload: Uint8Array;
+}
+interface TransactionExecutionResultData {
+    consumedComputeUnits: number;
+    consumedMemoryUnits: number;
+    consumedStateUnits: number;
+    userErrorCode: bigint;
+    vmError: TransactionVmError;
+    executionResult: bigint;
+    pagesUsed: number;
+    eventsCount: number;
+    eventsSize: number;
+    readwriteAccounts: Pubkey[];
+    readonlyAccounts: Pubkey[];
+    events?: TransactionExecutionEvent[];
+    errorProgramAccIdx: number;
+}
+declare class Transaction {
+    readonly version: number;
+    readonly feePayer: Pubkey;
+    readonly program: Pubkey;
+    readonly fee: bigint;
+    readonly nonce: bigint;
+    readonly startSlot: bigint;
+    readonly expiryAfter: number;
+    readonly chainId: number;
+    readonly requestedComputeUnits: number;
+    readonly requestedStateUnits: number;
+    readonly requestedMemoryUnits: number;
+    readonly flags: number;
+    readonly readWriteAccounts: Pubkey[];
+    readonly readOnlyAccounts: Pubkey[];
+    readonly instructionData?: Uint8Array;
+    readonly instructionDataSize?: number;
+    readonly feePayerStateProof?: Uint8Array;
+    readonly feePayerAccountMetaRaw?: Uint8Array;
+    executionResult?: TransactionExecutionResultData;
+    slot?: bigint;
+    blockOffset?: number;
+    private signature?;
+    constructor(params: {
+        version?: number;
+        feePayer: PubkeyInput;
+        program: PubkeyInput;
+        header: TransactionHeaderInput;
+        accounts?: TransactionAccountsInput;
+        instructionData?: Uint8Array;
+        instructionDataSize?: number;
+        proofs?: OptionalProofs;
+    });
+    static fromWire(data: Uint8Array): Transaction;
+    static parseWire(data: Uint8Array, options?: {
+        strict?: boolean;
+    }): {
+        transaction: Transaction;
+        size: number;
+    };
+    static fromProto(proto: Transaction$1): Transaction;
+    getSignature(): Signature | undefined;
+    setSignature(signature: Signature): void;
+    sign(privateKey: Uint8Array): Promise<Signature>;
+    toWireForSigning(): Uint8Array;
+    toWire(): Uint8Array;
+    private createHeader;
+    private buildWirePayload;
+    private static parseBodySections;
+    private static ensureAvailable;
+    private static parseStateProof;
+    static executionResultFromProto(proto: TransactionExecutionResult): TransactionExecutionResultData;
+}
+
+type StreamTransactionUpdate = {
+    kind: "partial";
+    signature: Uint8Array;
+    slot?: bigint;
+    executionResult?: ReturnType<typeof Transaction.executionResultFromProto>;
+} | {
+    kind: "full";
+    transaction: Transaction;
+};
+interface TrackTransactionUpdate {
+    signature?: Uint8Array;
+    status: string;
+    statusCode: ConsensusStatus;
+    slot?: bigint;
+    executionResult?: ReturnType<typeof Transaction.executionResultFromProto>;
+    transaction?: Transaction;
+}
+
+interface TransactionStatusParams {
+    signature: Uint8Array;
+    consensusStatus?: ConsensusStatus;
+    executionResult?: ReturnType<typeof Transaction.executionResultFromProto>;
+}
+declare class TransactionStatusSnapshot {
+    readonly signature: Uint8Array;
+    readonly statusCode?: ConsensusStatus;
+    readonly status?: string;
+    readonly executionResult?: ReturnType<typeof Transaction.executionResultFromProto>;
+    constructor(params: TransactionStatusParams);
+    static fromProto(proto: TransactionStatus): TransactionStatusSnapshot;
+}
+
+type PartialTransportOptions = Partial<GrpcWebTransportOptions>;
+interface ThruClientConfig {
+    baseUrl?: string;
+    transport?: Transport;
+    transportOptions?: PartialTransportOptions;
+    interceptors?: Interceptor[];
+    callOptions?: CallOptions;
+}
+type QueryClient = ReturnType<typeof createClient<typeof QueryService>>;
+type CommandClient = ReturnType<typeof createClient<typeof CommandService>>;
+type StreamingClient = ReturnType<typeof createClient<typeof StreamingService>>;
+interface ThruClientContext {
+    baseUrl: string;
+    transport: Transport;
+    query: QueryClient;
+    command: CommandClient;
+    streaming: StreamingClient;
+    callOptions?: CallOptions;
+}
+
+interface AccountFlagsData {
+    isProgram: boolean;
+    isPrivileged: boolean;
+    isUncompressable: boolean;
+    isEphemeral: boolean;
+    isDeleted: boolean;
+    isNew: boolean;
+    isCompressed: boolean;
+}
+declare class AccountFlags implements AccountFlagsData {
+    readonly isProgram: boolean;
+    readonly isPrivileged: boolean;
+    readonly isUncompressable: boolean;
+    readonly isEphemeral: boolean;
+    readonly isDeleted: boolean;
+    readonly isNew: boolean;
+    readonly isCompressed: boolean;
+    constructor(flags?: Partial<AccountFlagsData>);
+    static fromProto(flags?: AccountFlags$1): AccountFlags;
+}
+declare class AccountMeta {
+    readonly version: number;
+    readonly flags: AccountFlags;
+    readonly dataSize: number;
+    readonly seq: bigint;
+    readonly owner?: Pubkey;
+    readonly balance: bigint;
+    readonly nonce?: bigint;
+    constructor(params: {
+        version: number;
+        flags?: AccountFlags;
+        dataSize: number;
+        seq: bigint;
+        owner?: Pubkey;
+        balance: bigint;
+        nonce?: bigint;
+    });
+    static fromProto(meta?: AccountMeta$1): AccountMeta | undefined;
+}
+declare class AccountData {
+    readonly data?: Uint8Array;
+    readonly compressed: boolean;
+    readonly compressionAlgorithm?: string;
+    constructor(params: {
+        data?: Uint8Array;
+        compressed?: boolean;
+        compressionAlgorithm?: string;
+    });
+    static fromProto(data?: AccountData$1): AccountData | undefined;
+}
+interface AccountVersionContext {
+    slot?: bigint;
+    blockTimestampNs?: bigint;
+}
+declare class Account {
+    readonly address: Pubkey;
+    readonly meta?: AccountMeta;
+    readonly data?: AccountData;
+    readonly versionContext?: AccountVersionContext;
+    readonly consensusStatus?: ConsensusStatus;
+    constructor(params: {
+        address: Pubkey;
+        meta?: AccountMeta;
+        data?: AccountData;
+        versionContext?: AccountVersionContext;
+        consensusStatus?: ConsensusStatus;
+    });
+    static fromProto(proto: Account$1): Account;
+}
+
+interface AccountPageChunk {
+    pageIndex: number;
+    pageSize: number;
+    data: Uint8Array;
+    compressed?: boolean;
+    compressionAlgorithm?: string;
+}
+interface AccountSnapshot {
+    account: Account;
+}
+interface AccountUpdateDelta {
+    slot: bigint;
+    meta?: AccountMeta;
+    page?: AccountPageChunk;
+    deleted?: boolean;
+}
+type StreamAccountUpdate = {
+    kind: "snapshot";
+    snapshot: AccountSnapshot;
+} | {
+    kind: "update";
+    update: AccountUpdateDelta;
+};
+
+type FilterParamValueCase = "stringValue" | "bytesValue" | "boolValue" | "intValue" | "doubleValue" | "uintValue" | "pubkeyValue" | "signatureValue" | "taPubkeyValue" | "tsSignatureValue";
+declare class FilterParamValue {
+    private readonly case?;
+    private readonly value?;
+    private constructor();
+    static none(): FilterParamValue;
+    static string(value: string): FilterParamValue;
+    static bytes(value: Uint8Array): FilterParamValue;
+    static bool(value: boolean): FilterParamValue;
+    static int(value: bigint): FilterParamValue;
+    static double(value: number): FilterParamValue;
+    static uint(value: number | bigint): FilterParamValue;
+    static pubkey(value: PubkeyInput): FilterParamValue;
+    static signature(value: SignatureInput): FilterParamValue;
+    static taPubkey(value: PubkeyInput | string): FilterParamValue;
+    static tsSignature(value: SignatureInput): FilterParamValue;
+    static fromProto(proto: FilterParamValue$1): FilterParamValue;
+    toProto(): FilterParamValue$1;
+    getCase(): FilterParamValueCase | undefined;
+    getString(): string | undefined;
+    getBytes(): Uint8Array | undefined;
+    getBool(): boolean | undefined;
+    getInt(): bigint | undefined;
+    getUint(): bigint | undefined;
+    getDouble(): number | undefined;
+    getPubkey(): Uint8Array | undefined;
+    getSignature(): Uint8Array | undefined;
+    getTaPubkey(): string | undefined;
+    getTsSignature(): string | undefined;
+}
+interface FilterParamsInit {
+    [key: string]: FilterParamValue;
+}
+declare class Filter {
+    readonly expression?: string;
+    private readonly params;
+    constructor(init?: {
+        expression?: string;
+        params?: FilterParamsInit | Map<string, FilterParamValue> | Iterable<[string, FilterParamValue]>;
+    });
+    static fromProto(proto: Filter$1): Filter;
+    toProto(): Filter$1;
+    hasParam(name: string): boolean;
+    getParam(name: string): FilterParamValue | undefined;
+    listParams(): string[];
+    entries(): [string, FilterParamValue][];
+    withExpression(expression?: string): Filter;
+    withParam(name: string, value: FilterParamValue): Filter;
+    withoutParam(name: string): Filter;
+    private setParamInternal;
+}
+
+interface PageRequestParams {
+    pageSize?: number;
+    pageToken?: string;
+    orderBy?: string;
+}
+declare class PageRequest {
+    readonly pageSize?: number;
+    readonly pageToken?: string;
+    readonly orderBy?: string;
+    constructor(params?: PageRequestParams);
+    static fromProto(proto?: PageRequest$1): PageRequest | undefined;
+    toProto(): PageRequest$1;
+    withParams(params: PageRequestParams): PageRequest;
+}
+interface PageResponseParams {
+    nextPageToken?: string;
+    totalSize?: bigint;
+}
+declare class PageResponse {
+    readonly nextPageToken?: string;
+    readonly totalSize?: bigint;
+    constructor(params?: PageResponseParams);
+    static fromProto(proto?: PageResponse$1): PageResponse | undefined;
+    toProto(): PageResponse$1;
+    hasNextPage(): boolean;
+}
+
+interface CreateAccountOptions {
+    /** The new account's public key (fee payer). */
+    publicKey: PubkeyInput;
+    /** Optional overrides for the transaction header. */
+    header?: Partial<TransactionHeaderInput>;
+}
+interface AccountQueryOptions {
+    view?: AccountView;
+    versionContext?: VersionContext;
+    minConsensus?: ConsensusStatus;
+    dataSlice?: DataSlice;
+}
+interface RawAccountQueryOptions {
+    view?: AccountView;
+    versionContext?: VersionContext;
+    minConsensus?: ConsensusStatus;
+}
+interface ListAccountsOptions {
+    view?: AccountView;
+    versionContext?: VersionContext;
+    filter?: Filter;
+    page?: PageRequest;
+    minConsensus?: ConsensusStatus;
+}
+interface AccountList {
+    accounts: Account[];
+    page?: PageResponse;
+}
+declare function getAccount(ctx: ThruClientContext, address: PubkeyInput, options?: AccountQueryOptions): Promise<Account>;
+declare function getRawAccount(ctx: ThruClientContext, address: PubkeyInput, options?: RawAccountQueryOptions): Promise<RawAccount>;
+declare function listAccounts(ctx: ThruClientContext, options: ListAccountsOptions): Promise<AccountList>;
+declare function createAccount(ctx: ThruClientContext, options: CreateAccountOptions): Promise<Transaction>;
+
+type accounts_AccountList = AccountList;
+type accounts_AccountQueryOptions = AccountQueryOptions;
+type accounts_CreateAccountOptions = CreateAccountOptions;
+type accounts_ListAccountsOptions = ListAccountsOptions;
+type accounts_RawAccountQueryOptions = RawAccountQueryOptions;
+declare const accounts_createAccount: typeof createAccount;
+declare const accounts_getAccount: typeof getAccount;
+declare const accounts_getRawAccount: typeof getRawAccount;
+declare const accounts_listAccounts: typeof listAccounts;
+declare namespace accounts {
+  export { type accounts_AccountList as AccountList, type accounts_AccountQueryOptions as AccountQueryOptions, type accounts_CreateAccountOptions as CreateAccountOptions, type accounts_ListAccountsOptions as ListAccountsOptions, type accounts_RawAccountQueryOptions as RawAccountQueryOptions, accounts_createAccount as createAccount, accounts_getAccount as getAccount, accounts_getRawAccount as getRawAccount, accounts_listAccounts as listAccounts };
+}
+
+interface BlockFooterParams {
+    signature?: Uint8Array;
+    status: ExecutionStatus;
+    consumedComputeUnits: bigint;
+    consumedStateUnits: number;
+    attestorPayment: bigint;
+}
+declare class BlockFooter {
+    readonly signature?: Uint8Array;
+    readonly status: ExecutionStatus;
+    readonly consumedComputeUnits: bigint;
+    readonly consumedStateUnits: number;
+    readonly attestorPayment: bigint;
+    constructor(params: BlockFooterParams);
+    static fromProto(proto: BlockFooter$1): BlockFooter;
+}
+
+interface BlockHeaderParams {
+    slot: bigint;
+    version: number;
+    headerSignature?: Uint8Array;
+    producer?: Uint8Array;
+    expiryTimestamp?: Timestamp;
+    startSlot: bigint;
+    expiryAfter?: number;
+    maxBlockSize?: number;
+    maxComputeUnits?: bigint;
+    maxStateUnits?: number;
+    bondAmountLockUp?: bigint;
+    weightSlot?: bigint;
+    blockHash?: Uint8Array;
+    chainId?: number;
+}
+declare class BlockHeader {
+    readonly slot: bigint;
+    readonly version: number;
+    readonly headerSignature?: Uint8Array;
+    readonly producer?: Uint8Array;
+    readonly expiryTimestamp?: Timestamp;
+    readonly startSlot: bigint;
+    readonly expiryAfter?: number;
+    readonly maxBlockSize?: number;
+    readonly maxComputeUnits?: bigint;
+    readonly maxStateUnits?: number;
+    readonly bondAmountLockUp?: bigint;
+    readonly weightSlot?: bigint;
+    readonly blockHash?: Uint8Array;
+    readonly chainId?: number;
+    constructor(params: BlockHeaderParams);
+    static fromProto(proto: BlockHeader$1): BlockHeader;
+    withBlockHash(blockHash: Uint8Array): BlockHeader;
+}
+
+declare class Block {
+    readonly header: BlockHeader;
+    readonly footer?: BlockFooter;
+    readonly body?: Uint8Array;
+    readonly consensusStatus?: ConsensusStatus;
+    blockTimeNs?: bigint;
+    attestorPayment?: bigint;
+    constructor(params: {
+        header: BlockHeader;
+        footer?: BlockFooter;
+        body?: Uint8Array;
+        consensusStatus?: ConsensusStatus;
+    });
+    static fromProto(proto: Block$1): Block;
+    static fromWire(data: Uint8Array): Block;
+    private static tryParseWireWithHeaderSize;
+    toWire(): Uint8Array;
+    getTransactions(): Transaction[];
+    private static extractTransactionBody;
+    private static extractWithHeaderSize;
+    /**
+     * Checks if the data looks like a valid transaction body.
+     * Uses heuristics to detect if we've correctly offset into the block data.
+     * Wire format: header (112 bytes) + body + signature (64 bytes at end)
+     * This is a lenient heuristic for format detection - version/flag validation
+     * happens in Transaction.parseWire.
+     */
+    private static looksLikeValidTransactionBody;
+    private serializeHeader;
+    private serializeFooter;
+    private static parseHeader;
+    /**
+     * Parses a block header with a specific expected size.
+     * Handles both current (168 bytes with weight_slot) and legacy (160 bytes without weight_slot) formats.
+     */
+    private static parseHeaderWithSize;
+    private static parseFooter;
+    private static parseTransactionsFromBody;
+}
+
+type BlockSelector = {
+    slot: number | bigint;
+} | {
+    blockHash: Uint8Array | string;
+};
+interface DeriveProgramAddressOptions {
+    programAddress: PubkeyInput;
+    seed: Uint8Array | string;
+    ephemeral?: boolean;
+}
+interface DeriveProgramAddressResult {
+    bytes: Uint8Array;
+    address: string;
+}
+declare function deriveProgramAddress(options: DeriveProgramAddressOptions): DeriveProgramAddressResult;
+type DeriveAddressInput = PubkeyInput | Uint8Array;
+interface DeriveAddressResult {
+    bytes: Uint8Array;
+    address: string;
+}
+/**
+ * Derive an address by hashing an array of inputs.
+ * Inputs can be pubkeys (as string, Uint8Array, or Pubkey) or raw Uint8Array data.
+ *
+ * @example
+ * // Token account: SHA256(owner || mint || seed)
+ * deriveAddress([ownerPubkey, mintPubkey, seed])
+ *
+ * // Mint account: SHA256(creator || seed)
+ * deriveAddress([creatorPubkey, seed])
+ */
+declare function deriveAddress(inputs: DeriveAddressInput[]): DeriveAddressResult;
+
+interface BlockQueryOptions {
+    view?: BlockView;
+    minConsensus?: ConsensusStatus;
+}
+interface RawBlockQueryOptions {
+    minConsensus?: ConsensusStatus;
+}
+interface ListBlocksOptions {
+    filter?: Filter;
+    page?: PageRequest;
+    view?: BlockView;
+    minConsensus?: ConsensusStatus;
+}
+interface BlockList {
+    blocks: Block[];
+    page?: PageResponse;
+}
+declare function getBlock(ctx: ThruClientContext, selector: BlockSelector, options?: BlockQueryOptions): Promise<Block>;
+declare function getRawBlock(ctx: ThruClientContext, selector: BlockSelector, options?: RawBlockQueryOptions): Promise<RawBlock>;
+declare function listBlocks(ctx: ThruClientContext, options?: ListBlocksOptions): Promise<BlockList>;
+
+type blocks_BlockList = BlockList;
+type blocks_BlockQueryOptions = BlockQueryOptions;
+type blocks_ListBlocksOptions = ListBlocksOptions;
+type blocks_RawBlockQueryOptions = RawBlockQueryOptions;
+declare const blocks_getBlock: typeof getBlock;
+declare const blocks_getRawBlock: typeof getRawBlock;
+declare const blocks_listBlocks: typeof listBlocks;
+declare namespace blocks {
+  export { type blocks_BlockList as BlockList, type blocks_BlockQueryOptions as BlockQueryOptions, type blocks_ListBlocksOptions as ListBlocksOptions, type blocks_RawBlockQueryOptions as RawBlockQueryOptions, blocks_getBlock as getBlock, blocks_getRawBlock as getRawBlock, blocks_listBlocks as listBlocks };
+}
+
+declare function getChainInfo(ctx: ThruClientContext): Promise<GetChainInfoResponse>;
+declare function getChainId(ctx: ThruClientContext): Promise<number>;
+
+declare const chain_getChainId: typeof getChainId;
+declare const chain_getChainInfo: typeof getChainInfo;
+declare namespace chain {
+  export { chain_getChainId as getChainId, chain_getChainInfo as getChainInfo };
+}
+
+declare function consensusStatusToString(status: ConsensusStatus): string;
+
+type VersionContextInput = VersionContext | {
+    current: true;
+} | {
+    currentOrHistorical: true;
+} | {
+    slot: number | bigint;
+} | {
+    timestamp: Date | number | Timestamp;
+} | {
+    seq: number | bigint;
+};
+
+declare function currentVersionContext(): VersionContext;
+declare function currentOrHistoricalVersionContext(): VersionContext;
+declare function slotVersionContext(slot: number | bigint): VersionContext;
+declare function timestampVersionContext(value: Date | number | Timestamp): VersionContext;
+declare function seqVersionContext(seq: number | bigint): VersionContext;
+declare function versionContext(input?: VersionContextInput): VersionContext;
+
+type consensus_VersionContextInput = VersionContextInput;
+declare const consensus_consensusStatusToString: typeof consensusStatusToString;
+declare const consensus_currentOrHistoricalVersionContext: typeof currentOrHistoricalVersionContext;
+declare const consensus_currentVersionContext: typeof currentVersionContext;
+declare const consensus_seqVersionContext: typeof seqVersionContext;
+declare const consensus_slotVersionContext: typeof slotVersionContext;
+declare const consensus_timestampVersionContext: typeof timestampVersionContext;
+declare const consensus_versionContext: typeof versionContext;
+declare namespace consensus {
+  export { type consensus_VersionContextInput as VersionContextInput, consensus_consensusStatusToString as consensusStatusToString, consensus_currentOrHistoricalVersionContext as currentOrHistoricalVersionContext, consensus_currentVersionContext as currentVersionContext, consensus_seqVersionContext as seqVersionContext, consensus_slotVersionContext as slotVersionContext, consensus_timestampVersionContext as timestampVersionContext, consensus_versionContext as versionContext };
+}
+
+interface ChainEventParams {
+    id: string;
+    transactionSignature?: Uint8Array;
+    program?: Uint8Array;
+    payload?: Uint8Array;
+    slot?: bigint;
+    callIndex?: number;
+    programIndex?: number;
+    payloadSize?: number;
+    timestampNs?: bigint;
+}
+declare class ChainEvent {
+    readonly id: string;
+    readonly transactionSignature?: Uint8Array;
+    readonly program?: Uint8Array;
+    readonly payload?: Uint8Array;
+    readonly slot?: bigint;
+    readonly callIndex?: number;
+    readonly programIndex?: number;
+    readonly payloadSize?: number;
+    readonly timestampNs?: bigint;
+    constructor(params: ChainEventParams);
+    static fromQuery(proto: Event): ChainEvent;
+    static fromStream(proto: StreamEventsResponse): ChainEvent;
+}
+
+interface GetEventOptions {
+    versionContext?: VersionContext;
+}
+interface ListEventsOptions {
+    filter?: Filter;
+    page?: PageRequest;
+    versionContext?: VersionContext;
+    minConsensus?: ConsensusStatus;
+}
+interface EventList {
+    events: ChainEvent[];
+    page?: PageResponse;
+}
+declare function getEvent(ctx: ThruClientContext, eventId: string, options?: GetEventOptions): Promise<ChainEvent>;
+declare function listEvents(ctx: ThruClientContext, options?: ListEventsOptions): Promise<EventList>;
+
+type events_EventList = EventList;
+type events_GetEventOptions = GetEventOptions;
+type events_ListEventsOptions = ListEventsOptions;
+declare const events_getEvent: typeof getEvent;
+declare const events_listEvents: typeof listEvents;
+declare namespace events {
+  export { type events_EventList as EventList, type events_GetEventOptions as GetEventOptions, type events_ListEventsOptions as ListEventsOptions, events_getEvent as getEvent, events_listEvents as listEvents };
+}
+
+interface HeightSnapshotParams {
+    finalized: bigint;
+    locallyExecuted: bigint;
+    clusterExecuted: bigint;
+}
+declare class HeightSnapshot {
+    readonly finalized: bigint;
+    readonly locallyExecuted: bigint;
+    readonly clusterExecuted: bigint;
+    constructor(params: HeightSnapshotParams);
+    static fromProto(proto: {
+        finalized: bigint;
+        locallyExecuted: bigint;
+        clusterExecuted: bigint;
+    }): HeightSnapshot;
+    delta(other: HeightSnapshot): {
+        finalized: bigint;
+        locallyExecuted: bigint;
+        clusterExecuted: bigint;
+    };
+}
+
+declare function getBlockHeight(ctx: ThruClientContext): Promise<HeightSnapshot>;
+
+declare const height_getBlockHeight: typeof getBlockHeight;
+declare namespace height {
+  export { height_getBlockHeight as getBlockHeight };
+}
+
+interface GeneratedKeyPair {
+    address: string;
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+}
+/**
+ * Generates a new Ed25519 keypair using the same HD wallet pipeline as the Thru wallet.
+ */
+declare function generateKeyPair(): Promise<GeneratedKeyPair>;
+declare function fromPrivateKey(privateKey: Uint8Array): Promise<Uint8Array>;
+
+type keys_GeneratedKeyPair = GeneratedKeyPair;
+declare const keys_fromPrivateKey: typeof fromPrivateKey;
+declare const keys_generateKeyPair: typeof generateKeyPair;
+declare namespace keys {
+  export { type keys_GeneratedKeyPair as GeneratedKeyPair, keys_fromPrivateKey as fromPrivateKey, keys_generateKeyPair as generateKeyPair };
+}
+
+declare function getNodeStatus(ctx: ThruClientContext): Promise<GetNodeStatusResponse>;
+declare function getNodePubkey(ctx: ThruClientContext): Promise<GetNodePubkeyResponse>;
+declare function getNodeRecords(ctx: ThruClientContext): Promise<GetNodeRecordsResponse>;
+
+declare const node_getNodePubkey: typeof getNodePubkey;
+declare const node_getNodeRecords: typeof getNodeRecords;
+declare const node_getNodeStatus: typeof getNodeStatus;
+declare namespace node {
+  export { node_getNodePubkey as getNodePubkey, node_getNodeRecords as getNodeRecords, node_getNodeStatus as getNodeStatus };
+}
+
+interface AccountNonceObserverOptions {
+    versionContext?: VersionContext;
+    signal?: AbortSignal;
+}
+interface WaitForNonceOptions {
+    timeoutMs?: number;
+}
+declare class AccountNonceObserver {
+    private readonly ctx;
+    private readonly account;
+    private readonly versionContext;
+    private readonly abortController;
+    private readonly waiters;
+    private latestNonce;
+    private closed;
+    private streamStarted;
+    constructor(ctx: ThruClientContext, account: PubkeyInput, options?: AccountNonceObserverOptions);
+    getLatestNonce(): bigint | undefined;
+    refresh(): Promise<bigint | undefined>;
+    start(): void;
+    waitForNonceAtLeast(target: bigint, options?: WaitForNonceOptions): Promise<bigint>;
+    close(): void;
+    private runStream;
+    private observeNonce;
+    private resolveReadyWaiters;
+    private rejectWaiters;
+}
+interface FeePayerNonceAllocation {
+    baseNonce: bigint;
+    nonces: bigint[];
+    barrierNonce: bigint;
+}
+interface FeePayerNonceManagerOptions {
+    observer?: AccountNonceObserver;
+}
+declare class FeePayerNonceManager {
+    readonly observer: AccountNonceObserver;
+    private allocationQueue;
+    private nextNonce;
+    constructor(ctx: ThruClientContext, feePayer: PubkeyInput, options?: FeePayerNonceManagerOptions);
+    allocate(count: number): Promise<FeePayerNonceAllocation>;
+    reset(nextNonce?: bigint): void;
+    sync(): Promise<bigint>;
+    waitForNonceAtLeast(target: bigint, options?: WaitForNonceOptions): Promise<bigint>;
+    close(): void;
+    private allocateUnsafe;
+    private withAllocationLock;
+}
+
+type nonce_AccountNonceObserver = AccountNonceObserver;
+declare const nonce_AccountNonceObserver: typeof AccountNonceObserver;
+type nonce_AccountNonceObserverOptions = AccountNonceObserverOptions;
+type nonce_FeePayerNonceAllocation = FeePayerNonceAllocation;
+type nonce_FeePayerNonceManager = FeePayerNonceManager;
+declare const nonce_FeePayerNonceManager: typeof FeePayerNonceManager;
+type nonce_FeePayerNonceManagerOptions = FeePayerNonceManagerOptions;
+type nonce_WaitForNonceOptions = WaitForNonceOptions;
+declare namespace nonce {
+  export { nonce_AccountNonceObserver as AccountNonceObserver, type nonce_AccountNonceObserverOptions as AccountNonceObserverOptions, type nonce_FeePayerNonceAllocation as FeePayerNonceAllocation, nonce_FeePayerNonceManager as FeePayerNonceManager, type nonce_FeePayerNonceManagerOptions as FeePayerNonceManagerOptions, type nonce_WaitForNonceOptions as WaitForNonceOptions };
+}
+
+declare class StateProof {
+    readonly proof: Uint8Array;
+    readonly slot: bigint;
+    constructor(params: {
+        proof: Uint8Array;
+        slot: bigint;
+    });
+    static fromProto(proto: StateProof$1): StateProof;
+}
+
+type GenerateStateProofOptions = {
+    address?: PubkeyInput;
+    proofType: StateProofType;
+    targetSlot?: bigint;
+};
+
+declare function generateStateProof(ctx: ThruClientContext, options: GenerateStateProofOptions): Promise<StateProof>;
+interface GetStateRootsOptions {
+    slot?: bigint;
+}
+declare function getStateRoots(ctx: ThruClientContext, options?: GetStateRootsOptions): Promise<GetStateRootsResponse>;
+
+type proofs_GetStateRootsOptions = GetStateRootsOptions;
+declare const proofs_generateStateProof: typeof generateStateProof;
+declare const proofs_getStateRoots: typeof getStateRoots;
+declare namespace proofs {
+  export { type proofs_GetStateRootsOptions as GetStateRootsOptions, proofs_generateStateProof as generateStateProof, proofs_getStateRoots as getStateRoots };
+}
+
+interface ListSlotMetricsOptions {
+    startSlot: bigint;
+    endSlot?: bigint;
+    limit?: number;
+}
+declare function getSlotMetrics(ctx: ThruClientContext, slot: bigint): Promise<GetSlotMetricsResponse>;
+declare function listSlotMetrics(ctx: ThruClientContext, options: ListSlotMetricsOptions): Promise<ListSlotMetricsResponse>;
+
+type slots_ListSlotMetricsOptions = ListSlotMetricsOptions;
+declare const slots_getSlotMetrics: typeof getSlotMetrics;
+declare const slots_listSlotMetrics: typeof listSlotMetrics;
+declare namespace slots {
+  export { type slots_ListSlotMetricsOptions as ListSlotMetricsOptions, slots_getSlotMetrics as getSlotMetrics, slots_listSlotMetrics as listSlotMetrics };
+}
+
+interface TrackTransactionOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+interface StreamBlocksOptions {
+    startSlot?: bigint;
+    filter?: Filter;
+    view?: BlockView;
+    minConsensus?: ConsensusStatus;
+    signal?: AbortSignal;
+}
+interface StreamBlocksResult {
+    block: Block;
+}
+declare function streamBlocks(ctx: ThruClientContext, options?: StreamBlocksOptions): AsyncIterable<StreamBlocksResult>;
+interface StreamAccountUpdatesOptions {
+    view?: AccountView;
+    filter?: Filter;
+    signal?: AbortSignal;
+}
+interface StreamAccountUpdatesResult {
+    update: StreamAccountUpdate;
+}
+declare function streamAccountUpdates(ctx: ThruClientContext, address: PubkeyInput, options?: StreamAccountUpdatesOptions): AsyncIterable<StreamAccountUpdatesResult>;
+interface StreamTransactionsOptions {
+    filter?: Filter;
+    minConsensus?: ConsensusStatus;
+    signal?: AbortSignal;
+}
+type StreamTransactionsResult = StreamTransactionUpdate;
+declare function streamTransactions(ctx: ThruClientContext, options?: StreamTransactionsOptions): AsyncIterable<StreamTransactionsResult>;
+interface StreamEventsOptions {
+    filter?: Filter;
+    signal?: AbortSignal;
+}
+interface StreamEventsResult {
+    event: ChainEvent;
+}
+declare function streamEvents(ctx: ThruClientContext, options?: StreamEventsOptions): AsyncIterable<StreamEventsResult>;
+declare function trackTransaction(ctx: ThruClientContext, signature: SignatureInput, options?: TrackTransactionOptions): AsyncIterable<TrackTransactionUpdate>;
+interface StreamHeightOptions {
+    signal?: AbortSignal;
+}
+interface StreamHeightResult {
+    height: HeightSnapshot;
+}
+declare function streamHeight(ctx: ThruClientContext, options?: StreamHeightOptions): AsyncIterable<StreamHeightResult>;
+interface StreamSlotMetricsOptions {
+    startSlot?: bigint;
+    signal?: AbortSignal;
+}
+interface StreamSlotMetricsResult {
+    slot: bigint;
+    collectedFees: bigint;
+    globalActivatedStateCounter: bigint;
+    globalDeactivatedStateCounter: bigint;
+    blockTimestamp?: Timestamp;
+}
+declare function streamSlotMetrics(ctx: ThruClientContext, options?: StreamSlotMetricsOptions): AsyncIterable<StreamSlotMetricsResult>;
+type StreamNodeRecordsResult = {
+    type: "record";
+    record: NodeRecord;
+} | {
+    type: "finished";
+};
+interface StreamNodeRecordsOptions {
+    signal?: AbortSignal;
+}
+declare function streamNodeRecords(ctx: ThruClientContext, options?: StreamNodeRecordsOptions): AsyncIterable<StreamNodeRecordsResult>;
+interface CollectStreamOptions {
+    limit?: number;
+    signal?: AbortSignal;
+}
+declare function collectStream<T>(iterable: AsyncIterable<T>, options?: CollectStreamOptions): Promise<T[]>;
+declare function firstStreamValue<T>(iterable: AsyncIterable<T>, options?: {
+    signal?: AbortSignal;
+}): Promise<T | undefined>;
+declare function forEachStreamValue<T>(iterable: AsyncIterable<T>, handler: (value: T, index: number) => void | Promise<void>, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;
+
+type streaming_CollectStreamOptions = CollectStreamOptions;
+type streaming_StreamAccountUpdatesOptions = StreamAccountUpdatesOptions;
+type streaming_StreamAccountUpdatesResult = StreamAccountUpdatesResult;
+type streaming_StreamBlocksOptions = StreamBlocksOptions;
+type streaming_StreamBlocksResult = StreamBlocksResult;
+type streaming_StreamEventsOptions = StreamEventsOptions;
+type streaming_StreamEventsResult = StreamEventsResult;
+type streaming_StreamHeightOptions = StreamHeightOptions;
+type streaming_StreamHeightResult = StreamHeightResult;
+type streaming_StreamNodeRecordsOptions = StreamNodeRecordsOptions;
+type streaming_StreamNodeRecordsResult = StreamNodeRecordsResult;
+type streaming_StreamSlotMetricsOptions = StreamSlotMetricsOptions;
+type streaming_StreamSlotMetricsResult = StreamSlotMetricsResult;
+type streaming_StreamTransactionUpdate = StreamTransactionUpdate;
+type streaming_StreamTransactionsOptions = StreamTransactionsOptions;
+type streaming_StreamTransactionsResult = StreamTransactionsResult;
+type streaming_TrackTransactionOptions = TrackTransactionOptions;
+type streaming_TrackTransactionUpdate = TrackTransactionUpdate;
+declare const streaming_collectStream: typeof collectStream;
+declare const streaming_firstStreamValue: typeof firstStreamValue;
+declare const streaming_forEachStreamValue: typeof forEachStreamValue;
+declare const streaming_streamAccountUpdates: typeof streamAccountUpdates;
+declare const streaming_streamBlocks: typeof streamBlocks;
+declare const streaming_streamEvents: typeof streamEvents;
+declare const streaming_streamHeight: typeof streamHeight;
+declare const streaming_streamNodeRecords: typeof streamNodeRecords;
+declare const streaming_streamSlotMetrics: typeof streamSlotMetrics;
+declare const streaming_streamTransactions: typeof streamTransactions;
+declare const streaming_trackTransaction: typeof trackTransaction;
+declare namespace streaming {
+  export { type streaming_CollectStreamOptions as CollectStreamOptions, type streaming_StreamAccountUpdatesOptions as StreamAccountUpdatesOptions, type streaming_StreamAccountUpdatesResult as StreamAccountUpdatesResult, type streaming_StreamBlocksOptions as StreamBlocksOptions, type streaming_StreamBlocksResult as StreamBlocksResult, type streaming_StreamEventsOptions as StreamEventsOptions, type streaming_StreamEventsResult as StreamEventsResult, type streaming_StreamHeightOptions as StreamHeightOptions, type streaming_StreamHeightResult as StreamHeightResult, type streaming_StreamNodeRecordsOptions as StreamNodeRecordsOptions, type streaming_StreamNodeRecordsResult as StreamNodeRecordsResult, type streaming_StreamSlotMetricsOptions as StreamSlotMetricsOptions, type streaming_StreamSlotMetricsResult as StreamSlotMetricsResult, type streaming_StreamTransactionUpdate as StreamTransactionUpdate, type streaming_StreamTransactionsOptions as StreamTransactionsOptions, type streaming_StreamTransactionsResult as StreamTransactionsResult, type streaming_TrackTransactionOptions as TrackTransactionOptions, type streaming_TrackTransactionUpdate as TrackTransactionUpdate, streaming_collectStream as collectStream, streaming_firstStreamValue as firstStreamValue, streaming_forEachStreamValue as forEachStreamValue, streaming_streamAccountUpdates as streamAccountUpdates, streaming_streamBlocks as streamBlocks, streaming_streamEvents as streamEvents, streaming_streamHeight as streamHeight, streaming_streamNodeRecords as streamNodeRecords, streaming_streamSlotMetrics as streamSlotMetrics, streaming_streamTransactions as streamTransactions, streaming_trackTransaction as trackTransaction };
+}
+
+interface TransactionFeePayerConfig {
+    publicKey: PubkeyInput;
+    privateKey?: Uint8Array;
+}
+interface TransactionAccountsConfig {
+    readWrite?: PubkeyInput[];
+    readOnly?: PubkeyInput[];
+}
+interface TransactionHeaderConfig {
+    fee?: bigint;
+    nonce?: bigint;
+    startSlot?: bigint;
+    expiryAfter?: number;
+    chainId?: number;
+    computeUnits?: number;
+    stateUnits?: number;
+    memoryUnits?: number;
+    flags?: number;
+}
+/**
+ * Instruction data can be either:
+ * - A Uint8Array directly
+ * - A function that takes an InstructionContext and returns a Uint8Array
+ */
+type InstructionData = Uint8Array | string | ((context: InstructionContext) => Promise<Uint8Array>);
+interface BuildTransactionOptions {
+    feePayer: TransactionFeePayerConfig;
+    program: PubkeyInput;
+    header?: TransactionHeaderConfig;
+    accounts?: TransactionAccountsConfig;
+    instructionData?: InstructionData;
+    feePayerStateProof?: Uint8Array;
+    feePayerAccountMetaRaw?: Uint8Array;
+}
+interface BuildAndSignTransactionOptions extends BuildTransactionOptions {
+    feePayer: TransactionFeePayerConfig & {
+        privateKey: Uint8Array;
+    };
+}
+interface TransactionQueryOptions {
+    view?: TransactionView;
+    versionContext?: VersionContext;
+    minConsensus?: ConsensusStatus;
+}
+interface RawTransactionQueryOptions {
+    versionContext?: VersionContext;
+    minConsensus?: ConsensusStatus;
+}
+interface ListTransactionsForAccountOptions {
+    filter?: Filter;
+    page?: PageRequest;
+    transactionOptions?: TransactionQueryOptions;
+}
+interface TransactionList {
+    transactions: Transaction[];
+    page?: PageResponse;
+}
+interface ListTransactionsOptions {
+    filter?: Filter;
+    page?: PageRequest;
+    returnEvents?: boolean;
+    versionContext?: VersionContext;
+    minConsensus?: ConsensusStatus;
+}
+declare function getTransaction(ctx: ThruClientContext, signature: SignatureInput, options?: TransactionQueryOptions): Promise<Transaction>;
+declare function getRawTransaction(ctx: ThruClientContext, signature: SignatureInput, options?: RawTransactionQueryOptions): Promise<RawTransaction>;
+declare function getTransactionStatus(ctx: ThruClientContext, signature: SignatureInput): Promise<TransactionStatusSnapshot>;
+declare function listTransactionsForAccount(ctx: ThruClientContext, account: PubkeyInput, options?: ListTransactionsForAccountOptions): Promise<TransactionList>;
+declare function listTransactions(ctx: ThruClientContext, options?: ListTransactionsOptions): Promise<TransactionList>;
+declare function buildTransaction(ctx: ThruClientContext, options: BuildTransactionOptions): Promise<Transaction>;
+declare function buildAndSignTransaction(ctx: ThruClientContext, options: BuildAndSignTransactionOptions): Promise<SignedTransactionResult>;
+declare function sendTransaction(ctx: ThruClientContext, transaction: Transaction | Uint8Array): Promise<string>;
+interface BatchSendTransactionsOptions {
+    numRetries?: number;
+}
+type BatchTrackStatus = "executed" | "finalized_without_execution" | "timeout" | "not_accepted" | "cancelled" | "track_error";
+interface BatchSendAndTrackOptions extends BatchSendTransactionsOptions {
+    trackTimeoutMs?: number;
+    signal?: AbortSignal;
+}
+interface BatchSendAndTrackResult {
+    signature: string;
+    accepted: boolean;
+    trackStatus: BatchTrackStatus;
+    update?: TrackTransactionUpdate;
+    executionResult?: TransactionExecutionResultData;
+    error?: unknown;
+}
+declare function batchSendTransactions(ctx: ThruClientContext, transactions: (Transaction | Uint8Array)[], options?: BatchSendTransactionsOptions): Promise<BatchSendTransactionsResponse>;
+declare function batchSendAndTrack(ctx: ThruClientContext, transactions: (Transaction | Uint8Array)[], options?: BatchSendAndTrackOptions): Promise<BatchSendAndTrackResult[]>;
+interface SendAndTrackTxnOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+interface SendAndTrackTxnUpdate {
+    status: SubmissionStatus;
+    signature?: {
+        value: Uint8Array;
+    };
+    consensusStatus: number;
+    executionResult?: {
+        vmError: number;
+        consumedComputeUnits: number;
+        userErrorCode: bigint;
+    };
+}
+declare function sendAndTrackTxn(ctx: ThruClientContext, transaction: Transaction | Uint8Array, options?: SendAndTrackTxnOptions): AsyncIterable<SendAndTrackTxnUpdate>;
+
+type transactions_BatchSendAndTrackOptions = BatchSendAndTrackOptions;
+type transactions_BatchSendAndTrackResult = BatchSendAndTrackResult;
+type transactions_BatchSendTransactionsOptions = BatchSendTransactionsOptions;
+type transactions_BatchTrackStatus = BatchTrackStatus;
+type transactions_BuildAndSignTransactionOptions = BuildAndSignTransactionOptions;
+type transactions_BuildTransactionOptions = BuildTransactionOptions;
+type transactions_InstructionData = InstructionData;
+type transactions_ListTransactionsForAccountOptions = ListTransactionsForAccountOptions;
+type transactions_ListTransactionsOptions = ListTransactionsOptions;
+type transactions_RawTransactionQueryOptions = RawTransactionQueryOptions;
+type transactions_SendAndTrackTxnOptions = SendAndTrackTxnOptions;
+type transactions_SendAndTrackTxnUpdate = SendAndTrackTxnUpdate;
+type transactions_TransactionAccountsConfig = TransactionAccountsConfig;
+type transactions_TransactionFeePayerConfig = TransactionFeePayerConfig;
+type transactions_TransactionHeaderConfig = TransactionHeaderConfig;
+type transactions_TransactionList = TransactionList;
+type transactions_TransactionQueryOptions = TransactionQueryOptions;
+declare const transactions_batchSendAndTrack: typeof batchSendAndTrack;
+declare const transactions_batchSendTransactions: typeof batchSendTransactions;
+declare const transactions_buildAndSignTransaction: typeof buildAndSignTransaction;
+declare const transactions_buildTransaction: typeof buildTransaction;
+declare const transactions_getRawTransaction: typeof getRawTransaction;
+declare const transactions_getTransaction: typeof getTransaction;
+declare const transactions_getTransactionStatus: typeof getTransactionStatus;
+declare const transactions_listTransactions: typeof listTransactions;
+declare const transactions_listTransactionsForAccount: typeof listTransactionsForAccount;
+declare const transactions_sendAndTrackTxn: typeof sendAndTrackTxn;
+declare const transactions_sendTransaction: typeof sendTransaction;
+declare namespace transactions {
+  export { type transactions_BatchSendAndTrackOptions as BatchSendAndTrackOptions, type transactions_BatchSendAndTrackResult as BatchSendAndTrackResult, type transactions_BatchSendTransactionsOptions as BatchSendTransactionsOptions, type transactions_BatchTrackStatus as BatchTrackStatus, type transactions_BuildAndSignTransactionOptions as BuildAndSignTransactionOptions, type transactions_BuildTransactionOptions as BuildTransactionOptions, type transactions_InstructionData as InstructionData, type transactions_ListTransactionsForAccountOptions as ListTransactionsForAccountOptions, type transactions_ListTransactionsOptions as ListTransactionsOptions, type transactions_RawTransactionQueryOptions as RawTransactionQueryOptions, type transactions_SendAndTrackTxnOptions as SendAndTrackTxnOptions, type transactions_SendAndTrackTxnUpdate as SendAndTrackTxnUpdate, type transactions_TransactionAccountsConfig as TransactionAccountsConfig, type transactions_TransactionFeePayerConfig as TransactionFeePayerConfig, type transactions_TransactionHeaderConfig as TransactionHeaderConfig, type transactions_TransactionList as TransactionList, type transactions_TransactionQueryOptions as TransactionQueryOptions, transactions_batchSendAndTrack as batchSendAndTrack, transactions_batchSendTransactions as batchSendTransactions, transactions_buildAndSignTransaction as buildAndSignTransaction, transactions_buildTransaction as buildTransaction, transactions_getRawTransaction as getRawTransaction, transactions_getTransaction as getTransaction, transactions_getTransactionStatus as getTransactionStatus, transactions_listTransactions as listTransactions, transactions_listTransactionsForAccount as listTransactionsForAccount, transactions_sendAndTrackTxn as sendAndTrackTxn, transactions_sendTransaction as sendTransaction };
+}
+
+declare class VersionInfo {
+    readonly components: Record<string, string>;
+    constructor(components: Record<string, string>);
+    static fromProto(proto: GetVersionResponse): VersionInfo;
+    get(component: string): string | undefined;
+}
+
+declare function getVersion(ctx: ThruClientContext): Promise<VersionInfo>;
+
+type BoundFunction<F> = F extends (ctx: ThruClientContext, ...args: infer P) => infer R ? (...args: P) => R : never;
+interface BoundBlocks {
+    get: BoundFunction<typeof getBlock>;
+    getRaw: BoundFunction<typeof getRawBlock>;
+    list: BoundFunction<typeof listBlocks>;
+    stream: BoundFunction<typeof streamBlocks>;
+    getBlockHeight: BoundFunction<typeof getBlockHeight>;
+    streamHeight: BoundFunction<typeof streamHeight>;
+}
+interface BoundAccounts {
+    get: BoundFunction<typeof getAccount>;
+    getRaw: BoundFunction<typeof getRawAccount>;
+    list: BoundFunction<typeof listAccounts>;
+    stream: BoundFunction<typeof streamAccountUpdates>;
+    create: BoundFunction<typeof createAccount>;
+}
+interface BoundTransactions {
+    get: BoundFunction<typeof getTransaction>;
+    getRaw: BoundFunction<typeof getRawTransaction>;
+    getStatus: BoundFunction<typeof getTransactionStatus>;
+    list: BoundFunction<typeof listTransactions>;
+    listForAccount: BoundFunction<typeof listTransactionsForAccount>;
+    stream: BoundFunction<typeof streamTransactions>;
+    build: BoundFunction<typeof buildTransaction>;
+    buildAndSign: BoundFunction<typeof buildAndSignTransaction>;
+    send: BoundFunction<typeof sendTransaction>;
+    batchSend: BoundFunction<typeof batchSendTransactions>;
+    batchSendAndTrack: BoundFunction<typeof batchSendAndTrack>;
+    sendAndTrack: BoundFunction<typeof sendAndTrackTxn>;
+    track: BoundFunction<typeof trackTransaction>;
+}
+interface BoundNonce {
+    createObserver(account: PubkeyInput, options?: AccountNonceObserverOptions): AccountNonceObserver;
+    createFeePayerManager(feePayer: PubkeyInput, options?: FeePayerNonceManagerOptions): FeePayerNonceManager;
+}
+interface BoundEvents {
+    get: BoundFunction<typeof getEvent>;
+    list: BoundFunction<typeof listEvents>;
+    stream: BoundFunction<typeof streamEvents>;
+}
+interface BoundProofs {
+    generate: BoundFunction<typeof generateStateProof>;
+    getStateRoots: BoundFunction<typeof getStateRoots>;
+}
+interface BoundKeys {
+    generateKeyPair: typeof generateKeyPair;
+    fromPrivateKey: typeof fromPrivateKey;
+}
+interface BoundVersion {
+    get: BoundFunction<typeof getVersion>;
+}
+interface BoundSlots {
+    getMetrics: BoundFunction<typeof getSlotMetrics>;
+    listMetrics: BoundFunction<typeof listSlotMetrics>;
+    streamMetrics: BoundFunction<typeof streamSlotMetrics>;
+}
+interface BoundNode {
+    getStatus: BoundFunction<typeof getNodeStatus>;
+    getPubkey: BoundFunction<typeof getNodePubkey>;
+    getRecords: BoundFunction<typeof getNodeRecords>;
+    streamRecords: BoundFunction<typeof streamNodeRecords>;
+}
+interface BoundChain {
+    getChainInfo: BoundFunction<typeof getChainInfo>;
+    getChainId: BoundFunction<typeof getChainId>;
+}
+interface BoundConsensus {
+    statusToString: typeof consensusStatusToString;
+    versionContext: typeof versionContext;
+    currentVersionContext: typeof currentVersionContext;
+    currentOrHistoricalVersionContext: typeof currentOrHistoricalVersionContext;
+    slotVersionContext: typeof slotVersionContext;
+    timestampVersionContext: typeof timestampVersionContext;
+    seqVersionContext: typeof seqVersionContext;
+}
+interface Helpers {
+    createSignature(value: SignatureInput): Signature;
+    createPubkey(value: PubkeyInput): Pubkey;
+    deriveProgramAddress(options: DeriveProgramAddressOptions): DeriveProgramAddressResult;
+    deriveAddress(inputs: DeriveAddressInput[]): DeriveAddressResult;
+}
+interface Thru {
+    ctx: ThruClientContext;
+    blocks: BoundBlocks;
+    accounts: BoundAccounts;
+    transactions: BoundTransactions;
+    events: BoundEvents;
+    slots: BoundSlots;
+    proofs: BoundProofs;
+    keys: BoundKeys;
+    version: BoundVersion;
+    consensus: BoundConsensus;
+    nonce: BoundNonce;
+    node: BoundNode;
+    chain: BoundChain;
+    helpers: Helpers;
+}
+
+declare function createThruClient(config?: ThruClientConfig): Thru;
+
+export { type StreamAccountUpdate as $, Account as A, type BatchSendAndTrackOptions as B, ChainEvent as C, type DeriveAddressInput as D, type ListBlocksOptions as E, type FeePayerNonceAllocation as F, type GenerateStateProofOptions as G, HeightSnapshot as H, type InstructionContext as I, type ListSlotMetricsOptions as J, type ListTransactionsForAccountOptions as K, type ListAccountsOptions as L, type PageRequestParams as M, PageResponse as N, type PageResponseParams as O, PageRequest as P, Pubkey as Q, type PubkeyInput as R, type RawAccountQueryOptions as S, type RawBlockQueryOptions as T, type RawTransactionQueryOptions as U, type SendAndTrackTxnOptions as V, type SendAndTrackTxnUpdate as W, Signature as X, type SignatureInput as Y, type SignedTransactionResult as Z, StateProof as _, AccountNonceObserver as a, type StreamAccountUpdatesOptions as a0, type StreamAccountUpdatesResult as a1, type StreamBlocksOptions as a2, type StreamBlocksResult as a3, type StreamEventsOptions as a4, type StreamEventsResult as a5, type StreamNodeRecordsOptions as a6, type StreamNodeRecordsResult as a7, type StreamSlotMetricsOptions as a8, type StreamSlotMetricsResult as a9, deriveProgramAddress as aA, events as aB, firstStreamValue as aC, forEachStreamValue as aD, height as aE, keys as aF, node as aG, nonce as aH, proofs as aI, slots as aJ, streaming as aK, transactions as aL, type StreamTransactionUpdate as aa, type StreamTransactionsOptions as ab, type StreamTransactionsResult as ac, type Thru as ad, type ThruClientConfig as ae, type TrackTransactionOptions as af, type TrackTransactionUpdate as ag, Transaction as ah, type TransactionAccountsConfig as ai, type TransactionExecutionEvent as aj, type TransactionExecutionResultData as ak, type TransactionFeePayerConfig as al, type TransactionHeaderConfig as am, type TransactionList as an, type TransactionQueryOptions as ao, TransactionStatusSnapshot as ap, type VersionContextInput as aq, VersionInfo as ar, type WaitForNonceOptions as as, accounts as at, blocks as au, chain as av, collectStream as aw, consensus as ax, createThruClient as ay, deriveAddress as az, type AccountNonceObserverOptions as b, type AccountQueryOptions as c, type BatchSendAndTrackResult as d, type BatchSendTransactionsOptions as e, type BatchTrackStatus as f, Block as g, type BlockList as h, type BlockQueryOptions as i, type BlockSelector as j, type BuildAndSignTransactionOptions as k, type BuildTransactionOptions as l, type BuildTransactionParams as m, type CreateAccountOptions as n, type DeriveAddressResult as o, type DeriveProgramAddressOptions as p, type DeriveProgramAddressResult as q, FeePayerNonceManager as r, type FeePayerNonceManagerOptions as s, Filter as t, FilterParamValue as u, type GeneratedKeyPair as v, type GetEventOptions as w, type GetStateRootsOptions as x, type HeightSnapshotParams as y, type InstructionData as z };