@thru/thru-sdk 0.1.34 → 0.1.38

package/dist/VersionInfo-Cw5HUNrn.d.ts

@@ -0,0 +1,960 @@
+import { Pubkey as Pubkey$1, TaPubkey, Signature as Signature$1, TsSignature, TransactionVmError, Transaction as Transaction$1, TransactionExecutionResult, ConsensusStatus, TransactionStatus, AccountFlags as AccountFlags$1, AccountMeta as AccountMeta$1, AccountData as AccountData$1, Account as Account$1, FilterParamValue as FilterParamValue$1, Filter as Filter$1, PageRequest as PageRequest$1, PageResponse as PageResponse$1, AccountView, VersionContext, DataSlice, RawAccount, ExecutionStatus, BlockFooter as BlockFooter$1, BlockHeader as BlockHeader$1, Block as Block$1, BlockView, RawBlock, Event, StreamEventsResponse, StateProof as StateProof$1, StateProofType, TransactionView, RawTransaction, BatchSendTransactionsResponse, GetVersionResponse } from '@thru/proto';
+import { Timestamp } from '@bufbuild/protobuf/wkt';
+import { Transport, createClient, CallOptions, Interceptor } from '@connectrpc/connect';
+import { GrpcWebTransportOptions } from '@connectrpc/connect-web';
+
+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[];
+}
+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;
+    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;
+    toWire(): Uint8Array;
+    getTransactions(): Transaction[];
+    private static extractTransactionBody;
+    private serializeHeader;
+    private serializeFooter;
+    private static parseHeader;
+    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 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 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>;
+
+declare const proofs_generateStateProof: typeof generateStateProof;
+declare namespace proofs {
+  export { proofs_generateStateProof as generateStateProof };
+}
+
+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 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_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_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_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_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;
+}
+declare function batchSendTransactions(ctx: ThruClientContext, transactions: (Transaction | Uint8Array)[], options?: BatchSendTransactionsOptions): Promise<BatchSendTransactionsResponse>;
+
+type transactions_BatchSendTransactionsOptions = BatchSendTransactionsOptions;
+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_TransactionAccountsConfig = TransactionAccountsConfig;
+type transactions_TransactionFeePayerConfig = TransactionFeePayerConfig;
+type transactions_TransactionHeaderConfig = TransactionHeaderConfig;
+type transactions_TransactionList = TransactionList;
+type transactions_TransactionQueryOptions = TransactionQueryOptions;
+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_sendTransaction: typeof sendTransaction;
+declare namespace transactions {
+  export { type transactions_BatchSendTransactionsOptions as BatchSendTransactionsOptions, 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_TransactionAccountsConfig as TransactionAccountsConfig, type transactions_TransactionFeePayerConfig as TransactionFeePayerConfig, type transactions_TransactionHeaderConfig as TransactionHeaderConfig, type transactions_TransactionList as TransactionList, type transactions_TransactionQueryOptions as TransactionQueryOptions, 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_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;
+}
+
+export { type StreamAccountUpdatesOptions as $, Account as A, type BuildTransactionParams as B, ChainEvent as C, type VersionContextInput as D, type AccountQueryOptions as E, Filter as F, type CreateAccountOptions as G, HeightSnapshot as H, type BlockList as I, type BlockQueryOptions as J, type ListBlocksOptions as K, type ListAccountsOptions as L, type RawBlockQueryOptions as M, type GetEventOptions as N, type BlockSelector as O, PageRequest as P, type DeriveAddressInput as Q, type RawAccountQueryOptions as R, type SignedTransactionResult as S, Transaction as T, type DeriveAddressResult as U, VersionInfo as V, type DeriveProgramAddressOptions as W, type DeriveProgramAddressResult as X, type GeneratedKeyPair as Y, type StreamAccountUpdate as Z, type HeightSnapshotParams as _, type ThruClientContext as a, type StreamAccountUpdatesResult as a0, type StreamBlocksOptions as a1, type StreamBlocksResult as a2, type StreamEventsOptions as a3, type StreamEventsResult as a4, type StreamTransactionsOptions as a5, type StreamTransactionsResult as a6, type StreamTransactionUpdate as a7, type TrackTransactionOptions as a8, type TrackTransactionUpdate as a9, getTransaction as aA, getRawTransaction as aB, getTransactionStatus as aC, listTransactions as aD, listTransactionsForAccount as aE, streamTransactions as aF, buildTransaction as aG, buildAndSignTransaction as aH, sendTransaction as aI, batchSendTransactions as aJ, trackTransaction as aK, getEvent as aL, listEvents as aM, streamEvents as aN, generateStateProof as aO, generateKeyPair as aP, fromPrivateKey as aQ, consensusStatusToString as aR, versionContext as aS, currentVersionContext as aT, currentOrHistoricalVersionContext as aU, slotVersionContext as aV, timestampVersionContext as aW, seqVersionContext as aX, type ThruClientConfig as aY, type TransactionExecutionEvent as aa, type TransactionExecutionResultData as ab, type InstructionContext as ac, type BatchSendTransactionsOptions as ad, type BuildAndSignTransactionOptions as ae, type BuildTransactionOptions as af, type InstructionData as ag, type ListTransactionsForAccountOptions as ah, type RawTransactionQueryOptions as ai, type TransactionAccountsConfig as aj, type TransactionFeePayerConfig as ak, type TransactionHeaderConfig as al, type TransactionList as am, type TransactionQueryOptions as an, type GenerateStateProofOptions as ao, getBlock as ap, getRawBlock as aq, listBlocks as ar, streamBlocks as as, getBlockHeight as at, streamHeight as au, getAccount as av, getRawAccount as aw, listAccounts as ax, streamAccountUpdates as ay, createAccount as az, accounts as b, blocks as c, consensus as d, events as e, Block as f, FilterParamValue as g, height as h, PageResponse as i, Pubkey as j, keys as k, Signature as l, StateProof as m, TransactionStatusSnapshot as n, deriveAddress as o, proofs as p, deriveProgramAddress as q, collectStream as r, streaming as s, transactions as t, firstStreamValue as u, forEachStreamValue as v, type PageRequestParams as w, type PageResponseParams as x, type PubkeyInput as y, type SignatureInput as z };