@thru/token-program 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,1144 @@
+import { Account } from '@thru/thru-sdk';
+
+type AccountLookupContext = {
+    getAccountIndex: (pubkey: Uint8Array) => number;
+};
+type InstructionData = (context: AccountLookupContext) => Promise<Uint8Array>;
+interface MintAccountInfo {
+    decimals: number;
+    supply: bigint;
+    creator: string;
+    mintAuthority: string;
+    freezeAuthority: string | null;
+    hasFreezeAuthority: boolean;
+    ticker: string;
+}
+interface TokenAccountInfo {
+    mint: string;
+    owner: string;
+    amount: bigint;
+    isFrozen: boolean;
+}
+interface InitializeMintArgs {
+    mintAccountBytes: Uint8Array;
+    decimals: number;
+    creatorBytes?: Uint8Array;
+    mintAuthorityBytes: Uint8Array;
+    freezeAuthorityBytes?: Uint8Array;
+    ticker: string;
+    seedHex: string;
+    stateProof: Uint8Array;
+}
+interface InitializeAccountArgs {
+    tokenAccountBytes: Uint8Array;
+    mintAccountBytes: Uint8Array;
+    ownerAccountBytes: Uint8Array;
+    seedBytes: Uint8Array;
+    stateProof: Uint8Array;
+}
+interface MintToArgs {
+    mintAccountBytes: Uint8Array;
+    destinationAccountBytes: Uint8Array;
+    authorityAccountBytes: Uint8Array;
+    amount: bigint;
+}
+interface TransferArgs {
+    sourceAccountBytes: Uint8Array;
+    destinationAccountBytes: Uint8Array;
+    amount: bigint;
+}
+
+declare const PUBKEY_LENGTH = 32;
+declare const TICKER_MAX_LENGTH = 8;
+declare const ZERO_PUBKEY: Uint8Array<ArrayBuffer>;
+
+declare function createInitializeMintInstruction({ mintAccountBytes, decimals, mintAuthorityBytes, freezeAuthorityBytes, ticker, seedHex, stateProof, creatorBytes, }: InitializeMintArgs): InstructionData;
+
+declare function createInitializeAccountInstruction(args: InitializeAccountArgs): InstructionData;
+
+declare function createMintToInstruction(args: MintToArgs): InstructionData;
+
+declare function createTransferInstruction(args: TransferArgs): InstructionData;
+
+type __TnValidateResult$2 = {
+    ok: boolean;
+    code?: string;
+    consumed?: bigint;
+};
+declare class Hash {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): Hash;
+    static builder(): HashBuilder;
+    static fromBuilder(builder: HashBuilder): Hash | null;
+    get_bytes(): number[];
+    set_bytes(value: number[]): void;
+    get bytes(): number[];
+    set bytes(value: number[]);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult$2;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+    static from_array(buffer: Uint8Array): Hash | null;
+}
+declare class HashBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_bytes(values: number[]): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): Hash;
+}
+declare class Pubkey {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): Pubkey;
+    static builder(): PubkeyBuilder;
+    static fromBuilder(builder: PubkeyBuilder): Pubkey | null;
+    get_bytes(): number[];
+    set_bytes(value: number[]): void;
+    get bytes(): number[];
+    set bytes(value: number[]);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult$2;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+    static from_array(buffer: Uint8Array): Pubkey | null;
+}
+declare class PubkeyBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_bytes(values: number[]): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): Pubkey;
+}
+
+type __TnValidateResult$1 = {
+    ok: boolean;
+    code?: string;
+    consumed?: bigint;
+};
+type __TnBuilderLike$1 = {
+    build(): Uint8Array;
+};
+type __TnVariantDescriptor$1 = {
+    readonly name: string;
+    readonly tag: number;
+    readonly payloadSize: number | null;
+    readonly payloadType?: string;
+    readonly createPayloadBuilder?: () => unknown | null;
+};
+type __TnVariantSelectorResult$1<Parent> = {
+    select(name: string): {
+        writePayload(payload: Uint8Array | __TnBuilderLike$1): {
+            finish(): Parent;
+        };
+    };
+    finish(): Parent;
+};
+declare class StateProofHeader {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): StateProofHeader;
+    static builder(): StateProofHeaderBuilder;
+    static fromBuilder(builder: StateProofHeaderBuilder): StateProofHeader | null;
+    get_type_slot(): bigint;
+    set_type_slot(value: bigint): void;
+    get type_slot(): bigint;
+    set type_slot(value: bigint);
+    get_path_bitset(): Hash;
+    set_path_bitset(value: Hash): void;
+    get path_bitset(): Hash;
+    set path_bitset(value: Hash);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult$1;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+    static from_array(buffer: Uint8Array): StateProofHeader | null;
+}
+declare class StateProofHeaderBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_type_slot(value: number): this;
+    set_path_bitset(value: Uint8Array): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): StateProofHeader;
+}
+declare class StateProof_proof_body_existing_Inner {
+    private buffer;
+    private view;
+    private __tnFieldContext;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): StateProof_proof_body_existing_Inner;
+    withFieldContext(context: Record<string, number | bigint>): this;
+    private __tnResolveFieldRef;
+    get_sibling_hashes_length(): number;
+    get_sibling_hashes_at(index: number): Hash;
+    get_sibling_hashes(): Hash[];
+    set_sibling_hashes_at(index: number, value: Hash): void;
+    set_sibling_hashes(value: Hash[]): void;
+    get sibling_hashes(): Hash[];
+    set sibling_hashes(value: Hash[]);
+}
+declare class StateProof_proof_body_updating_Inner {
+    private buffer;
+    private view;
+    private __tnFieldContext;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): StateProof_proof_body_updating_Inner;
+    withFieldContext(context: Record<string, number | bigint>): this;
+    private __tnResolveFieldRef;
+    get_existing_leaf_hash(): Hash;
+    set_existing_leaf_hash(value: Hash): void;
+    get existing_leaf_hash(): Hash;
+    set existing_leaf_hash(value: Hash);
+    get_sibling_hashes_length(): number;
+    get_sibling_hashes_at(index: number): Hash;
+    get_sibling_hashes(): Hash[];
+    set_sibling_hashes_at(index: number, value: Hash): void;
+    set_sibling_hashes(value: Hash[]): void;
+    get sibling_hashes(): Hash[];
+    set sibling_hashes(value: Hash[]);
+}
+declare class StateProof_proof_body_creation_Inner {
+    private buffer;
+    private view;
+    private __tnFieldContext;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): StateProof_proof_body_creation_Inner;
+    withFieldContext(context: Record<string, number | bigint>): this;
+    private __tnResolveFieldRef;
+    get_existing_leaf_pubkey(): Pubkey;
+    set_existing_leaf_pubkey(value: Pubkey): void;
+    get existing_leaf_pubkey(): Pubkey;
+    set existing_leaf_pubkey(value: Pubkey);
+    get_existing_leaf_hash(): Hash;
+    set_existing_leaf_hash(value: Hash): void;
+    get existing_leaf_hash(): Hash;
+    set existing_leaf_hash(value: Hash);
+    get_sibling_hashes_length(): number;
+    get_sibling_hashes_at(index: number): Hash;
+    get_sibling_hashes(): Hash[];
+    set_sibling_hashes_at(index: number, value: Hash): void;
+    set_sibling_hashes(value: Hash[]): void;
+    get sibling_hashes(): Hash[];
+    set sibling_hashes(value: Hash[]);
+}
+declare class StateProof_proof_body_Inner {
+    private buffer;
+    private descriptor;
+    private view;
+    private __tnFieldContext;
+    private constructor();
+    static __tnCreate(payload: Uint8Array, descriptor: __TnVariantDescriptor$1 | null, fieldContext?: Record<string, number | bigint>): StateProof_proof_body_Inner;
+    bytes(): Uint8Array;
+    variant(): __TnVariantDescriptor$1 | null;
+    asExisting(): StateProof_proof_body_existing_Inner | null;
+    asUpdating(): StateProof_proof_body_updating_Inner | null;
+    asCreation(): StateProof_proof_body_creation_Inner | null;
+}
+declare class StateProof {
+    private buffer;
+    private view;
+    private __tnFieldContext;
+    private static readonly __tnFieldOffset_proof_body;
+    private __tnParams;
+    private __tnDerivedParams;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        params?: StateProof.Params;
+        fieldContext?: Record<string, number | bigint>;
+    }): StateProof;
+    dynamicParams(): StateProof.Params;
+    withFieldContext(context: Record<string, number | bigint>): this;
+    private __tnResolveFieldRef;
+    static builder(): StateProofBuilder;
+    static fromBuilder(builder: StateProofBuilder): StateProof | null;
+    static readonly proof_bodyVariantDescriptors: readonly [{
+        readonly name: "existing";
+        readonly tag: 0;
+        readonly payloadSize: null;
+        readonly payloadType: "StateProof::proof_body::existing";
+        readonly createPayloadBuilder: () => null;
+    }, {
+        readonly name: "updating";
+        readonly tag: 1;
+        readonly payloadSize: null;
+        readonly payloadType: "StateProof::proof_body::updating";
+        readonly createPayloadBuilder: () => null;
+    }, {
+        readonly name: "creation";
+        readonly tag: 2;
+        readonly payloadSize: null;
+        readonly payloadType: "StateProof::proof_body::creation";
+        readonly createPayloadBuilder: () => null;
+    }];
+    static __tnComputeSequentialLayout(view: DataView, buffer: Uint8Array): {
+        params: Record<string, bigint> | null;
+        offsets: Record<string, number> | null;
+        derived: Record<string, bigint> | null;
+    } | null;
+    private static __tnExtractParams;
+    private __tnEnsureDerivedParams;
+    private __tnReadDerivedParam;
+    get_hdr(): StateProofHeader;
+    set_hdr(value: StateProofHeader): void;
+    get hdr(): StateProofHeader;
+    set hdr(value: StateProofHeader);
+    get_proof_body_computed_tag(): number;
+    proofBodyVariant(): typeof StateProof.proof_bodyVariantDescriptors[number] | null;
+    proof_body(): StateProof_proof_body_Inner;
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult$1;
+    static footprintIr(proof_body_hdr_type_slot: number | bigint, proof_body_payload_size: number | bigint): bigint;
+    private static __tnPackParams;
+    static footprintIrFromParams(params: StateProof.Params): bigint;
+    static footprintFromParams(params: StateProof.Params): number;
+    static footprintFromValues(input: {
+        proof_body_hdr_type_slot: number | bigint;
+        proof_body_payload_size: number | bigint;
+    }): number;
+    static footprint(params: StateProof.Params): number;
+    static validate(buffer: Uint8Array, opts?: {
+        params?: StateProof.Params;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+        params?: StateProof.Params;
+    };
+    static from_array(buffer: Uint8Array, opts?: {
+        params?: StateProof.Params;
+    }): StateProof | null;
+}
+declare namespace StateProof {
+    type Params = {
+        /** ABI path: proof_body.hdr.type_slot */
+        readonly proof_body_hdr_type_slot: bigint;
+        /** ABI path: proof_body.payload_size */
+        readonly proof_body_payload_size: bigint;
+    };
+    const ParamKeys: Readonly<{
+        readonly proof_body_hdr_type_slot: "proof_body.hdr.type_slot";
+        readonly proof_body_payload_size: "proof_body.payload_size";
+    }>;
+    const Params: {
+        fromValues(input: {
+            proof_body_hdr_type_slot: number | bigint;
+            proof_body_payload_size: number | bigint;
+        }): Params;
+        fromBuilder(source: {
+            dynamicParams(): Params;
+        } | {
+            params: Params;
+        } | Params): Params;
+    };
+    function params(input: {
+        proof_body_hdr_type_slot: number | bigint;
+        proof_body_payload_size: number | bigint;
+    }): Params;
+}
+declare class StateProofBuilder {
+    private __tnPrefixBuffer;
+    private __tnPrefixView;
+    private __tnPayload_proof_body;
+    private __tnCachedParams;
+    private __tnLastBuffer;
+    private __tnLastParams;
+    private __tnVariantSelector_proof_body?;
+    constructor();
+    set_hdr(value: Uint8Array): this;
+    private __tnInvalidate;
+    proof_body(): __TnVariantSelectorResult$1<StateProofBuilder>;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): StateProof;
+    finishView(): StateProof;
+    dynamicParams(): StateProof.Params;
+    private __tnComputeParams;
+    private __tnWriteInto;
+    private __tnValidateOrThrow;
+}
+
+type __TnValidateResult = {
+    ok: boolean;
+    code?: string;
+    consumed?: bigint;
+};
+type __TnBuilderLike = {
+    build(): Uint8Array;
+};
+type __TnStructFieldInput = Uint8Array | __TnBuilderLike | {
+    buffer?: Uint8Array;
+} | {
+    asUint8Array?: () => Uint8Array;
+} | {
+    bytes?: () => Uint8Array;
+};
+type __TnVariantDescriptor = {
+    readonly name: string;
+    readonly tag: number;
+    readonly payloadSize: number | null;
+    readonly payloadType?: string;
+    readonly createPayloadBuilder?: () => unknown | null;
+};
+type __TnVariantSelectorResult<Parent> = {
+    select(name: string): {
+        writePayload(payload: Uint8Array | __TnBuilderLike): {
+            finish(): Parent;
+        };
+    };
+    finish(): Parent;
+};
+declare class BurnInstruction {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): BurnInstruction;
+    static builder(): BurnInstructionBuilder;
+    static fromBuilder(builder: BurnInstructionBuilder): BurnInstruction | null;
+    get_token_account_index(): number;
+    set_token_account_index(value: number): void;
+    get token_account_index(): number;
+    set token_account_index(value: number);
+    get_mint_account_index(): number;
+    set_mint_account_index(value: number): void;
+    get mint_account_index(): number;
+    set mint_account_index(value: number);
+    get_authority_account_index(): number;
+    set_authority_account_index(value: number): void;
+    get authority_account_index(): number;
+    set authority_account_index(value: number);
+    get_amount(): bigint;
+    set_amount(value: bigint): void;
+    get amount(): bigint;
+    set amount(value: bigint);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+    static new(token_account_index: number, mint_account_index: number, authority_account_index: number, amount: bigint): BurnInstruction;
+    static from_array(buffer: Uint8Array): BurnInstruction | null;
+}
+declare class BurnInstructionBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_token_account_index(value: number): this;
+    set_mint_account_index(value: number): this;
+    set_authority_account_index(value: number): this;
+    set_amount(value: number): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): BurnInstruction;
+}
+declare class CloseAccountInstruction {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): CloseAccountInstruction;
+    static builder(): CloseAccountInstructionBuilder;
+    static fromBuilder(builder: CloseAccountInstructionBuilder): CloseAccountInstruction | null;
+    get_token_account_index(): number;
+    set_token_account_index(value: number): void;
+    get token_account_index(): number;
+    set token_account_index(value: number);
+    get_dest_account_index(): number;
+    set_dest_account_index(value: number): void;
+    get dest_account_index(): number;
+    set dest_account_index(value: number);
+    get_authority_account_index(): number;
+    set_authority_account_index(value: number): void;
+    get authority_account_index(): number;
+    set authority_account_index(value: number);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+    static new(token_account_index: number, dest_account_index: number, authority_account_index: number): CloseAccountInstruction;
+    static from_array(buffer: Uint8Array): CloseAccountInstruction | null;
+}
+declare class CloseAccountInstructionBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_token_account_index(value: number): this;
+    set_dest_account_index(value: number): this;
+    set_authority_account_index(value: number): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): CloseAccountInstruction;
+}
+declare class FreezeAccountInstruction {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): FreezeAccountInstruction;
+    static builder(): FreezeAccountInstructionBuilder;
+    static fromBuilder(builder: FreezeAccountInstructionBuilder): FreezeAccountInstruction | null;
+    get_token_account_index(): number;
+    set_token_account_index(value: number): void;
+    get token_account_index(): number;
+    set token_account_index(value: number);
+    get_mint_account_index(): number;
+    set_mint_account_index(value: number): void;
+    get mint_account_index(): number;
+    set mint_account_index(value: number);
+    get_authority_account_index(): number;
+    set_authority_account_index(value: number): void;
+    get authority_account_index(): number;
+    set authority_account_index(value: number);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+    static new(token_account_index: number, mint_account_index: number, authority_account_index: number): FreezeAccountInstruction;
+    static from_array(buffer: Uint8Array): FreezeAccountInstruction | null;
+}
+declare class FreezeAccountInstructionBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_token_account_index(value: number): this;
+    set_mint_account_index(value: number): this;
+    set_authority_account_index(value: number): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): FreezeAccountInstruction;
+}
+declare class MintToInstruction {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): MintToInstruction;
+    static builder(): MintToInstructionBuilder;
+    static fromBuilder(builder: MintToInstructionBuilder): MintToInstruction | null;
+    get_mint_account_index(): number;
+    set_mint_account_index(value: number): void;
+    get mint_account_index(): number;
+    set mint_account_index(value: number);
+    get_dest_account_index(): number;
+    set_dest_account_index(value: number): void;
+    get dest_account_index(): number;
+    set dest_account_index(value: number);
+    get_authority_account_index(): number;
+    set_authority_account_index(value: number): void;
+    get authority_account_index(): number;
+    set authority_account_index(value: number);
+    get_amount(): bigint;
+    set_amount(value: bigint): void;
+    get amount(): bigint;
+    set amount(value: bigint);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+    static new(mint_account_index: number, dest_account_index: number, authority_account_index: number, amount: bigint): MintToInstruction;
+    static from_array(buffer: Uint8Array): MintToInstruction | null;
+}
+declare class MintToInstructionBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_mint_account_index(value: number): this;
+    set_dest_account_index(value: number): this;
+    set_authority_account_index(value: number): this;
+    set_amount(value: number): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): MintToInstruction;
+}
+declare class Seed32 {
+    private buffer;
+    private view;
+    private constructor();
+    private static readonly __tnElementSize;
+    private static readonly __tnElementCount;
+    get length(): number;
+    getElementBytes(index: number): Uint8Array;
+    static from_array(buffer: Uint8Array): Seed32 | null;
+    asUint8Array(): Uint8Array;
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+}
+declare class ThawAccountInstruction {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): ThawAccountInstruction;
+    static builder(): ThawAccountInstructionBuilder;
+    static fromBuilder(builder: ThawAccountInstructionBuilder): ThawAccountInstruction | null;
+    get_token_account_index(): number;
+    set_token_account_index(value: number): void;
+    get token_account_index(): number;
+    set token_account_index(value: number);
+    get_mint_account_index(): number;
+    set_mint_account_index(value: number): void;
+    get mint_account_index(): number;
+    set mint_account_index(value: number);
+    get_authority_account_index(): number;
+    set_authority_account_index(value: number): void;
+    get authority_account_index(): number;
+    set authority_account_index(value: number);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+    static new(token_account_index: number, mint_account_index: number, authority_account_index: number): ThawAccountInstruction;
+    static from_array(buffer: Uint8Array): ThawAccountInstruction | null;
+}
+declare class ThawAccountInstructionBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_token_account_index(value: number): this;
+    set_mint_account_index(value: number): this;
+    set_authority_account_index(value: number): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): ThawAccountInstruction;
+}
+declare class TickerField {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): TickerField;
+    static builder(): TickerFieldBuilder;
+    static fromBuilder(builder: TickerFieldBuilder): TickerField | null;
+    get_length(): number;
+    set_length(value: number): void;
+    get length(): number;
+    set length(value: number);
+    get_bytes(): number[];
+    set_bytes(value: number[]): void;
+    get bytes(): number[];
+    set bytes(value: number[]);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+    static from_array(buffer: Uint8Array): TickerField | null;
+}
+declare class TickerFieldBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_length(value: number): this;
+    set_bytes(values: number[]): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): TickerField;
+}
+declare class TransferInstruction {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): TransferInstruction;
+    static builder(): TransferInstructionBuilder;
+    static fromBuilder(builder: TransferInstructionBuilder): TransferInstruction | null;
+    get_source_account_index(): number;
+    set_source_account_index(value: number): void;
+    get source_account_index(): number;
+    set source_account_index(value: number);
+    get_dest_account_index(): number;
+    set_dest_account_index(value: number): void;
+    get dest_account_index(): number;
+    set dest_account_index(value: number);
+    get_amount(): bigint;
+    set_amount(value: bigint): void;
+    get amount(): bigint;
+    set amount(value: bigint);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+    static new(source_account_index: number, dest_account_index: number, amount: bigint): TransferInstruction;
+    static from_array(buffer: Uint8Array): TransferInstruction | null;
+}
+declare class TransferInstructionBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_source_account_index(value: number): this;
+    set_dest_account_index(value: number): this;
+    set_amount(value: number): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): TransferInstruction;
+}
+declare class InitializeAccountInstruction {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): InitializeAccountInstruction;
+    static builder(): InitializeAccountInstructionBuilder;
+    static fromBuilder(builder: InitializeAccountInstructionBuilder): InitializeAccountInstruction | null;
+    get_token_account_index(): number;
+    set_token_account_index(value: number): void;
+    get token_account_index(): number;
+    set token_account_index(value: number);
+    get_mint_account_index(): number;
+    set_mint_account_index(value: number): void;
+    get mint_account_index(): number;
+    set mint_account_index(value: number);
+    get_owner_account_index(): number;
+    set_owner_account_index(value: number): void;
+    get owner_account_index(): number;
+    set owner_account_index(value: number);
+    get_new_account_seed(): Seed32;
+    set_new_account_seed(value: Seed32): void;
+    get new_account_seed(): Seed32;
+    set new_account_seed(value: Seed32);
+    get_state_proof(): StateProof;
+    set_state_proof(value: StateProof): void;
+    get state_proof(): StateProof;
+    set state_proof(value: StateProof);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(_buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+    static from_array(buffer: Uint8Array): InitializeAccountInstruction | null;
+}
+declare class InitializeAccountInstructionBuilder {
+    private buffer;
+    private view;
+    private __tnTail_state_proof;
+    constructor();
+    private __tnInvalidate;
+    set_token_account_index(value: number): this;
+    set_mint_account_index(value: number): this;
+    set_owner_account_index(value: number): this;
+    set_new_account_seed(value: Uint8Array): this;
+    set_state_proof(value: StateProof | __TnStructFieldInput): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): InitializeAccountInstruction;
+    finishView(): InitializeAccountInstruction;
+    private __tnCollectTailFragments;
+    private __tnComputeSize;
+    private __tnWriteInto;
+    private __tnValidateOrThrow;
+}
+declare class InitializeMintInstruction {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): InitializeMintInstruction;
+    static builder(): InitializeMintInstructionBuilder;
+    static fromBuilder(builder: InitializeMintInstructionBuilder): InitializeMintInstruction | null;
+    get_mint_account_index(): number;
+    set_mint_account_index(value: number): void;
+    get mint_account_index(): number;
+    set mint_account_index(value: number);
+    get_decimals(): number;
+    set_decimals(value: number): void;
+    get decimals(): number;
+    set decimals(value: number);
+    get_creator(): Pubkey;
+    set_creator(value: Pubkey): void;
+    get creator(): Pubkey;
+    set creator(value: Pubkey);
+    get_mint_authority(): Pubkey;
+    set_mint_authority(value: Pubkey): void;
+    get mint_authority(): Pubkey;
+    set mint_authority(value: Pubkey);
+    get_freeze_authority(): Pubkey;
+    set_freeze_authority(value: Pubkey): void;
+    get freeze_authority(): Pubkey;
+    set freeze_authority(value: Pubkey);
+    get_has_freeze_authority(): number;
+    set_has_freeze_authority(value: number): void;
+    get has_freeze_authority(): number;
+    set has_freeze_authority(value: number);
+    get_ticker(): TickerField;
+    set_ticker(value: TickerField): void;
+    get ticker(): TickerField;
+    set ticker(value: TickerField);
+    get_seed(): Seed32;
+    set_seed(value: Seed32): void;
+    get seed(): Seed32;
+    set seed(value: Seed32);
+    get_state_proof(): StateProof;
+    set_state_proof(value: StateProof): void;
+    get state_proof(): StateProof;
+    set state_proof(value: StateProof);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(): bigint;
+    static footprint(): number;
+    static validate(_buffer: Uint8Array, _opts?: {
+        params?: never;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+    };
+    static from_array(buffer: Uint8Array): InitializeMintInstruction | null;
+}
+declare class InitializeMintInstructionBuilder {
+    private buffer;
+    private view;
+    private __tnTail_state_proof;
+    constructor();
+    private __tnInvalidate;
+    set_mint_account_index(value: number): this;
+    set_decimals(value: number): this;
+    set_creator(value: Uint8Array): this;
+    set_mint_authority(value: Uint8Array): this;
+    set_freeze_authority(value: Uint8Array): this;
+    set_has_freeze_authority(value: number): this;
+    set_ticker(value: Uint8Array): this;
+    set_seed(value: Uint8Array): this;
+    set_state_proof(value: StateProof | __TnStructFieldInput): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): InitializeMintInstruction;
+    finishView(): InitializeMintInstruction;
+    private __tnCollectTailFragments;
+    private __tnComputeSize;
+    private __tnWriteInto;
+    private __tnValidateOrThrow;
+}
+declare class TokenInstruction_payload_Inner {
+    private buffer;
+    private descriptor;
+    private view;
+    private __tnFieldContext;
+    private constructor();
+    static __tnCreate(payload: Uint8Array, descriptor: __TnVariantDescriptor | null, fieldContext?: Record<string, number | bigint>): TokenInstruction_payload_Inner;
+    bytes(): Uint8Array;
+    variant(): __TnVariantDescriptor | null;
+    asInitializeMint(): InitializeMintInstruction | null;
+    asInitializeAccount(): InitializeAccountInstruction | null;
+    asTransfer(): TransferInstruction | null;
+    asMintTo(): MintToInstruction | null;
+    asBurn(): BurnInstruction | null;
+    asCloseAccount(): CloseAccountInstruction | null;
+    asFreezeAccount(): FreezeAccountInstruction | null;
+    asThawAccount(): ThawAccountInstruction | null;
+}
+declare class TokenInstruction {
+    private buffer;
+    private view;
+    private static readonly __tnFieldOffset_payload;
+    private __tnParams;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        params?: TokenInstruction.Params;
+    }): TokenInstruction;
+    dynamicParams(): TokenInstruction.Params;
+    static builder(): TokenInstructionBuilder;
+    static fromBuilder(builder: TokenInstructionBuilder): TokenInstruction | null;
+    static readonly payloadVariantDescriptors: readonly [{
+        readonly name: "initialize_mint";
+        readonly tag: 0;
+        readonly payloadSize: null;
+        readonly payloadType: "TokenInstruction::payload::initialize_mint";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "initialize_account";
+        readonly tag: 1;
+        readonly payloadSize: null;
+        readonly payloadType: "TokenInstruction::payload::initialize_account";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "transfer";
+        readonly tag: 2;
+        readonly payloadSize: 12;
+        readonly payloadType: "TokenInstruction::payload::transfer";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "mint_to";
+        readonly tag: 3;
+        readonly payloadSize: 14;
+        readonly payloadType: "TokenInstruction::payload::mint_to";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "burn";
+        readonly tag: 4;
+        readonly payloadSize: 14;
+        readonly payloadType: "TokenInstruction::payload::burn";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "close_account";
+        readonly tag: 5;
+        readonly payloadSize: 6;
+        readonly payloadType: "TokenInstruction::payload::close_account";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "freeze_account";
+        readonly tag: 6;
+        readonly payloadSize: 6;
+        readonly payloadType: "TokenInstruction::payload::freeze_account";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "thaw_account";
+        readonly tag: 7;
+        readonly payloadSize: 6;
+        readonly payloadType: "TokenInstruction::payload::thaw_account";
+        readonly createPayloadBuilder: () => unknown;
+    }];
+    static __tnComputeSequentialLayout(view: DataView, buffer: Uint8Array): {
+        params: Record<string, bigint> | null;
+        offsets: Record<string, number> | null;
+        derived: Record<string, bigint> | null;
+    } | null;
+    private static __tnExtractParams;
+    get_tag(): number;
+    set_tag(value: number): void;
+    get tag(): number;
+    set tag(value: number);
+    payloadVariant(): typeof TokenInstruction.payloadVariantDescriptors[number] | null;
+    payload(): TokenInstruction_payload_Inner;
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(payload_payload_size: number | bigint, payload_tag: number | bigint): bigint;
+    private static __tnPackParams;
+    static footprintIrFromParams(params: TokenInstruction.Params): bigint;
+    static footprintFromParams(params: TokenInstruction.Params): number;
+    static footprintFromValues(input: {
+        payload_payload_size: number | bigint;
+        payload_tag: number | bigint;
+    }): number;
+    static footprint(params: TokenInstruction.Params): number;
+    static validate(buffer: Uint8Array, opts?: {
+        params?: TokenInstruction.Params;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+        params?: TokenInstruction.Params;
+    };
+    static from_array(buffer: Uint8Array, opts?: {
+        params?: TokenInstruction.Params;
+    }): TokenInstruction | null;
+}
+declare namespace TokenInstruction {
+    type Params = {
+        /** ABI path: payload.payload_size */
+        readonly payload_payload_size: bigint;
+        /** ABI path: payload.tag */
+        readonly payload_tag: bigint;
+    };
+    const ParamKeys: Readonly<{
+        readonly payload_payload_size: "payload.payload_size";
+        readonly payload_tag: "payload.tag";
+    }>;
+    const Params: {
+        fromValues(input: {
+            payload_payload_size: number | bigint;
+            payload_tag: number | bigint;
+        }): Params;
+        fromBuilder(source: {
+            dynamicParams(): Params;
+        } | {
+            params: Params;
+        } | Params): Params;
+    };
+    function params(input: {
+        payload_payload_size: number | bigint;
+        payload_tag: number | bigint;
+    }): Params;
+}
+declare class TokenInstructionBuilder {
+    private __tnPrefixBuffer;
+    private __tnPrefixView;
+    private __tnField_tag;
+    private __tnPayload_payload;
+    private __tnCachedParams;
+    private __tnLastBuffer;
+    private __tnLastParams;
+    private __tnVariantSelector_payload?;
+    constructor();
+    private __tnInvalidate;
+    private __tnAssign_tag;
+    set_tag(value: number): this;
+    payload(): __TnVariantSelectorResult<TokenInstructionBuilder>;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): TokenInstruction;
+    finishView(): TokenInstruction;
+    dynamicParams(): TokenInstruction.Params;
+    private __tnComputeParams;
+    private __tnWriteInto;
+    private __tnValidateOrThrow;
+}
+
+type TokenInstructionVariantName = (typeof TokenInstruction.payloadVariantDescriptors)[number]['name'];
+declare function buildTokenInstructionBytes(variant: TokenInstructionVariantName, payload: Uint8Array): Uint8Array;
+
+declare function deriveMintAddress(mintAuthorityAddress: string, seed: string, tokenProgramAddress: string): {
+    address: string;
+    bytes: Uint8Array;
+    derivedSeed: Uint8Array;
+};
+declare function deriveTokenAccountAddress(ownerAddress: string, mintAddress: string, tokenProgramAddress: string, seed?: Uint8Array): {
+    address: string;
+    bytes: Uint8Array;
+    derivedSeed: Uint8Array;
+};
+declare function deriveWalletSeed(walletAddress: string, extraSeeds?: Uint8Array[]): Uint8Array;
+
+declare function parseMintAccountData(account: Account): MintAccountInfo;
+declare function parseTokenAccountData(account: Account): TokenAccountInfo;
+declare function isAccountNotFoundError(err: unknown): boolean;
+
+declare function formatRawAmount(amount: bigint, decimals: number): string;
+declare function bytesToHex(bytes: Uint8Array): string;
+declare function hexToBytes(hex: string): Uint8Array;
+
+export { type AccountLookupContext, type InitializeAccountArgs, type InitializeMintArgs, type InstructionData, type MintAccountInfo, type MintToArgs, PUBKEY_LENGTH, TICKER_MAX_LENGTH, type TokenAccountInfo, type TransferArgs, ZERO_PUBKEY, buildTokenInstructionBytes, bytesToHex, createInitializeAccountInstruction, createInitializeMintInstruction, createMintToInstruction, createTransferInstruction, deriveMintAddress, deriveTokenAccountAddress, deriveWalletSeed, formatRawAmount, hexToBytes, isAccountNotFoundError, parseMintAccountData, parseTokenAccountData };