@thru/programs 0.2.30 → 0.2.31

package/dist/amm/index.d.cts

@@ -0,0 +1,1424 @@
+import { Account } from '@thru/sdk';
+import { Thru } from '@thru/sdk/client';
+
+type __TnValidateResult$1 = {
+    ok: boolean;
+    code?: string;
+    consumed?: bigint;
+    params?: Record<string, bigint>;
+};
+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$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): 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 = {
+    ok: boolean;
+    code?: string;
+    consumed?: bigint;
+    params?: Record<string, bigint>;
+};
+type __TnBuilderLike = {
+    build(): 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;
+};
+type __TnFamWriterResult<Parent> = {
+    write(payload: Uint8Array | __TnBuilderLike): {
+        finish(): Parent;
+    };
+    finish(): Parent;
+};
+declare class AmmAddLiquidityInstruction {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): AmmAddLiquidityInstruction;
+    static builder(): AmmAddLiquidityInstructionBuilder;
+    static fromBuilder(builder: AmmAddLiquidityInstructionBuilder): AmmAddLiquidityInstruction | null;
+    get_pool_account_idx(): number;
+    set_pool_account_idx(value: number): void;
+    get pool_account_idx(): number;
+    set pool_account_idx(value: number);
+    get_depositor_account_idx(): number;
+    set_depositor_account_idx(value: number): void;
+    get depositor_account_idx(): number;
+    set depositor_account_idx(value: number);
+    get_depositor_token_one_account_idx(): number;
+    set_depositor_token_one_account_idx(value: number): void;
+    get depositor_token_one_account_idx(): number;
+    set depositor_token_one_account_idx(value: number);
+    get_depositor_token_two_account_idx(): number;
+    set_depositor_token_two_account_idx(value: number): void;
+    get depositor_token_two_account_idx(): number;
+    set depositor_token_two_account_idx(value: number);
+    get_depositor_lp_account_idx(): number;
+    set_depositor_lp_account_idx(value: number): void;
+    get depositor_lp_account_idx(): number;
+    set depositor_lp_account_idx(value: number);
+    get_vault_one_account_idx(): number;
+    set_vault_one_account_idx(value: number): void;
+    get vault_one_account_idx(): number;
+    set vault_one_account_idx(value: number);
+    get_vault_two_account_idx(): number;
+    set_vault_two_account_idx(value: number): void;
+    get vault_two_account_idx(): number;
+    set vault_two_account_idx(value: number);
+    get_lp_mint_account_idx(): number;
+    set_lp_mint_account_idx(value: number): void;
+    get lp_mint_account_idx(): number;
+    set lp_mint_account_idx(value: number);
+    get_token_program_account_idx(): number;
+    set_token_program_account_idx(value: number): void;
+    get token_program_account_idx(): number;
+    set token_program_account_idx(value: number);
+    get_max_amount_mint_one(): bigint;
+    set_max_amount_mint_one(value: bigint): void;
+    get max_amount_mint_one(): bigint;
+    set max_amount_mint_one(value: bigint);
+    get_max_amount_mint_two(): bigint;
+    set_max_amount_mint_two(value: bigint): void;
+    get max_amount_mint_two(): bigint;
+    set max_amount_mint_two(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(pool_account_idx: number, depositor_account_idx: number, depositor_token_one_account_idx: number, depositor_token_two_account_idx: number, depositor_lp_account_idx: number, vault_one_account_idx: number, vault_two_account_idx: number, lp_mint_account_idx: number, token_program_account_idx: number, max_amount_mint_one: bigint, max_amount_mint_two: bigint): AmmAddLiquidityInstruction;
+    static from_array(buffer: Uint8Array): AmmAddLiquidityInstruction | null;
+}
+declare class AmmAddLiquidityInstructionBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_pool_account_idx(value: number): this;
+    set_depositor_account_idx(value: number): this;
+    set_depositor_token_one_account_idx(value: number): this;
+    set_depositor_token_two_account_idx(value: number): this;
+    set_depositor_lp_account_idx(value: number): this;
+    set_vault_one_account_idx(value: number): this;
+    set_vault_two_account_idx(value: number): this;
+    set_lp_mint_account_idx(value: number): this;
+    set_token_program_account_idx(value: number): this;
+    set_max_amount_mint_one(value: bigint): this;
+    set_max_amount_mint_two(value: bigint): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): AmmAddLiquidityInstruction;
+}
+declare class AmmError {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): AmmError;
+    static builder(): AmmErrorBuilder;
+    static fromBuilder(builder: AmmErrorBuilder): AmmError | null;
+    get_code(): bigint;
+    set_code(value: bigint): void;
+    get code(): bigint;
+    set code(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(code: bigint): AmmError;
+    static from_array(buffer: Uint8Array): AmmError | null;
+}
+declare class AmmErrorBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_code(value: bigint): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): AmmError;
+}
+declare class AmmSwapInstruction {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): AmmSwapInstruction;
+    static builder(): AmmSwapInstructionBuilder;
+    static fromBuilder(builder: AmmSwapInstructionBuilder): AmmSwapInstruction | null;
+    get_pool_account_idx(): number;
+    set_pool_account_idx(value: number): void;
+    get pool_account_idx(): number;
+    set pool_account_idx(value: number);
+    get_user_transfer_authority_idx(): number;
+    set_user_transfer_authority_idx(value: number): void;
+    get user_transfer_authority_idx(): number;
+    set user_transfer_authority_idx(value: number);
+    get_user_input_account_idx(): number;
+    set_user_input_account_idx(value: number): void;
+    get user_input_account_idx(): number;
+    set user_input_account_idx(value: number);
+    get_user_output_account_idx(): number;
+    set_user_output_account_idx(value: number): void;
+    get user_output_account_idx(): number;
+    set user_output_account_idx(value: number);
+    get_vault_input_account_idx(): number;
+    set_vault_input_account_idx(value: number): void;
+    get vault_input_account_idx(): number;
+    set vault_input_account_idx(value: number);
+    get_vault_output_account_idx(): number;
+    set_vault_output_account_idx(value: number): void;
+    get vault_output_account_idx(): number;
+    set vault_output_account_idx(value: number);
+    get_lp_mint_account_idx(): number;
+    set_lp_mint_account_idx(value: number): void;
+    get lp_mint_account_idx(): number;
+    set lp_mint_account_idx(value: number);
+    get_token_program_account_idx(): number;
+    set_token_program_account_idx(value: number): void;
+    get token_program_account_idx(): number;
+    set token_program_account_idx(value: number);
+    get_amount_in(): bigint;
+    set_amount_in(value: bigint): void;
+    get amount_in(): bigint;
+    set amount_in(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(pool_account_idx: number, user_transfer_authority_idx: number, user_input_account_idx: number, user_output_account_idx: number, vault_input_account_idx: number, vault_output_account_idx: number, lp_mint_account_idx: number, token_program_account_idx: number, amount_in: bigint): AmmSwapInstruction;
+    static from_array(buffer: Uint8Array): AmmSwapInstruction | null;
+}
+declare class AmmSwapInstructionBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_pool_account_idx(value: number): this;
+    set_user_transfer_authority_idx(value: number): this;
+    set_user_input_account_idx(value: number): this;
+    set_user_output_account_idx(value: number): this;
+    set_vault_input_account_idx(value: number): this;
+    set_vault_output_account_idx(value: number): this;
+    set_lp_mint_account_idx(value: number): this;
+    set_token_program_account_idx(value: number): this;
+    set_amount_in(value: bigint): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): AmmSwapInstruction;
+}
+declare class AmmWithdrawLiquidityInstruction {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): AmmWithdrawLiquidityInstruction;
+    static builder(): AmmWithdrawLiquidityInstructionBuilder;
+    static fromBuilder(builder: AmmWithdrawLiquidityInstructionBuilder): AmmWithdrawLiquidityInstruction | null;
+    get_pool_account_idx(): number;
+    set_pool_account_idx(value: number): void;
+    get pool_account_idx(): number;
+    set pool_account_idx(value: number);
+    get_withdrawer_account_idx(): number;
+    set_withdrawer_account_idx(value: number): void;
+    get withdrawer_account_idx(): number;
+    set withdrawer_account_idx(value: number);
+    get_withdrawer_token_one_account_idx(): number;
+    set_withdrawer_token_one_account_idx(value: number): void;
+    get withdrawer_token_one_account_idx(): number;
+    set withdrawer_token_one_account_idx(value: number);
+    get_withdrawer_token_two_account_idx(): number;
+    set_withdrawer_token_two_account_idx(value: number): void;
+    get withdrawer_token_two_account_idx(): number;
+    set withdrawer_token_two_account_idx(value: number);
+    get_withdrawer_lp_account_idx(): number;
+    set_withdrawer_lp_account_idx(value: number): void;
+    get withdrawer_lp_account_idx(): number;
+    set withdrawer_lp_account_idx(value: number);
+    get_vault_one_account_idx(): number;
+    set_vault_one_account_idx(value: number): void;
+    get vault_one_account_idx(): number;
+    set vault_one_account_idx(value: number);
+    get_vault_two_account_idx(): number;
+    set_vault_two_account_idx(value: number): void;
+    get vault_two_account_idx(): number;
+    set vault_two_account_idx(value: number);
+    get_lp_mint_account_idx(): number;
+    set_lp_mint_account_idx(value: number): void;
+    get lp_mint_account_idx(): number;
+    set lp_mint_account_idx(value: number);
+    get_token_program_account_idx(): number;
+    set_token_program_account_idx(value: number): void;
+    get token_program_account_idx(): number;
+    set token_program_account_idx(value: number);
+    get_lp_amount(): bigint;
+    set_lp_amount(value: bigint): void;
+    get lp_amount(): bigint;
+    set lp_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(pool_account_idx: number, withdrawer_account_idx: number, withdrawer_token_one_account_idx: number, withdrawer_token_two_account_idx: number, withdrawer_lp_account_idx: number, vault_one_account_idx: number, vault_two_account_idx: number, lp_mint_account_idx: number, token_program_account_idx: number, lp_amount: bigint): AmmWithdrawLiquidityInstruction;
+    static from_array(buffer: Uint8Array): AmmWithdrawLiquidityInstruction | null;
+}
+declare class AmmWithdrawLiquidityInstructionBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_pool_account_idx(value: number): this;
+    set_withdrawer_account_idx(value: number): this;
+    set_withdrawer_token_one_account_idx(value: number): this;
+    set_withdrawer_token_two_account_idx(value: number): this;
+    set_withdrawer_lp_account_idx(value: number): this;
+    set_vault_one_account_idx(value: number): this;
+    set_vault_two_account_idx(value: number): this;
+    set_lp_mint_account_idx(value: number): this;
+    set_token_program_account_idx(value: number): this;
+    set_lp_amount(value: bigint): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): AmmWithdrawLiquidityInstruction;
+}
+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 SwapEventData {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): SwapEventData;
+    static builder(): SwapEventDataBuilder;
+    static fromBuilder(builder: SwapEventDataBuilder): SwapEventData | null;
+    get_pool(): Pubkey;
+    set_pool(value: Pubkey): void;
+    get pool(): Pubkey;
+    set pool(value: Pubkey);
+    get_sender(): Pubkey;
+    set_sender(value: Pubkey): void;
+    get sender(): Pubkey;
+    set sender(value: Pubkey);
+    get_to(): Pubkey;
+    set_to(value: Pubkey): void;
+    get to(): Pubkey;
+    set to(value: Pubkey);
+    get_amount_in(): bigint;
+    set_amount_in(value: bigint): void;
+    get amount_in(): bigint;
+    set amount_in(value: bigint);
+    get_amount_out(): bigint;
+    set_amount_out(value: bigint): void;
+    get amount_out(): bigint;
+    set amount_out(value: bigint);
+    get_swap_direction(): number;
+    set_swap_direction(value: number): void;
+    get swap_direction(): number;
+    set swap_direction(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): SwapEventData | null;
+}
+declare class SwapEventDataBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_pool(value: Uint8Array): this;
+    set_sender(value: Uint8Array): this;
+    set_to(value: Uint8Array): this;
+    set_amount_in(value: bigint): this;
+    set_amount_out(value: bigint): this;
+    set_swap_direction(value: number): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): SwapEventData;
+}
+declare class SyncEventData {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): SyncEventData;
+    static builder(): SyncEventDataBuilder;
+    static fromBuilder(builder: SyncEventDataBuilder): SyncEventData | null;
+    get_pool(): Pubkey;
+    set_pool(value: Pubkey): void;
+    get pool(): Pubkey;
+    set pool(value: Pubkey);
+    get_reserve_one(): bigint;
+    set_reserve_one(value: bigint): void;
+    get reserve_one(): bigint;
+    set reserve_one(value: bigint);
+    get_reserve_two(): bigint;
+    set_reserve_two(value: bigint): void;
+    get reserve_two(): bigint;
+    set reserve_two(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 from_array(buffer: Uint8Array): SyncEventData | null;
+}
+declare class SyncEventDataBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_pool(value: Uint8Array): this;
+    set_reserve_one(value: bigint): this;
+    set_reserve_two(value: bigint): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): SyncEventData;
+}
+declare class AmmInitPoolInstruction {
+    private buffer;
+    private view;
+    private __tnFieldContext;
+    private __tnParams;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        params?: AmmInitPoolInstruction.Params;
+        fieldContext?: Record<string, number | bigint>;
+    }): AmmInitPoolInstruction;
+    dynamicParams(): AmmInitPoolInstruction.Params;
+    withFieldContext(context: Record<string, number | bigint>): this;
+    private __tnResolveFieldRef;
+    static builder(): AmmInitPoolInstructionBuilder;
+    static fromBuilder(builder: AmmInitPoolInstructionBuilder): AmmInitPoolInstruction | null;
+    static readonly flexibleArrayWriters: readonly [{
+        readonly field: "pool_proof";
+        readonly method: "pool_proof";
+        readonly sizeField: "pool_proof_size";
+        readonly paramKey: "pool_proof_size";
+        readonly elementSize: 1;
+    }, {
+        readonly field: "lp_mint_proof";
+        readonly method: "lp_mint_proof";
+        readonly sizeField: "lp_mint_proof_size";
+        readonly paramKey: "lp_mint_proof_size";
+        readonly elementSize: 1;
+    }, {
+        readonly field: "vault_one_proof";
+        readonly method: "vault_one_proof";
+        readonly sizeField: "vault_one_proof_size";
+        readonly paramKey: "vault_one_proof_size";
+        readonly elementSize: 1;
+    }, {
+        readonly field: "vault_two_proof";
+        readonly method: "vault_two_proof";
+        readonly sizeField: "vault_two_proof_size";
+        readonly paramKey: "vault_two_proof_size";
+        readonly elementSize: 1;
+    }];
+    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 __tnDynamicOffsetCache;
+    private __tnGetDynamicOffset;
+    private __tnComputeDynamicOffsets;
+    get_payer_account_idx(): number;
+    set_payer_account_idx(value: number): void;
+    get payer_account_idx(): number;
+    set payer_account_idx(value: number);
+    get_pool_account_idx(): number;
+    set_pool_account_idx(value: number): void;
+    get pool_account_idx(): number;
+    set pool_account_idx(value: number);
+    get_lp_mint_account_idx(): number;
+    set_lp_mint_account_idx(value: number): void;
+    get lp_mint_account_idx(): number;
+    set lp_mint_account_idx(value: number);
+    get_vault_one_account_idx(): number;
+    set_vault_one_account_idx(value: number): void;
+    get vault_one_account_idx(): number;
+    set vault_one_account_idx(value: number);
+    get_vault_two_account_idx(): number;
+    set_vault_two_account_idx(value: number): void;
+    get vault_two_account_idx(): number;
+    set vault_two_account_idx(value: number);
+    get_mint_one_account_idx(): number;
+    set_mint_one_account_idx(value: number): void;
+    get mint_one_account_idx(): number;
+    set mint_one_account_idx(value: number);
+    get_mint_two_account_idx(): number;
+    set_mint_two_account_idx(value: number): void;
+    get mint_two_account_idx(): number;
+    set mint_two_account_idx(value: number);
+    get_token_program_account_idx(): number;
+    set_token_program_account_idx(value: number): void;
+    get token_program_account_idx(): number;
+    set token_program_account_idx(value: number);
+    get_swap_fee_bps(): number;
+    set_swap_fee_bps(value: number): void;
+    get swap_fee_bps(): number;
+    set swap_fee_bps(value: number);
+    get_lp_mint_seed(): Seed32;
+    set_lp_mint_seed(value: Seed32): void;
+    get lp_mint_seed(): Seed32;
+    set lp_mint_seed(value: Seed32);
+    get_pool_proof_size(): bigint;
+    set_pool_proof_size(value: bigint): void;
+    get pool_proof_size(): bigint;
+    set pool_proof_size(value: bigint);
+    get_lp_mint_proof_size(): bigint;
+    set_lp_mint_proof_size(value: bigint): void;
+    get lp_mint_proof_size(): bigint;
+    set lp_mint_proof_size(value: bigint);
+    get_vault_one_proof_size(): bigint;
+    set_vault_one_proof_size(value: bigint): void;
+    get vault_one_proof_size(): bigint;
+    set vault_one_proof_size(value: bigint);
+    get_vault_two_proof_size(): bigint;
+    set_vault_two_proof_size(value: bigint): void;
+    get vault_two_proof_size(): bigint;
+    set vault_two_proof_size(value: bigint);
+    get_pool_proof_length(): number;
+    get_pool_proof_at(index: number): number;
+    get_pool_proof(): number[];
+    set_pool_proof_at(index: number, value: number): void;
+    set_pool_proof(value: number[]): void;
+    get pool_proof(): number[];
+    set pool_proof(value: number[]);
+    get_lp_mint_proof_length(): number;
+    get_lp_mint_proof_at(index: number): number;
+    get_lp_mint_proof(): number[];
+    set_lp_mint_proof_at(index: number, value: number): void;
+    set_lp_mint_proof(value: number[]): void;
+    get lp_mint_proof(): number[];
+    set lp_mint_proof(value: number[]);
+    get_vault_one_proof_length(): number;
+    get_vault_one_proof_at(index: number): number;
+    get_vault_one_proof(): number[];
+    set_vault_one_proof_at(index: number, value: number): void;
+    set_vault_one_proof(value: number[]): void;
+    get vault_one_proof(): number[];
+    set vault_one_proof(value: number[]);
+    get_vault_two_proof_length(): number;
+    get_vault_two_proof_at(index: number): number;
+    get_vault_two_proof(): number[];
+    set_vault_two_proof_at(index: number, value: number): void;
+    set_vault_two_proof(value: number[]): void;
+    get vault_two_proof(): number[];
+    set vault_two_proof(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(lp_mint_proof_lp_mint_proof_size: number | bigint, pool_proof_pool_proof_size: number | bigint, vault_one_proof_vault_one_proof_size: number | bigint, vault_two_proof_vault_two_proof_size: number | bigint): bigint;
+    private static __tnPackParams;
+    static footprintIrFromParams(params: AmmInitPoolInstruction.Params): bigint;
+    static footprintFromParams(params: AmmInitPoolInstruction.Params): number;
+    static footprintFromValues(input: {
+        lp_mint_proof_lp_mint_proof_size: number | bigint;
+        pool_proof_pool_proof_size: number | bigint;
+        vault_one_proof_vault_one_proof_size: number | bigint;
+        vault_two_proof_vault_two_proof_size: number | bigint;
+    }): number;
+    static footprint(params: AmmInitPoolInstruction.Params): number;
+    static validate(buffer: Uint8Array, opts?: {
+        params?: AmmInitPoolInstruction.Params;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+        params?: AmmInitPoolInstruction.Params;
+    };
+    static from_array(buffer: Uint8Array, opts?: {
+        params?: AmmInitPoolInstruction.Params;
+    }): AmmInitPoolInstruction | null;
+}
+declare namespace AmmInitPoolInstruction {
+    type Params = {
+        /** ABI path: lp_mint_proof.lp_mint_proof_size */
+        readonly lp_mint_proof_lp_mint_proof_size: bigint;
+        /** ABI path: pool_proof.pool_proof_size */
+        readonly pool_proof_pool_proof_size: bigint;
+        /** ABI path: vault_one_proof.vault_one_proof_size */
+        readonly vault_one_proof_vault_one_proof_size: bigint;
+        /** ABI path: vault_two_proof.vault_two_proof_size */
+        readonly vault_two_proof_vault_two_proof_size: bigint;
+    };
+    const ParamKeys: Readonly<{
+        readonly lp_mint_proof_lp_mint_proof_size: "lp_mint_proof.lp_mint_proof_size";
+        readonly pool_proof_pool_proof_size: "pool_proof.pool_proof_size";
+        readonly vault_one_proof_vault_one_proof_size: "vault_one_proof.vault_one_proof_size";
+        readonly vault_two_proof_vault_two_proof_size: "vault_two_proof.vault_two_proof_size";
+    }>;
+    const Params: {
+        fromValues(input: {
+            lp_mint_proof_lp_mint_proof_size: number | bigint;
+            pool_proof_pool_proof_size: number | bigint;
+            vault_one_proof_vault_one_proof_size: number | bigint;
+            vault_two_proof_vault_two_proof_size: number | bigint;
+        }): Params;
+        fromBuilder(source: {
+            dynamicParams(): Params;
+        } | {
+            params: Params;
+        } | Params): Params;
+    };
+    function params(input: {
+        lp_mint_proof_lp_mint_proof_size: number | bigint;
+        pool_proof_pool_proof_size: number | bigint;
+        vault_one_proof_vault_one_proof_size: number | bigint;
+        vault_two_proof_vault_two_proof_size: number | bigint;
+    }): Params;
+}
+declare class AmmInitPoolInstructionBuilder {
+    private buffer;
+    private view;
+    private __tnCachedParams;
+    private __tnLastBuffer;
+    private __tnLastParams;
+    private __tnFam_pool_proof;
+    private __tnFam_pool_proofCount;
+    private __tnFamWriter_pool_proof?;
+    private __tnFam_lp_mint_proof;
+    private __tnFam_lp_mint_proofCount;
+    private __tnFamWriter_lp_mint_proof?;
+    private __tnFam_vault_one_proof;
+    private __tnFam_vault_one_proofCount;
+    private __tnFamWriter_vault_one_proof?;
+    private __tnFam_vault_two_proof;
+    private __tnFam_vault_two_proofCount;
+    private __tnFamWriter_vault_two_proof?;
+    constructor();
+    private __tnInvalidate;
+    set_payer_account_idx(value: number): this;
+    set_pool_account_idx(value: number): this;
+    set_lp_mint_account_idx(value: number): this;
+    set_vault_one_account_idx(value: number): this;
+    set_vault_two_account_idx(value: number): this;
+    set_mint_one_account_idx(value: number): this;
+    set_mint_two_account_idx(value: number): this;
+    set_token_program_account_idx(value: number): this;
+    set_swap_fee_bps(value: number): this;
+    set_lp_mint_seed(value: Uint8Array): this;
+    set_pool_proof_size(value: bigint): this;
+    set_lp_mint_proof_size(value: bigint): this;
+    set_vault_one_proof_size(value: bigint): this;
+    set_vault_two_proof_size(value: bigint): this;
+    pool_proof(): __TnFamWriterResult<AmmInitPoolInstructionBuilder>;
+    lp_mint_proof(): __TnFamWriterResult<AmmInitPoolInstructionBuilder>;
+    vault_one_proof(): __TnFamWriterResult<AmmInitPoolInstructionBuilder>;
+    vault_two_proof(): __TnFamWriterResult<AmmInitPoolInstructionBuilder>;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): AmmInitPoolInstruction;
+    finishView(): AmmInitPoolInstruction;
+    dynamicParams(): AmmInitPoolInstruction.Params;
+    private __tnComputeParams;
+    private __tnWriteInto;
+    private __tnValidateOrThrow;
+}
+declare class AmmInstruction_payload_Inner {
+    private buffer;
+    private descriptor;
+    private view;
+    private __tnFieldContext;
+    private constructor();
+    static __tnCreate(payload: Uint8Array, descriptor: __TnVariantDescriptor | null, fieldContext?: Record<string, number | bigint>): AmmInstruction_payload_Inner;
+    bytes(): Uint8Array;
+    variant(): __TnVariantDescriptor | null;
+    asInitPool(): AmmInitPoolInstruction | null;
+    asAddLiquidity(): AmmAddLiquidityInstruction | null;
+    asWithdrawLiquidity(): AmmWithdrawLiquidityInstruction | null;
+    asSwap(): AmmSwapInstruction | null;
+}
+declare class AmmInstruction {
+    private buffer;
+    private view;
+    private static readonly __tnFieldOffset_payload;
+    private __tnParams;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        params?: AmmInstruction.Params;
+        fieldContext?: Record<string, number | bigint>;
+    }): AmmInstruction;
+    dynamicParams(): AmmInstruction.Params;
+    static builder(): AmmInstructionBuilder;
+    static fromBuilder(builder: AmmInstructionBuilder): AmmInstruction | null;
+    static readonly payloadVariantDescriptors: readonly [{
+        readonly name: "init_pool";
+        readonly tag: 0;
+        readonly payloadSize: null;
+        readonly payloadType: "AmmInstruction::payload::init_pool";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "add_liquidity";
+        readonly tag: 1;
+        readonly payloadSize: 34;
+        readonly payloadType: "AmmInstruction::payload::add_liquidity";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "withdraw_liquidity";
+        readonly tag: 2;
+        readonly payloadSize: 26;
+        readonly payloadType: "AmmInstruction::payload::withdraw_liquidity";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "swap";
+        readonly tag: 3;
+        readonly payloadSize: 24;
+        readonly payloadType: "AmmInstruction::payload::swap";
+        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_discriminant(): number;
+    set_discriminant(value: number): void;
+    get discriminant(): number;
+    set discriminant(value: number);
+    payloadVariant(): typeof AmmInstruction.payloadVariantDescriptors[number] | null;
+    payload(): AmmInstruction_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_discriminant: number | bigint, payload_payload_size: number | bigint): bigint;
+    private static __tnPackParams;
+    static footprintIrFromParams(params: AmmInstruction.Params): bigint;
+    static footprintFromParams(params: AmmInstruction.Params): number;
+    static footprintFromValues(input: {
+        payload_discriminant: number | bigint;
+        payload_payload_size: number | bigint;
+    }): number;
+    static footprint(params: AmmInstruction.Params): number;
+    static validate(buffer: Uint8Array, opts?: {
+        params?: AmmInstruction.Params;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+        params?: AmmInstruction.Params;
+    };
+    static from_array(buffer: Uint8Array, opts?: {
+        params?: AmmInstruction.Params;
+    }): AmmInstruction | null;
+}
+declare namespace AmmInstruction {
+    type Params = {
+        /** ABI path: payload.discriminant */
+        readonly payload_discriminant: bigint;
+        /** ABI path: payload.payload_size */
+        readonly payload_payload_size: bigint;
+    };
+    const ParamKeys: Readonly<{
+        readonly payload_discriminant: "payload.discriminant";
+        readonly payload_payload_size: "payload.payload_size";
+    }>;
+    const Params: {
+        fromValues(input: {
+            payload_discriminant: number | bigint;
+            payload_payload_size: number | bigint;
+        }): Params;
+        fromBuilder(source: {
+            dynamicParams(): Params;
+        } | {
+            params: Params;
+        } | Params): Params;
+    };
+    function params(input: {
+        payload_discriminant: number | bigint;
+        payload_payload_size: number | bigint;
+    }): Params;
+}
+declare class AmmInstructionBuilder {
+    private __tnPrefixBuffer;
+    private __tnPrefixView;
+    private __tnField_discriminant;
+    private __tnPayload_payload;
+    private __tnCachedParams;
+    private __tnLastBuffer;
+    private __tnLastParams;
+    private __tnVariantSelector_payload?;
+    constructor();
+    private __tnInvalidate;
+    private __tnAssign_discriminant;
+    set_discriminant(value: number): this;
+    payload(): __TnVariantSelectorResult<AmmInstructionBuilder>;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): AmmInstruction;
+    finishView(): AmmInstruction;
+    dynamicParams(): AmmInstruction.Params;
+    private __tnComputeParams;
+    private __tnWriteInto;
+    private __tnValidateOrThrow;
+}
+declare class AmmPoolMetadata$1 {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): AmmPoolMetadata$1;
+    static builder(): AmmPoolMetadataBuilder;
+    static fromBuilder(builder: AmmPoolMetadataBuilder): AmmPoolMetadata$1 | null;
+    get_is_initialized(): number;
+    set_is_initialized(value: number): void;
+    get is_initialized(): number;
+    set is_initialized(value: number);
+    get_locked_lp_supply(): bigint;
+    set_locked_lp_supply(value: bigint): void;
+    get locked_lp_supply(): bigint;
+    set locked_lp_supply(value: bigint);
+    get_swap_fee_bps(): number;
+    set_swap_fee_bps(value: number): void;
+    get swap_fee_bps(): number;
+    set swap_fee_bps(value: number);
+    get_swap_pool_authority(): Pubkey;
+    set_swap_pool_authority(value: Pubkey): void;
+    get swap_pool_authority(): Pubkey;
+    set swap_pool_authority(value: Pubkey);
+    get_mint_one(): Pubkey;
+    set_mint_one(value: Pubkey): void;
+    get mint_one(): Pubkey;
+    set mint_one(value: Pubkey);
+    get_mint_two(): Pubkey;
+    set_mint_two(value: Pubkey): void;
+    get mint_two(): Pubkey;
+    set mint_two(value: Pubkey);
+    get_vault_one(): Pubkey;
+    set_vault_one(value: Pubkey): void;
+    get vault_one(): Pubkey;
+    set vault_one(value: Pubkey);
+    get_vault_two(): Pubkey;
+    set_vault_two(value: Pubkey): void;
+    get vault_two(): Pubkey;
+    set vault_two(value: Pubkey);
+    get_lp_mint(): Pubkey;
+    set_lp_mint(value: Pubkey): void;
+    get lp_mint(): Pubkey;
+    set lp_mint(value: Pubkey);
+    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): AmmPoolMetadata$1 | null;
+}
+declare class AmmPoolMetadataBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_is_initialized(value: number): this;
+    set_locked_lp_supply(value: bigint): this;
+    set_swap_fee_bps(value: number): this;
+    set_swap_pool_authority(value: Uint8Array): this;
+    set_mint_one(value: Uint8Array): this;
+    set_mint_two(value: Uint8Array): this;
+    set_vault_one(value: Uint8Array): this;
+    set_vault_two(value: Uint8Array): this;
+    set_lp_mint(value: Uint8Array): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): AmmPoolMetadata$1;
+}
+declare class BurnEventData {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): BurnEventData;
+    static builder(): BurnEventDataBuilder;
+    static fromBuilder(builder: BurnEventDataBuilder): BurnEventData | null;
+    get_pool(): Pubkey;
+    set_pool(value: Pubkey): void;
+    get pool(): Pubkey;
+    set pool(value: Pubkey);
+    get_sender(): Pubkey;
+    set_sender(value: Pubkey): void;
+    get sender(): Pubkey;
+    set sender(value: Pubkey);
+    get_to(): Pubkey;
+    set_to(value: Pubkey): void;
+    get to(): Pubkey;
+    set to(value: Pubkey);
+    get_amount_one(): bigint;
+    set_amount_one(value: bigint): void;
+    get amount_one(): bigint;
+    set amount_one(value: bigint);
+    get_amount_two(): bigint;
+    set_amount_two(value: bigint): void;
+    get amount_two(): bigint;
+    set amount_two(value: bigint);
+    get_lp_burned(): bigint;
+    set_lp_burned(value: bigint): void;
+    get lp_burned(): bigint;
+    set lp_burned(value: bigint);
+    get_lp_total_supply(): bigint;
+    set_lp_total_supply(value: bigint): void;
+    get lp_total_supply(): bigint;
+    set lp_total_supply(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 from_array(buffer: Uint8Array): BurnEventData | null;
+}
+declare class BurnEventDataBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_pool(value: Uint8Array): this;
+    set_sender(value: Uint8Array): this;
+    set_to(value: Uint8Array): this;
+    set_amount_one(value: bigint): this;
+    set_amount_two(value: bigint): this;
+    set_lp_burned(value: bigint): this;
+    set_lp_total_supply(value: bigint): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): BurnEventData;
+}
+declare class MintEventData {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): MintEventData;
+    static builder(): MintEventDataBuilder;
+    static fromBuilder(builder: MintEventDataBuilder): MintEventData | null;
+    get_pool(): Pubkey;
+    set_pool(value: Pubkey): void;
+    get pool(): Pubkey;
+    set pool(value: Pubkey);
+    get_sender(): Pubkey;
+    set_sender(value: Pubkey): void;
+    get sender(): Pubkey;
+    set sender(value: Pubkey);
+    get_amount_one(): bigint;
+    set_amount_one(value: bigint): void;
+    get amount_one(): bigint;
+    set amount_one(value: bigint);
+    get_amount_two(): bigint;
+    set_amount_two(value: bigint): void;
+    get amount_two(): bigint;
+    set amount_two(value: bigint);
+    get_lp_minted(): bigint;
+    set_lp_minted(value: bigint): void;
+    get lp_minted(): bigint;
+    set lp_minted(value: bigint);
+    get_lp_total_supply(): bigint;
+    set_lp_total_supply(value: bigint): void;
+    get lp_total_supply(): bigint;
+    set lp_total_supply(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 from_array(buffer: Uint8Array): MintEventData | null;
+}
+declare class MintEventDataBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_pool(value: Uint8Array): this;
+    set_sender(value: Uint8Array): this;
+    set_amount_one(value: bigint): this;
+    set_amount_two(value: bigint): this;
+    set_lp_minted(value: bigint): this;
+    set_lp_total_supply(value: bigint): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): MintEventData;
+}
+declare class PoolInitEventData {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): PoolInitEventData;
+    static builder(): PoolInitEventDataBuilder;
+    static fromBuilder(builder: PoolInitEventDataBuilder): PoolInitEventData | null;
+    get_pool(): Pubkey;
+    set_pool(value: Pubkey): void;
+    get pool(): Pubkey;
+    set pool(value: Pubkey);
+    get_mint_one(): Pubkey;
+    set_mint_one(value: Pubkey): void;
+    get mint_one(): Pubkey;
+    set mint_one(value: Pubkey);
+    get_mint_two(): Pubkey;
+    set_mint_two(value: Pubkey): void;
+    get mint_two(): Pubkey;
+    set mint_two(value: Pubkey);
+    get_lp_mint(): Pubkey;
+    set_lp_mint(value: Pubkey): void;
+    get lp_mint(): Pubkey;
+    set lp_mint(value: Pubkey);
+    get_vault_one(): Pubkey;
+    set_vault_one(value: Pubkey): void;
+    get vault_one(): Pubkey;
+    set vault_one(value: Pubkey);
+    get_vault_two(): Pubkey;
+    set_vault_two(value: Pubkey): void;
+    get vault_two(): Pubkey;
+    set vault_two(value: Pubkey);
+    get_swap_fee_bps(): number;
+    set_swap_fee_bps(value: number): void;
+    get swap_fee_bps(): number;
+    set swap_fee_bps(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): PoolInitEventData | null;
+}
+declare class PoolInitEventDataBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_pool(value: Uint8Array): this;
+    set_mint_one(value: Uint8Array): this;
+    set_mint_two(value: Uint8Array): this;
+    set_lp_mint(value: Uint8Array): this;
+    set_vault_one(value: Uint8Array): this;
+    set_vault_two(value: Uint8Array): this;
+    set_swap_fee_bps(value: number): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): PoolInitEventData;
+}
+declare class AmmEvent_payload_Inner {
+    private buffer;
+    private descriptor;
+    private view;
+    private __tnFieldContext;
+    private constructor();
+    static __tnCreate(payload: Uint8Array, descriptor: __TnVariantDescriptor | null, fieldContext?: Record<string, number | bigint>): AmmEvent_payload_Inner;
+    bytes(): Uint8Array;
+    variant(): __TnVariantDescriptor | null;
+    asPoolInit(): PoolInitEventData | null;
+    asMint(): MintEventData | null;
+    asBurn(): BurnEventData | null;
+    asSwap(): SwapEventData | null;
+    asSync(): SyncEventData | null;
+}
+declare class AmmEvent {
+    private buffer;
+    private view;
+    private static readonly __tnFieldOffset_payload;
+    private __tnParams;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        params?: AmmEvent.Params;
+        fieldContext?: Record<string, number | bigint>;
+    }): AmmEvent;
+    dynamicParams(): AmmEvent.Params;
+    static builder(): AmmEventBuilder;
+    static fromBuilder(builder: AmmEventBuilder): AmmEvent | null;
+    static readonly payloadVariantDescriptors: readonly [{
+        readonly name: "pool_init";
+        readonly tag: 0;
+        readonly payloadSize: 194;
+        readonly payloadType: "AmmEvent::payload::pool_init";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "mint";
+        readonly tag: 1;
+        readonly payloadSize: 96;
+        readonly payloadType: "AmmEvent::payload::mint";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "burn";
+        readonly tag: 2;
+        readonly payloadSize: 128;
+        readonly payloadType: "AmmEvent::payload::burn";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "swap";
+        readonly tag: 3;
+        readonly payloadSize: 113;
+        readonly payloadType: "AmmEvent::payload::swap";
+        readonly createPayloadBuilder: () => unknown;
+    }, {
+        readonly name: "sync";
+        readonly tag: 4;
+        readonly payloadSize: 48;
+        readonly payloadType: "AmmEvent::payload::sync";
+        readonly createPayloadBuilder: () => unknown;
+    }];
+    private static __tnExtractParams;
+    get_event_type(): number;
+    set_event_type(value: number): void;
+    get event_type(): number;
+    set event_type(value: number);
+    payloadVariant(): typeof AmmEvent.payloadVariantDescriptors[number] | null;
+    payload(): AmmEvent_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_event_type: number | bigint): bigint;
+    private static __tnPackParams;
+    static footprintIrFromParams(params: AmmEvent.Params): bigint;
+    static footprintFromParams(params: AmmEvent.Params): number;
+    static footprintFromValues(input: {
+        payload_event_type: number | bigint;
+    }): number;
+    static footprint(params: AmmEvent.Params): number;
+    static validate(buffer: Uint8Array, opts?: {
+        params?: AmmEvent.Params;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+        params?: AmmEvent.Params;
+    };
+    static from_array(buffer: Uint8Array, opts?: {
+        params?: AmmEvent.Params;
+    }): AmmEvent | null;
+}
+declare namespace AmmEvent {
+    type Params = {
+        /** ABI path: payload.event_type */
+        readonly payload_event_type: bigint;
+    };
+    const ParamKeys: Readonly<{
+        readonly payload_event_type: "payload.event_type";
+    }>;
+    const Params: {
+        fromValues(input: {
+            payload_event_type: number | bigint;
+        }): Params;
+        fromBuilder(source: {
+            dynamicParams(): Params;
+        } | {
+            params: Params;
+        } | Params): Params;
+    };
+    function params(input: {
+        payload_event_type: number | bigint;
+    }): Params;
+}
+declare class AmmEventBuilder {
+    private __tnPrefixBuffer;
+    private __tnPrefixView;
+    private __tnField_event_type;
+    private __tnPayload_payload;
+    private __tnCachedParams;
+    private __tnLastBuffer;
+    private __tnLastParams;
+    private __tnVariantSelector_payload?;
+    constructor();
+    private __tnInvalidate;
+    private __tnAssign_event_type;
+    set_event_type(value: number): this;
+    payload(): __TnVariantSelectorResult<AmmEventBuilder>;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): AmmEvent;
+    finishView(): AmmEvent;
+    dynamicParams(): AmmEvent.Params;
+    private __tnComputeParams;
+    private __tnWriteInto;
+    private __tnValidateOrThrow;
+}
+
+declare const AMM_INSTRUCTION_INIT_POOL = 0;
+declare const AMM_INSTRUCTION_ADD_LIQUIDITY = 1;
+declare const AMM_INSTRUCTION_WITHDRAW_LIQUIDITY = 2;
+declare const AMM_INSTRUCTION_SWAP = 3;
+declare const AMM_EVENT_POOL_INIT = 0;
+declare const AMM_EVENT_MINT = 1;
+declare const AMM_EVENT_BURN = 2;
+declare const AMM_EVENT_SWAP = 3;
+declare const AMM_EVENT_SYNC = 4;
+declare const AMM_BPS_DENOMINATOR = 10000;
+declare const AMM_DEFAULT_SWAP_FEE_BPS = 30;
+declare const AMM_MAX_SWAP_FEE_BPS = 500;
+declare const AMM_MINIMUM_LIQUIDITY = 1000n;
+declare const AMM_LP_DECIMALS = 6;
+declare const AMM_LP_SCALE = 1000000n;
+declare const AMM_POOL_METADATA_SIZE = 203;
+declare const AMM_PROGRAM_ADDRESS = "taCnhMCcBZSJ8MDLGYBnTIRgmWxZx_jNjoNwOwzk1g4ST1";
+declare const AMM_ERROR_LABELS: Record<number, string>;
+declare const AMM_VAULT_ONE_SEED: Uint8Array<ArrayBufferLike>;
+declare const AMM_VAULT_TWO_SEED: Uint8Array<ArrayBufferLike>;
+type AccountLookupContext = {
+    getAccountIndex: (pubkey: Uint8Array) => number;
+};
+type InstructionData = (context: AccountLookupContext) => Promise<Uint8Array>;
+interface SortedAmmMints {
+    mintOneBytes: Uint8Array;
+    mintTwoBytes: Uint8Array;
+    mintOneAddress: string;
+    mintTwoAddress: string;
+    inputOrder: 'already-sorted' | 'swapped';
+}
+interface AmmPoolAddresses {
+    mintOneAddress: string;
+    mintTwoAddress: string;
+    mintOneBytes: Uint8Array;
+    mintTwoBytes: Uint8Array;
+    poolAddress: string;
+    poolBytes: Uint8Array;
+    poolSeed: Uint8Array;
+    lpMintSeed: Uint8Array;
+    vaultOneSeed: Uint8Array;
+    vaultTwoSeed: Uint8Array;
+    swapFeeBps: number;
+    inputOrder: 'already-sorted' | 'swapped';
+}
+interface AmmPoolMetadata {
+    isInitialized: boolean;
+    lockedLpSupply: bigint;
+    swapFeeBps: number;
+    swapPoolAuthority: string;
+    mintOne: string;
+    mintTwo: string;
+    vaultOne: string;
+    vaultTwo: string;
+    lpMint: string;
+}
+interface AmmQuoteExactIn {
+    amountIn: bigint;
+    amountInAfterFee: bigint;
+    feeAmount: bigint;
+    amountOut: bigint;
+}
+interface InitPoolArgs {
+    payerAccountBytes: Uint8Array;
+    poolAccountBytes: Uint8Array;
+    lpMintAccountBytes: Uint8Array;
+    vaultOneAccountBytes: Uint8Array;
+    vaultTwoAccountBytes: Uint8Array;
+    mintOneAccountBytes: Uint8Array;
+    mintTwoAccountBytes: Uint8Array;
+    tokenProgramAccountBytes: Uint8Array;
+    swapFeeBps: number;
+    lpMintSeed: Uint8Array;
+    poolStateProof: Uint8Array;
+    lpMintStateProof: Uint8Array;
+    vaultOneStateProof: Uint8Array;
+    vaultTwoStateProof: Uint8Array;
+}
+interface AddLiquidityArgs {
+    poolAccountBytes: Uint8Array;
+    depositorAccountBytes: Uint8Array;
+    depositorTokenOneAccountBytes: Uint8Array;
+    depositorTokenTwoAccountBytes: Uint8Array;
+    depositorLpAccountBytes: Uint8Array;
+    vaultOneAccountBytes: Uint8Array;
+    vaultTwoAccountBytes: Uint8Array;
+    lpMintAccountBytes: Uint8Array;
+    tokenProgramAccountBytes: Uint8Array;
+    maxAmountMintOne: bigint;
+    maxAmountMintTwo: bigint;
+}
+interface WithdrawLiquidityArgs {
+    poolAccountBytes: Uint8Array;
+    withdrawerAccountBytes: Uint8Array;
+    withdrawerTokenOneAccountBytes: Uint8Array;
+    withdrawerTokenTwoAccountBytes: Uint8Array;
+    withdrawerLpAccountBytes: Uint8Array;
+    vaultOneAccountBytes: Uint8Array;
+    vaultTwoAccountBytes: Uint8Array;
+    lpMintAccountBytes: Uint8Array;
+    tokenProgramAccountBytes: Uint8Array;
+    lpAmount: bigint;
+}
+interface SwapArgs {
+    poolAccountBytes: Uint8Array;
+    userTransferAuthorityBytes: Uint8Array;
+    userInputAccountBytes: Uint8Array;
+    userOutputAccountBytes: Uint8Array;
+    vaultInputAccountBytes: Uint8Array;
+    vaultOutputAccountBytes: Uint8Array;
+    lpMintAccountBytes: Uint8Array;
+    tokenProgramAccountBytes: Uint8Array;
+    amountIn: bigint;
+}
+declare function sortAmmMints(mintA: Uint8Array | string, mintB: Uint8Array | string): SortedAmmMints;
+declare function deriveAmmLpMintSeed(thru: Thru, poolBytes: Uint8Array | string): Uint8Array;
+declare function deriveAmmPoolAddresses(thru: Thru, args: {
+    ammProgramAddress: string;
+    mintAAddress: string;
+    mintBAddress: string;
+    swapFeeBps?: number;
+}): AmmPoolAddresses;
+declare function createInitPoolInstruction(args: InitPoolArgs): InstructionData;
+declare function createAddLiquidityInstruction(args: AddLiquidityArgs): InstructionData;
+declare function createWithdrawLiquidityInstruction(args: WithdrawLiquidityArgs): InstructionData;
+declare function createSwapInstruction(args: SwapArgs): InstructionData;
+declare function parseAmmPoolMetadata(accountOrData: Account | Uint8Array): AmmPoolMetadata;
+declare function quoteAmmSwapExactIn(args: {
+    amountIn: bigint;
+    reserveIn: bigint;
+    reserveOut: bigint;
+    swapFeeBps: number;
+}): AmmQuoteExactIn;
+
+export { AMM_BPS_DENOMINATOR, AMM_DEFAULT_SWAP_FEE_BPS, AMM_ERROR_LABELS, AMM_EVENT_BURN, AMM_EVENT_MINT, AMM_EVENT_POOL_INIT, AMM_EVENT_SWAP, AMM_EVENT_SYNC, AMM_INSTRUCTION_ADD_LIQUIDITY, AMM_INSTRUCTION_INIT_POOL, AMM_INSTRUCTION_SWAP, AMM_INSTRUCTION_WITHDRAW_LIQUIDITY, AMM_LP_DECIMALS, AMM_LP_SCALE, AMM_MAX_SWAP_FEE_BPS, AMM_MINIMUM_LIQUIDITY, AMM_POOL_METADATA_SIZE, AMM_PROGRAM_ADDRESS, AMM_VAULT_ONE_SEED, AMM_VAULT_TWO_SEED, type AccountLookupContext, type AddLiquidityArgs, AmmAddLiquidityInstruction, AmmAddLiquidityInstructionBuilder, AmmError, AmmErrorBuilder, AmmEvent, AmmEventBuilder, AmmInitPoolInstruction, AmmInitPoolInstructionBuilder, AmmInstruction, AmmInstructionBuilder, type AmmPoolAddresses, type AmmPoolMetadata, AmmPoolMetadataBuilder, AmmPoolMetadata$1 as AmmPoolMetadataView, type AmmQuoteExactIn, AmmSwapInstruction, AmmSwapInstructionBuilder, AmmWithdrawLiquidityInstruction, AmmWithdrawLiquidityInstructionBuilder, BurnEventData, BurnEventDataBuilder, type InitPoolArgs, type InstructionData, MintEventData, MintEventDataBuilder, PoolInitEventData, PoolInitEventDataBuilder, Seed32, type SortedAmmMints, type SwapArgs, SwapEventData, SwapEventDataBuilder, SyncEventData, SyncEventDataBuilder, type WithdrawLiquidityArgs, createAddLiquidityInstruction, createInitPoolInstruction, createSwapInstruction, createWithdrawLiquidityInstruction, deriveAmmLpMintSeed, deriveAmmPoolAddresses, parseAmmPoolMetadata, quoteAmmSwapExactIn, sortAmmMints };