@thru/thru-sdk 0.1.34 → 0.1.36

package/dist/VersionInfo-BBuhryfs.d.ts

@@ -0,0 +1,930 @@
+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;
+    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;
+}
+interface BuildTransactionParams {
+    feePayer: FeePayerInput;
+    program: PubkeyInput;
+    header: TransactionHeaderInput;
+    accounts?: TransactionAccountsInput;
+    instructionData?: Uint8Array | string;
+    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 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;
+}
+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;
+    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;
+    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 StreamAccountUpdatesResult as $, Account as A, type BuildTransactionParams as B, ChainEvent as C, type AccountQueryOptions as D, type CreateAccountOptions as E, Filter as F, type BlockList as G, HeightSnapshot as H, type BlockQueryOptions as I, type ListBlocksOptions as J, type RawBlockQueryOptions as K, type ListAccountsOptions as L, type GetEventOptions as M, type BlockSelector as N, type DeriveAddressInput as O, PageRequest as P, type DeriveAddressResult as Q, type RawAccountQueryOptions as R, type SignedTransactionResult as S, Transaction as T, type DeriveProgramAddressOptions as U, VersionInfo as V, type DeriveProgramAddressResult as W, type GeneratedKeyPair as X, type StreamAccountUpdate as Y, type HeightSnapshotParams as Z, type StreamAccountUpdatesOptions as _, accounts as a, type StreamBlocksOptions as a0, type StreamBlocksResult as a1, type StreamEventsOptions as a2, type StreamEventsResult as a3, type StreamTransactionsOptions as a4, type StreamTransactionsResult as a5, type StreamTransactionUpdate as a6, type TrackTransactionOptions as a7, type TrackTransactionUpdate as a8, type TransactionExecutionEvent 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 TransactionExecutionResultData as aa, type InstructionContext as ab, type BatchSendTransactionsOptions as ac, type BuildAndSignTransactionOptions as ad, type BuildTransactionOptions as ae, type InstructionData as af, type ListTransactionsForAccountOptions as ag, type RawTransactionQueryOptions as ah, type TransactionAccountsConfig as ai, type TransactionFeePayerConfig as aj, type TransactionHeaderConfig as ak, type TransactionList as al, type TransactionQueryOptions as am, type GenerateStateProofOptions as an, type ThruClientContext 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, blocks as b, consensus as c, Block as d, events as e, FilterParamValue as f, PageResponse as g, height as h, Pubkey as i, Signature as j, keys as k, StateProof as l, TransactionStatusSnapshot as m, deriveAddress as n, deriveProgramAddress as o, proofs as p, collectStream as q, firstStreamValue as r, streaming as s, transactions as t, forEachStreamValue as u, type PageRequestParams as v, type PageResponseParams as w, type PubkeyInput as x, type SignatureInput as y, type VersionContextInput as z };