@thru/programs 0.2.22 → 0.2.24

package/dist/multicall/index.d.cts

@@ -0,0 +1,253 @@
+type __TnValidateResult$1 = {
+    ok: boolean;
+    code?: string;
+    consumed?: bigint;
+};
+type __TnBuilderLike = {
+    build(): Uint8Array;
+};
+type __TnFamWriterResult<Parent> = {
+    write(payload: Uint8Array | __TnBuilderLike): {
+        finish(): Parent;
+    };
+    finish(): Parent;
+};
+declare class InstructionData {
+    private buffer;
+    private view;
+    private __tnFieldContext;
+    private __tnParams;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        params?: InstructionData.Params;
+        fieldContext?: Record<string, number | bigint>;
+    }): InstructionData;
+    dynamicParams(): InstructionData.Params;
+    withFieldContext(context: Record<string, number | bigint>): this;
+    private __tnResolveFieldRef;
+    static builder(): InstructionDataBuilder;
+    static fromBuilder(builder: InstructionDataBuilder): InstructionData | null;
+    static readonly flexibleArrayWriters: readonly [{
+        readonly field: "data";
+        readonly method: "data";
+        readonly sizeField: "data_size";
+        readonly paramKey: "data_size";
+        readonly elementSize: 1;
+    }];
+    private static __tnExtractParams;
+    get_program_idx(): number;
+    set_program_idx(value: number): void;
+    get program_idx(): number;
+    set program_idx(value: number);
+    get_data_size(): bigint;
+    set_data_size(value: bigint): void;
+    get data_size(): bigint;
+    set data_size(value: bigint);
+    get_data_length(): number;
+    get_data_at(index: number): number;
+    get_data(): number[];
+    set_data_at(index: number, value: number): void;
+    set_data(value: number[]): void;
+    get data(): number[];
+    set data(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(data_data_size: number | bigint): bigint;
+    private static __tnPackParams;
+    static footprintIrFromParams(params: InstructionData.Params): bigint;
+    static footprintFromParams(params: InstructionData.Params): number;
+    static footprintFromValues(input: {
+        data_data_size: number | bigint;
+    }): number;
+    static footprint(params: InstructionData.Params): number;
+    static validate(buffer: Uint8Array, opts?: {
+        params?: InstructionData.Params;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+        params?: InstructionData.Params;
+    };
+    static from_array(buffer: Uint8Array, opts?: {
+        params?: InstructionData.Params;
+    }): InstructionData | null;
+}
+declare namespace InstructionData {
+    type Params = {
+        /** ABI path: data.data_size */
+        readonly data_data_size: bigint;
+    };
+    const ParamKeys: Readonly<{
+        readonly data_data_size: "data.data_size";
+    }>;
+    const Params: {
+        fromValues(input: {
+            data_data_size: number | bigint;
+        }): Params;
+        fromBuilder(source: {
+            dynamicParams(): Params;
+        } | {
+            params: Params;
+        } | Params): Params;
+    };
+    function params(input: {
+        data_data_size: number | bigint;
+    }): Params;
+}
+declare class InstructionDataBuilder {
+    private buffer;
+    private view;
+    private __tnCachedParams;
+    private __tnLastBuffer;
+    private __tnLastParams;
+    private __tnFam_data;
+    private __tnFam_dataCount;
+    private __tnFamWriter_data?;
+    constructor();
+    private __tnInvalidate;
+    set_program_idx(value: number): this;
+    set_data_size(value: number): this;
+    data(): __TnFamWriterResult<InstructionDataBuilder>;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): InstructionData;
+    finishView(): InstructionData;
+    dynamicParams(): InstructionData.Params;
+    private __tnComputeParams;
+    private __tnWriteInto;
+    private __tnValidateOrThrow;
+}
+
+type __TnValidateResult = {
+    ok: boolean;
+    code?: string;
+    consumed?: bigint;
+};
+declare class MulticallArgs {
+    private buffer;
+    private view;
+    private __tnFieldContext;
+    private __tnParams;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        params?: MulticallArgs.Params;
+        fieldContext?: Record<string, number | bigint>;
+    }): MulticallArgs;
+    dynamicParams(): MulticallArgs.Params;
+    withFieldContext(context: Record<string, number | bigint>): this;
+    private __tnResolveFieldRef;
+    private static __tnExtractParams;
+    get_calls_count(): number;
+    set_calls_count(value: number): void;
+    get calls_count(): number;
+    set calls_count(value: number);
+    /** Returns the number of elements in the jagged array. */
+    get_calls_length(): number;
+    /** Returns the element at the given index, or null if out of bounds.
+     * Note: This is O(n) as jagged arrays require sequential traversal. */
+    get_calls_at(index: number): InstructionData | null;
+    /** Returns a generator over the jagged array elements.
+     * This is more efficient than repeated calls to `get_calls_at()` for sequential access. */
+    callsIter(): Generator<InstructionData, void, unknown>;
+    get_calls(): InstructionData[];
+    set_calls(_value: InstructionData[]): void;
+    /** Returns the total byte size of all elements in the jagged array. */
+    get_calls_size(): number;
+    get calls(): InstructionData[];
+    set calls(value: InstructionData[]);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(calls_calls_count: number | bigint): bigint;
+    private static __tnPackParams;
+    static footprintIrFromParams(params: MulticallArgs.Params): bigint;
+    static footprintFromParams(params: MulticallArgs.Params): number;
+    static footprintFromValues(input: {
+        calls_calls_count: number | bigint;
+    }): number;
+    static footprint(params: MulticallArgs.Params): number;
+    static validate(buffer: Uint8Array, opts?: {
+        params?: MulticallArgs.Params;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+        params?: MulticallArgs.Params;
+    };
+    static from_array(buffer: Uint8Array, opts?: {
+        params?: MulticallArgs.Params;
+    }): MulticallArgs | null;
+}
+declare namespace MulticallArgs {
+    type Params = {
+        /** ABI path: calls.calls_count */
+        readonly calls_calls_count: bigint;
+    };
+    const ParamKeys: Readonly<{
+        readonly calls_calls_count: "calls.calls_count";
+    }>;
+    const Params: {
+        fromValues(input: {
+            calls_calls_count: number | bigint;
+        }): Params;
+        fromBuilder(source: {
+            dynamicParams(): Params;
+        } | {
+            params: Params;
+        } | Params): Params;
+    };
+    function params(input: {
+        calls_calls_count: number | bigint;
+    }): Params;
+}
+declare class MulticallError {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): MulticallError;
+    static builder(): MulticallErrorBuilder;
+    static fromBuilder(builder: MulticallErrorBuilder): MulticallError | 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): MulticallError;
+    static from_array(buffer: Uint8Array): MulticallError | null;
+}
+declare class MulticallErrorBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_code(value: number): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): MulticallError;
+}
+
+type MulticallCall = {
+    programIdx: number;
+    instructionData: Uint8Array;
+};
+declare const MULTICALL_PROGRAM_PUBKEY: Uint8Array<ArrayBuffer>;
+declare const MULTICALL_PROGRAM_ADDRESS: string;
+declare function buildMulticallInstruction(calls: MulticallCall[]): Uint8Array;
+
+export { InstructionData, InstructionDataBuilder, MULTICALL_PROGRAM_ADDRESS, MULTICALL_PROGRAM_PUBKEY, MulticallArgs, type MulticallCall, MulticallError, buildMulticallInstruction };

package/dist/multicall/index.d.ts

@@ -0,0 +1,253 @@
+type __TnValidateResult$1 = {
+    ok: boolean;
+    code?: string;
+    consumed?: bigint;
+};
+type __TnBuilderLike = {
+    build(): Uint8Array;
+};
+type __TnFamWriterResult<Parent> = {
+    write(payload: Uint8Array | __TnBuilderLike): {
+        finish(): Parent;
+    };
+    finish(): Parent;
+};
+declare class InstructionData {
+    private buffer;
+    private view;
+    private __tnFieldContext;
+    private __tnParams;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        params?: InstructionData.Params;
+        fieldContext?: Record<string, number | bigint>;
+    }): InstructionData;
+    dynamicParams(): InstructionData.Params;
+    withFieldContext(context: Record<string, number | bigint>): this;
+    private __tnResolveFieldRef;
+    static builder(): InstructionDataBuilder;
+    static fromBuilder(builder: InstructionDataBuilder): InstructionData | null;
+    static readonly flexibleArrayWriters: readonly [{
+        readonly field: "data";
+        readonly method: "data";
+        readonly sizeField: "data_size";
+        readonly paramKey: "data_size";
+        readonly elementSize: 1;
+    }];
+    private static __tnExtractParams;
+    get_program_idx(): number;
+    set_program_idx(value: number): void;
+    get program_idx(): number;
+    set program_idx(value: number);
+    get_data_size(): bigint;
+    set_data_size(value: bigint): void;
+    get data_size(): bigint;
+    set data_size(value: bigint);
+    get_data_length(): number;
+    get_data_at(index: number): number;
+    get_data(): number[];
+    set_data_at(index: number, value: number): void;
+    set_data(value: number[]): void;
+    get data(): number[];
+    set data(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(data_data_size: number | bigint): bigint;
+    private static __tnPackParams;
+    static footprintIrFromParams(params: InstructionData.Params): bigint;
+    static footprintFromParams(params: InstructionData.Params): number;
+    static footprintFromValues(input: {
+        data_data_size: number | bigint;
+    }): number;
+    static footprint(params: InstructionData.Params): number;
+    static validate(buffer: Uint8Array, opts?: {
+        params?: InstructionData.Params;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+        params?: InstructionData.Params;
+    };
+    static from_array(buffer: Uint8Array, opts?: {
+        params?: InstructionData.Params;
+    }): InstructionData | null;
+}
+declare namespace InstructionData {
+    type Params = {
+        /** ABI path: data.data_size */
+        readonly data_data_size: bigint;
+    };
+    const ParamKeys: Readonly<{
+        readonly data_data_size: "data.data_size";
+    }>;
+    const Params: {
+        fromValues(input: {
+            data_data_size: number | bigint;
+        }): Params;
+        fromBuilder(source: {
+            dynamicParams(): Params;
+        } | {
+            params: Params;
+        } | Params): Params;
+    };
+    function params(input: {
+        data_data_size: number | bigint;
+    }): Params;
+}
+declare class InstructionDataBuilder {
+    private buffer;
+    private view;
+    private __tnCachedParams;
+    private __tnLastBuffer;
+    private __tnLastParams;
+    private __tnFam_data;
+    private __tnFam_dataCount;
+    private __tnFamWriter_data?;
+    constructor();
+    private __tnInvalidate;
+    set_program_idx(value: number): this;
+    set_data_size(value: number): this;
+    data(): __TnFamWriterResult<InstructionDataBuilder>;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): InstructionData;
+    finishView(): InstructionData;
+    dynamicParams(): InstructionData.Params;
+    private __tnComputeParams;
+    private __tnWriteInto;
+    private __tnValidateOrThrow;
+}
+
+type __TnValidateResult = {
+    ok: boolean;
+    code?: string;
+    consumed?: bigint;
+};
+declare class MulticallArgs {
+    private buffer;
+    private view;
+    private __tnFieldContext;
+    private __tnParams;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        params?: MulticallArgs.Params;
+        fieldContext?: Record<string, number | bigint>;
+    }): MulticallArgs;
+    dynamicParams(): MulticallArgs.Params;
+    withFieldContext(context: Record<string, number | bigint>): this;
+    private __tnResolveFieldRef;
+    private static __tnExtractParams;
+    get_calls_count(): number;
+    set_calls_count(value: number): void;
+    get calls_count(): number;
+    set calls_count(value: number);
+    /** Returns the number of elements in the jagged array. */
+    get_calls_length(): number;
+    /** Returns the element at the given index, or null if out of bounds.
+     * Note: This is O(n) as jagged arrays require sequential traversal. */
+    get_calls_at(index: number): InstructionData | null;
+    /** Returns a generator over the jagged array elements.
+     * This is more efficient than repeated calls to `get_calls_at()` for sequential access. */
+    callsIter(): Generator<InstructionData, void, unknown>;
+    get_calls(): InstructionData[];
+    set_calls(_value: InstructionData[]): void;
+    /** Returns the total byte size of all elements in the jagged array. */
+    get_calls_size(): number;
+    get calls(): InstructionData[];
+    set calls(value: InstructionData[]);
+    private static __tnFootprintInternal;
+    private static __tnValidateInternal;
+    static __tnInvokeFootprint(__tnParams: Record<string, bigint>): bigint;
+    static __tnInvokeValidate(buffer: Uint8Array, __tnParams: Record<string, bigint>): __TnValidateResult;
+    static footprintIr(calls_calls_count: number | bigint): bigint;
+    private static __tnPackParams;
+    static footprintIrFromParams(params: MulticallArgs.Params): bigint;
+    static footprintFromParams(params: MulticallArgs.Params): number;
+    static footprintFromValues(input: {
+        calls_calls_count: number | bigint;
+    }): number;
+    static footprint(params: MulticallArgs.Params): number;
+    static validate(buffer: Uint8Array, opts?: {
+        params?: MulticallArgs.Params;
+    }): {
+        ok: boolean;
+        code?: string;
+        consumed?: number;
+        params?: MulticallArgs.Params;
+    };
+    static from_array(buffer: Uint8Array, opts?: {
+        params?: MulticallArgs.Params;
+    }): MulticallArgs | null;
+}
+declare namespace MulticallArgs {
+    type Params = {
+        /** ABI path: calls.calls_count */
+        readonly calls_calls_count: bigint;
+    };
+    const ParamKeys: Readonly<{
+        readonly calls_calls_count: "calls.calls_count";
+    }>;
+    const Params: {
+        fromValues(input: {
+            calls_calls_count: number | bigint;
+        }): Params;
+        fromBuilder(source: {
+            dynamicParams(): Params;
+        } | {
+            params: Params;
+        } | Params): Params;
+    };
+    function params(input: {
+        calls_calls_count: number | bigint;
+    }): Params;
+}
+declare class MulticallError {
+    private buffer;
+    private view;
+    private constructor();
+    static __tnCreateView(buffer: Uint8Array, opts?: {
+        fieldContext?: Record<string, number | bigint>;
+    }): MulticallError;
+    static builder(): MulticallErrorBuilder;
+    static fromBuilder(builder: MulticallErrorBuilder): MulticallError | 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): MulticallError;
+    static from_array(buffer: Uint8Array): MulticallError | null;
+}
+declare class MulticallErrorBuilder {
+    private buffer;
+    private view;
+    constructor();
+    set_code(value: number): this;
+    build(): Uint8Array;
+    buildInto(target: Uint8Array, offset?: number): Uint8Array;
+    finish(): MulticallError;
+}
+
+type MulticallCall = {
+    programIdx: number;
+    instructionData: Uint8Array;
+};
+declare const MULTICALL_PROGRAM_PUBKEY: Uint8Array<ArrayBuffer>;
+declare const MULTICALL_PROGRAM_ADDRESS: string;
+declare function buildMulticallInstruction(calls: MulticallCall[]): Uint8Array;
+
+export { InstructionData, InstructionDataBuilder, MULTICALL_PROGRAM_ADDRESS, MULTICALL_PROGRAM_PUBKEY, MulticallArgs, type MulticallCall, MulticallError, buildMulticallInstruction };