wowok/dist/esm/transactions/Transaction.d.ts

Wowok Blockchain TypeScript API

import type { SerializedBcs } from "../_deps/bcs/index.js";
import type { InferInput } from "valibot";
import type { SignatureWithBytes, Signer } from "../cryptography/index.js";
import type { TransactionArgument } from "./Commands.js";
import type { CallArg, Command, Argument, ObjectRef } from "./data/internal.js";
import { ArgumentSchema, TransactionExpiration } from "./data/internal.js";
import { Inputs } from "./Inputs.js";
import type { BuildTransactionOptions, SerializeTransactionOptions, TransactionPlugin } from "./resolve.js";
import { createObjectMethods } from "./object.js";
import { createPure } from "./pure.js";
import type { ClientWithCoreApi } from "../experimental/core.js";
export type TransactionObjectArgument = Exclude<InferInput<typeof ArgumentSchema>, {
    Input: unknown;
    type?: "pure";
}> | ((tx: Transaction) => Exclude<InferInput<typeof ArgumentSchema>, {
    Input: unknown;
    type?: "pure";
}>) | AsyncTransactionThunk<TransactionResultArgument>;
export type TransactionResult = Extract<Argument, {
    Result: unknown;
}> & Extract<Argument, {
    NestedResult: unknown;
}>[];
export type TransactionResultArgument = Extract<Argument, {
    Result: unknown;
}> | readonly Extract<Argument, {
    NestedResult: unknown;
}>[];
export type AsyncTransactionThunk<T extends TransactionResultArgument | void = TransactionResultArgument | void> = (tx: Transaction) => Promise<T | void>;
declare const TRANSACTION_BRAND: never;
interface SignOptions extends BuildTransactionOptions {
    signer: Signer;
}
export declare function isTransaction(obj: unknown): obj is TransactionLike;
export type TransactionObjectInput = string | CallArg | TransactionObjectArgument;
type TransactionLike = {
    getData(): unknown;
};
export declare class Transaction {
    #private;
    [TRANSACTION_BRAND]: boolean;
    static fromKind(serialized: string | Uint8Array): Transaction;
    static from(transaction: string | Uint8Array | TransactionLike): Transaction;
    static registerGlobalSerializationPlugin(step: TransactionPlugin): void;
    static registerGlobalSerializationPlugin(name: string, step: TransactionPlugin): void;
    static unregisterGlobalSerializationPlugin(name: string): void;
    static registerGlobalBuildPlugin(step: TransactionPlugin): void;
    static registerGlobalBuildPlugin(name: string, step: TransactionPlugin): void;
    static unregisterGlobalBuildPlugin(name: string): void;
    addSerializationPlugin(step: TransactionPlugin): void;
    addBuildPlugin(step: TransactionPlugin): void;
    addIntentResolver(intent: string, resolver: TransactionPlugin): void;
    setSender(sender: string): void;
    setSenderIfNotSet(sender: string): void;
    setExpiration(expiration?: InferInput<typeof TransactionExpiration> | null): void;
    setGasPrice(price: number | bigint): void;
    setGasBudget(budget: number | bigint): void;
    setGasBudgetIfNotSet(budget: number | bigint): void;
    setGasOwner(owner: string): void;
    setGasPayment(payments: ObjectRef[]): void;
    get blockData(): {
        version: 1;
        sender?: string;
        expiration?: {
            Epoch: number;
        } | {
            None: true;
        };
        gasConfig: {
            budget?: string | number | bigint;
            price?: string | number | bigint;
            payment?: {
                digest: string;
                objectId: string;
                version: string | number | bigint;
            }[];
            owner?: string;
        };
        inputs: ({
            kind: "Input";
            index: number;
            value: unknown;
            type?: "object";
        } | {
            kind: "Input";
            index: number;
            value: unknown;
            type: "pure";
        })[];
        transactions: ({
            kind: "MoveCall";
            target: `${string}::${string}::${string}`;
            typeArguments: string[];
            arguments: ({
                kind: "Input";
                index: number;
                value: unknown;
                type?: "object";
            } | {
                kind: "Input";
                index: number;
                value: unknown;
                type: "pure";
            } | {
                kind: "GasCoin";
            } | {
                kind: "Result";
                index: number;
            } | {
                kind: "NestedResult";
                index: number;
                resultIndex: number;
            })[];
        } | {
            kind: "TransferObjects";
            objects: ({
                kind: "Input";
                index: number;
                value: unknown;
                type?: "object";
            } | {
                kind: "Input";
                index: number;
                value: unknown;
                type: "pure";
            } | {
                kind: "GasCoin";
            } | {
                kind: "Result";
                index: number;
            } | {
                kind: "NestedResult";
                index: number;
                resultIndex: number;
            })[];
            address: {
                kind: "Input";
                index: number;
                value: unknown;
                type?: "object";
            } | {
                kind: "Input";
                index: number;
                value: unknown;
                type: "pure";
            } | {
                kind: "GasCoin";
            } | {
                kind: "Result";
                index: number;
            } | {
                kind: "NestedResult";
                index: number;
                resultIndex: number;
            };
        } | {
            kind: "SplitCoins";
            coin: {
                kind: "Input";
                index: number;
                value: unknown;
                type?: "object";
            } | {
                kind: "Input";
                index: number;
                value: unknown;
                type: "pure";
            } | {
                kind: "GasCoin";
            } | {
                kind: "Result";
                index: number;
            } | {
                kind: "NestedResult";
                index: number;
                resultIndex: number;
            };
            amounts: ({
                kind: "Input";
                index: number;
                value: unknown;
                type?: "object";
            } | {
                kind: "Input";
                index: number;
                value: unknown;
                type: "pure";
            } | {
                kind: "GasCoin";
            } | {
                kind: "Result";
                index: number;
            } | {
                kind: "NestedResult";
                index: number;
                resultIndex: number;
            })[];
        } | {
            kind: "MergeCoins";
            destination: {
                kind: "Input";
                index: number;
                value: unknown;
                type?: "object";
            } | {
                kind: "Input";
                index: number;
                value: unknown;
                type: "pure";
            } | {
                kind: "GasCoin";
            } | {
                kind: "Result";
                index: number;
            } | {
                kind: "NestedResult";
                index: number;
                resultIndex: number;
            };
            sources: ({
                kind: "Input";
                index: number;
                value: unknown;
                type?: "object";
            } | {
                kind: "Input";
                index: number;
                value: unknown;
                type: "pure";
            } | {
                kind: "GasCoin";
            } | {
                kind: "Result";
                index: number;
            } | {
                kind: "NestedResult";
                index: number;
                resultIndex: number;
            })[];
        } | {
            kind: "MakeMoveVec";
            type: {
                Some: import("../index.js").TypeTag;
            } | {
                None: true;
            };
            objects: ({
                kind: "Input";
                index: number;
                value: unknown;
                type?: "object";
            } | {
                kind: "Input";
                index: number;
                value: unknown;
                type: "pure";
            } | {
                kind: "GasCoin";
            } | {
                kind: "Result";
                index: number;
            } | {
                kind: "NestedResult";
                index: number;
                resultIndex: number;
            })[];
        } | {
            kind: "Publish";
            modules: number[][];
            dependencies: string[];
        } | {
            kind: "Upgrade";
            modules: number[][];
            dependencies: string[];
            packageId: string;
            ticket: {
                kind: "Input";
                index: number;
                value: unknown;
                type?: "object";
            } | {
                kind: "Input";
                index: number;
                value: unknown;
                type: "pure";
            } | {
                kind: "GasCoin";
            } | {
                kind: "Result";
                index: number;
            } | {
                kind: "NestedResult";
                index: number;
                resultIndex: number;
            };
        })[];
    };
    getData(): {
        version: 2;
        sender?: string;
        expiration?: import("../_deps/bcs/types.js").EnumOutputShapeWithKeys<{
            None: true;
            Epoch: string | number;
        }, "None" | "Epoch">;
        gasData: {
            budget: string | number;
            price: string | number;
            owner: string;
            payment: {
                objectId: string;
                version: string | number;
                digest: string;
            }[];
        };
        inputs: import("../_deps/bcs/types.js").EnumOutputShapeWithKeys<{
            Object: import("../_deps/bcs/types.js").EnumOutputShapeWithKeys<{
                ImmOrOwnedObject: {
                    objectId: string;
                    version: string | number;
                    digest: string;
                };
                SharedObject: {
                    objectId: string;
                    initialSharedVersion: string | number;
                    mutable: boolean;
                };
                Receiving: {
                    objectId: string;
                    version: string | number;
                    digest: string;
                };
            }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
            Pure: {
                bytes: string;
            };
            UnresolvedPure: {
                value: unknown;
            };
            UnresolvedObject: {
                objectId: string;
                version?: string | number;
                digest?: string;
                initialSharedVersion?: string | number;
                mutable?: boolean;
            };
        }, "Object" | "Pure" | "UnresolvedPure" | "UnresolvedObject">[];
        commands: import("../_deps/bcs/types.js").EnumOutputShapeWithKeys<{
            MoveCall: {
                package: string;
                module: string;
                function: string;
                typeArguments: string[];
                arguments: ({
                    $kind: "GasCoin";
                    GasCoin: true;
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "pure";
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "object";
                } | {
                    $kind: "Result";
                    Result: number;
                } | {
                    $kind: "NestedResult";
                    NestedResult: [number, number];
                })[];
                _argumentTypes?: {
                    ref: "&" | "&mut";
                    body: import("./index.js").OpenMoveTypeSignatureBody;
                }[];
            };
            TransferObjects: {
                objects: ({
                    $kind: "GasCoin";
                    GasCoin: true;
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "pure";
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "object";
                } | {
                    $kind: "Result";
                    Result: number;
                } | {
                    $kind: "NestedResult";
                    NestedResult: [number, number];
                })[];
                address: {
                    $kind: "GasCoin";
                    GasCoin: true;
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "pure";
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "object";
                } | {
                    $kind: "Result";
                    Result: number;
                } | {
                    $kind: "NestedResult";
                    NestedResult: [number, number];
                };
            };
            SplitCoins: {
                coin: {
                    $kind: "GasCoin";
                    GasCoin: true;
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "pure";
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "object";
                } | {
                    $kind: "Result";
                    Result: number;
                } | {
                    $kind: "NestedResult";
                    NestedResult: [number, number];
                };
                amounts: ({
                    $kind: "GasCoin";
                    GasCoin: true;
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "pure";
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "object";
                } | {
                    $kind: "Result";
                    Result: number;
                } | {
                    $kind: "NestedResult";
                    NestedResult: [number, number];
                })[];
            };
            MergeCoins: {
                destination: {
                    $kind: "GasCoin";
                    GasCoin: true;
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "pure";
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "object";
                } | {
                    $kind: "Result";
                    Result: number;
                } | {
                    $kind: "NestedResult";
                    NestedResult: [number, number];
                };
                sources: ({
                    $kind: "GasCoin";
                    GasCoin: true;
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "pure";
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "object";
                } | {
                    $kind: "Result";
                    Result: number;
                } | {
                    $kind: "NestedResult";
                    NestedResult: [number, number];
                })[];
            };
            Publish: {
                modules: string[];
                dependencies: string[];
            };
            MakeMoveVec: {
                type: string;
                elements: ({
                    $kind: "GasCoin";
                    GasCoin: true;
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "pure";
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "object";
                } | {
                    $kind: "Result";
                    Result: number;
                } | {
                    $kind: "NestedResult";
                    NestedResult: [number, number];
                })[];
            };
            Upgrade: {
                modules: string[];
                dependencies: string[];
                package: string;
                ticket: {
                    $kind: "GasCoin";
                    GasCoin: true;
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "pure";
                } | {
                    $kind: "Input";
                    Input: number;
                    type?: "object";
                } | {
                    $kind: "Result";
                    Result: number;
                } | {
                    $kind: "NestedResult";
                    NestedResult: [number, number];
                };
            };
            $Intent: {
                name: string;
                inputs: {
                    [x: string]: {
                        $kind: "GasCoin";
                        GasCoin: true;
                    } | {
                        $kind: "Input";
                        Input: number;
                        type?: "pure";
                    } | {
                        $kind: "Input";
                        Input: number;
                        type?: "object";
                    } | {
                        $kind: "Result";
                        Result: number;
                    } | {
                        $kind: "NestedResult";
                        NestedResult: [number, number];
                    } | ({
                        $kind: "GasCoin";
                        GasCoin: true;
                    } | {
                        $kind: "Input";
                        Input: number;
                        type?: "pure";
                    } | {
                        $kind: "Input";
                        Input: number;
                        type?: "object";
                    } | {
                        $kind: "Result";
                        Result: number;
                    } | {
                        $kind: "NestedResult";
                        NestedResult: [number, number];
                    })[];
                };
                data: {
                    [x: string]: unknown;
                };
            };
        }, "MoveCall" | "TransferObjects" | "SplitCoins" | "MergeCoins" | "Publish" | "MakeMoveVec" | "Upgrade" | "$Intent">[];
    };
    get pure(): ReturnType<typeof createPure<Argument>>;
    constructor();
    get gas(): {
        $kind: "GasCoin";
        GasCoin: true;
    };
    object: ReturnType<typeof createObjectMethods<{
        $kind: "Input";
        Input: number;
        type?: "object";
    }>>;
    objectRef(...args: Parameters<(typeof Inputs)["ObjectRef"]>): {
        $kind: "Input";
        Input: number;
        type?: "object";
    };
    receivingRef(...args: Parameters<(typeof Inputs)["ReceivingRef"]>): {
        $kind: "Input";
        Input: number;
        type?: "object";
    };
    sharedObjectRef(...args: Parameters<(typeof Inputs)["SharedObjectRef"]>): {
        $kind: "Input";
        Input: number;
        type?: "object";
    };
    add<T extends Command>(command: T): TransactionResult;
    add<T extends void | TransactionResultArgument | TransactionArgument | Command>(thunk: (tx: Transaction) => T): T;
    add<T extends TransactionResultArgument | void>(asyncTransactionThunk: AsyncTransactionThunk<T>): T;
    splitCoins<const Amounts extends (TransactionArgument | SerializedBcs<any> | number | string | bigint)[]>(coin: TransactionObjectArgument | string, amounts: Amounts): Extract<Argument, {
        Result: unknown;
    }> & { [K in keyof Amounts]: Extract<Argument, {
        NestedResult: unknown;
    }>; };
    mergeCoins(destination: TransactionObjectArgument | string, sources: (TransactionObjectArgument | string)[]): TransactionResult;
    publish({ modules, dependencies, }: {
        modules: number[][] | string[];
        dependencies: string[];
    }): TransactionResult;
    upgrade({ modules, dependencies, package: packageId, ticket, }: {
        modules: number[][] | string[];
        dependencies: string[];
        package: string;
        ticket: TransactionObjectArgument | string;
    }): TransactionResult;
    moveCall({ arguments: args, ...input }: {
        package: string;
        module: string;
        function: string;
        arguments?: (TransactionArgument | SerializedBcs<any>)[];
        typeArguments?: string[];
    } | {
        target: string;
        arguments?: (TransactionArgument | SerializedBcs<any>)[];
        typeArguments?: string[];
    }): TransactionResult;
    transferObjects(objects: (TransactionObjectArgument | string)[], address: TransactionArgument | SerializedBcs<any> | string): TransactionResult;
    makeMoveVec({ type, elements, }: {
        elements: (TransactionObjectArgument | string)[];
        type?: string;
    }): TransactionResult;
    serialize(): string;
    toJSON(options?: SerializeTransactionOptions): Promise<string>;
    sign(options: SignOptions): Promise<SignatureWithBytes>;
    isFullyResolved(): boolean;
    build(options?: BuildTransactionOptions): Promise<Uint8Array<ArrayBuffer>>;
    getDigest(options?: {
        client?: ClientWithCoreApi;
    }): Promise<string>;
    prepareForSerialization(options: SerializeTransactionOptions): Promise<void>;
}
export {};