@bitgo-beta/sdk-coin-sui 1.4.1-alpha.31 → 1.4.1-alpha.310

package/dist/src/lib/mystenlab/builder/Inputs.js

@@ -1,22 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMutableSharedObjectInput = exports.isSharedObjectInput = exports.getSharedObjectInput = exports.getIdFromCallArg = exports.Inputs = exports.BuilderCallArg = exports.ObjectCallArg = exports.PureCallArg = void 0;
+exports.Inputs = exports.BuilderCallArg = exports.ObjectCallArg = exports.PureCallArg = void 0;
+exports.getIdFromCallArg = getIdFromCallArg;
+exports.getSharedObjectInput = getSharedObjectInput;
+exports.isSharedObjectInput = isSharedObjectInput;
+exports.isMutableSharedObjectInput = isMutableSharedObjectInput;
 const superstruct_1 = require("superstruct");
 const types_1 = require("../types");
 const bcs_1 = require("./bcs");
-const ObjectArg = superstruct_1.union([
-    superstruct_1.object({ ImmOrOwned: types_1.SuiObjectRef }),
-    superstruct_1.object({
-        Shared: superstruct_1.object({
-            objectId: superstruct_1.string(),
-            initialSharedVersion: superstruct_1.union([superstruct_1.integer(), superstruct_1.string()]),
-            mutable: superstruct_1.boolean(),
+const ObjectArg = (0, superstruct_1.union)([
+    (0, superstruct_1.object)({ ImmOrOwned: types_1.SuiObjectRef }),
+    (0, superstruct_1.object)({
+        Shared: (0, superstruct_1.object)({
+            objectId: (0, superstruct_1.string)(),
+            initialSharedVersion: (0, superstruct_1.union)([(0, superstruct_1.integer)(), (0, superstruct_1.string)()]),
+            mutable: (0, superstruct_1.boolean)(),
         }),
     }),
 ]);
-exports.PureCallArg = superstruct_1.object({ Pure: superstruct_1.array(superstruct_1.integer()) });
-exports.ObjectCallArg = superstruct_1.object({ Object: ObjectArg });
-exports.BuilderCallArg = superstruct_1.union([exports.PureCallArg, exports.ObjectCallArg]);
+exports.PureCallArg = (0, superstruct_1.object)({ Pure: (0, superstruct_1.array)((0, superstruct_1.integer)()) });
+exports.ObjectCallArg = (0, superstruct_1.object)({ Object: ObjectArg });
+exports.BuilderCallArg = (0, superstruct_1.union)([exports.PureCallArg, exports.ObjectCallArg]);
 exports.Inputs = {
     Pure(data, type) {
         return {
@@ -32,25 +36,20 @@ exports.Inputs = {
 };
 function getIdFromCallArg(arg) {
     if (typeof arg === 'string') {
-        return arg;
+        return (0, types_1.normalizeSuiAddress)(arg);
     }
     if ('ImmOrOwned' in arg.Object) {
         return arg.Object.ImmOrOwned.objectId;
     }
     return arg.Object.Shared.objectId;
 }
-exports.getIdFromCallArg = getIdFromCallArg;
 function getSharedObjectInput(arg) {
     return typeof arg === 'object' && 'Object' in arg && 'Shared' in arg.Object ? arg.Object.Shared : undefined;
 }
-exports.getSharedObjectInput = getSharedObjectInput;
 function isSharedObjectInput(arg) {
-    return getSharedObjectInput(arg) !== undefined;
+    return !!getSharedObjectInput(arg);
 }
-exports.isSharedObjectInput = isSharedObjectInput;
 function isMutableSharedObjectInput(arg) {
-    var _a, _b;
-    return (_b = (_a = getSharedObjectInput(arg)) === null || _a === void 0 ? void 0 : _a.mutable) !== null && _b !== void 0 ? _b : false;
+    return getSharedObjectInput(arg)?.mutable ?? false;
 }
-exports.isMutableSharedObjectInput = isMutableSharedObjectInput;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5wdXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9teXN0ZW5sYWIvYnVpbGRlci9JbnB1dHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBcUNBLDRDQVFDO0FBRUQsb0RBRUM7QUFFRCxrREFFQztBQUVELGdFQUVDO0FBekRELDZDQUFvRjtBQUNwRixvQ0FBd0Y7QUFDeEYsK0JBQWdDO0FBRWhDLE1BQU0sU0FBUyxHQUFHLElBQUEsbUJBQUssRUFBQztJQUN0QixJQUFBLG9CQUFNLEVBQUMsRUFBRSxVQUFVLEVBQUUsb0JBQVksRUFBRSxDQUFDO0lBQ3BDLElBQUEsb0JBQU0sRUFBQztRQUNMLE1BQU0sRUFBRSxJQUFBLG9CQUFNLEVBQUM7WUFDYixRQUFRLEVBQUUsSUFBQSxvQkFBTSxHQUFFO1lBQ2xCLG9CQUFvQixFQUFFLElBQUEsbUJBQUssRUFBQyxDQUFDLElBQUEscUJBQU8sR0FBRSxFQUFFLElBQUEsb0JBQU0sR0FBRSxDQUFDLENBQUM7WUFDbEQsT0FBTyxFQUFFLElBQUEscUJBQU8sR0FBRTtTQUNuQixDQUFDO0tBQ0gsQ0FBQztDQUNILENBQUMsQ0FBQztBQUVVLFFBQUEsV0FBVyxHQUFHLElBQUEsb0JBQU0sRUFBQyxFQUFFLElBQUksRUFBRSxJQUFBLG1CQUFLLEVBQUMsSUFBQSxxQkFBTyxHQUFFLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDakQsUUFBQSxhQUFhLEdBQUcsSUFBQSxvQkFBTSxFQUFDLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUM7QUFJOUMsUUFBQSxjQUFjLEdBQUcsSUFBQSxtQkFBSyxFQUFDLENBQUMsbUJBQVcsRUFBRSxxQkFBYSxDQUFDLENBQUMsQ0FBQztBQUdyRCxRQUFBLE1BQU0sR0FBRztJQUNwQixJQUFJLENBQUMsSUFBYSxFQUFFLElBQWE7UUFDL0IsT0FBTztZQUNMLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksWUFBWSxVQUFVLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsYUFBTyxDQUFDLEdBQUcsQ0FBQyxJQUFLLEVBQUUsSUFBSSxDQUFDLENBQUMsT0FBTyxFQUFFLENBQUM7U0FDekYsQ0FBQztJQUNKLENBQUM7SUFDRCxTQUFTLENBQUMsR0FBaUI7UUFDekIsT0FBTyxFQUFFLE1BQU0sRUFBRSxFQUFFLFVBQVUsRUFBRSxHQUFHLEVBQUUsRUFBRSxDQUFDO0lBQ3pDLENBQUM7SUFDRCxlQUFlLENBQUMsR0FBb0I7UUFDbEMsT0FBTyxFQUFFLE1BQU0sRUFBRSxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsRUFBRSxDQUFDO0lBQ3JDLENBQUM7Q0FDRixDQUFDO0FBRUYsU0FBZ0IsZ0JBQWdCLENBQUMsR0FBNkI7SUFDNUQsSUFBSSxPQUFPLEdBQUcsS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUM1QixPQUFPLElBQUEsMkJBQW1CLEVBQUMsR0FBRyxDQUFDLENBQUM7SUFDbEMsQ0FBQztJQUNELElBQUksWUFBWSxJQUFJLEdBQUcsQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUMvQixPQUFPLEdBQUcsQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQztJQUN4QyxDQUFDO0lBQ0QsT0FBTyxHQUFHLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUM7QUFDcEMsQ0FBQztBQUVELFNBQWdCLG9CQUFvQixDQUFDLEdBQW1CO0lBQ3RELE9BQU8sT0FBTyxHQUFHLEtBQUssUUFBUSxJQUFJLFFBQVEsSUFBSSxHQUFHLElBQUksUUFBUSxJQUFJLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUM7QUFDOUcsQ0FBQztBQUVELFNBQWdCLG1CQUFtQixDQUFDLEdBQW1CO0lBQ3JELE9BQU8sQ0FBQyxDQUFDLG9CQUFvQixDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ3JDLENBQUM7QUFFRCxTQUFnQiwwQkFBMEIsQ0FBQyxHQUFtQjtJQUM1RCxPQUFPLG9CQUFvQixDQUFDLEdBQUcsQ0FBQyxFQUFFLE9BQU8sSUFBSSxLQUFLLENBQUM7QUFDckQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGFycmF5LCBib29sZWFuLCBJbmZlciwgaW50ZWdlciwgb2JqZWN0LCBzdHJpbmcsIHVuaW9uIH0gZnJvbSAnc3VwZXJzdHJ1Y3QnO1xuaW1wb3J0IHsgbm9ybWFsaXplU3VpQWRkcmVzcywgT2JqZWN0SWQsIFNoYXJlZE9iamVjdFJlZiwgU3VpT2JqZWN0UmVmIH0gZnJvbSAnLi4vdHlwZXMnO1xuaW1wb3J0IHsgYnVpbGRlciB9IGZyb20gJy4vYmNzJztcblxuY29uc3QgT2JqZWN0QXJnID0gdW5pb24oW1xuICBvYmplY3QoeyBJbW1Pck93bmVkOiBTdWlPYmplY3RSZWYgfSksXG4gIG9iamVjdCh7XG4gICAgU2hhcmVkOiBvYmplY3Qoe1xuICAgICAgb2JqZWN0SWQ6IHN0cmluZygpLFxuICAgICAgaW5pdGlhbFNoYXJlZFZlcnNpb246IHVuaW9uKFtpbnRlZ2VyKCksIHN0cmluZygpXSksXG4gICAgICBtdXRhYmxlOiBib29sZWFuKCksXG4gICAgfSksXG4gIH0pLFxuXSk7XG5cbmV4cG9ydCBjb25zdCBQdXJlQ2FsbEFyZyA9IG9iamVjdCh7IFB1cmU6IGFycmF5KGludGVnZXIoKSkgfSk7XG5leHBvcnQgY29uc3QgT2JqZWN0Q2FsbEFyZyA9IG9iamVjdCh7IE9iamVjdDogT2JqZWN0QXJnIH0pO1xuZXhwb3J0IHR5cGUgUHVyZUNhbGxBcmcgPSBJbmZlcjx0eXBlb2YgUHVyZUNhbGxBcmc+O1xuZXhwb3J0IHR5cGUgT2JqZWN0Q2FsbEFyZyA9IEluZmVyPHR5cGVvZiBPYmplY3RDYWxsQXJnPjtcblxuZXhwb3J0IGNvbnN0IEJ1aWxkZXJDYWxsQXJnID0gdW5pb24oW1B1cmVDYWxsQXJnLCBPYmplY3RDYWxsQXJnXSk7XG5leHBvcnQgdHlwZSBCdWlsZGVyQ2FsbEFyZyA9IEluZmVyPHR5cGVvZiBCdWlsZGVyQ2FsbEFyZz47XG5cbmV4cG9ydCBjb25zdCBJbnB1dHMgPSB7XG4gIFB1cmUoZGF0YTogdW5rbm93biwgdHlwZT86IHN0cmluZyk6IFB1cmVDYWxsQXJnIHtcbiAgICByZXR1cm4ge1xuICAgICAgUHVyZTogQXJyYXkuZnJvbShkYXRhIGluc3RhbmNlb2YgVWludDhBcnJheSA/IGRhdGEgOiBidWlsZGVyLnNlcih0eXBlISwgZGF0YSkudG9CeXRlcygpKSxcbiAgICB9O1xuICB9LFxuICBPYmplY3RSZWYocmVmOiBTdWlPYmplY3RSZWYpOiBPYmplY3RDYWxsQXJnIHtcbiAgICByZXR1cm4geyBPYmplY3Q6IHsgSW1tT3JPd25lZDogcmVmIH0gfTtcbiAgfSxcbiAgU2hhcmVkT2JqZWN0UmVmKHJlZjogU2hhcmVkT2JqZWN0UmVmKTogT2JqZWN0Q2FsbEFyZyB7XG4gICAgcmV0dXJuIHsgT2JqZWN0OiB7IFNoYXJlZDogcmVmIH0gfTtcbiAgfSxcbn07XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRJZEZyb21DYWxsQXJnKGFyZzogT2JqZWN0SWQgfCBPYmplY3RDYWxsQXJnKTogc3RyaW5nIHtcbiAgaWYgKHR5cGVvZiBhcmcgPT09ICdzdHJpbmcnKSB7XG4gICAgcmV0dXJuIG5vcm1hbGl6ZVN1aUFkZHJlc3MoYXJnKTtcbiAgfVxuICBpZiAoJ0ltbU9yT3duZWQnIGluIGFyZy5PYmplY3QpIHtcbiAgICByZXR1cm4gYXJnLk9iamVjdC5JbW1Pck93bmVkLm9iamVjdElkO1xuICB9XG4gIHJldHVybiBhcmcuT2JqZWN0LlNoYXJlZC5vYmplY3RJZDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldFNoYXJlZE9iamVjdElucHV0KGFyZzogQnVpbGRlckNhbGxBcmcpOiBTaGFyZWRPYmplY3RSZWYgfCB1bmRlZmluZWQge1xuICByZXR1cm4gdHlwZW9mIGFyZyA9PT0gJ29iamVjdCcgJiYgJ09iamVjdCcgaW4gYXJnICYmICdTaGFyZWQnIGluIGFyZy5PYmplY3QgPyBhcmcuT2JqZWN0LlNoYXJlZCA6IHVuZGVmaW5lZDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGlzU2hhcmVkT2JqZWN0SW5wdXQoYXJnOiBCdWlsZGVyQ2FsbEFyZyk6IGJvb2xlYW4ge1xuICByZXR1cm4gISFnZXRTaGFyZWRPYmplY3RJbnB1dChhcmcpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gaXNNdXRhYmxlU2hhcmVkT2JqZWN0SW5wdXQoYXJnOiBCdWlsZGVyQ2FsbEFyZyk6IGJvb2xlYW4ge1xuICByZXR1cm4gZ2V0U2hhcmVkT2JqZWN0SW5wdXQoYXJnKT8ubXV0YWJsZSA/PyBmYWxzZTtcbn1cbiJdfQ==

package/dist/src/lib/mystenlab/builder/TransactionBlock.d.ts

@@ -0,0 +1,302 @@
+import { ObjectId, SuiObjectRef } from '../types';
+import { Transactions, TransactionArgument, TransactionType } from './Transactions';
+import { ObjectCallArg } from './Inputs';
+import { TransactionExpiration } from './TransactionDataBlock';
+type TransactionResult = TransactionArgument & TransactionArgument[];
+declare const TRANSACTION_BRAND: unique symbol;
+interface BuildOptions {
+    onlyTransactionKind?: boolean;
+}
+/**
+ * Transaction Builder
+ */
+export declare class TransactionBlock {
+    #private;
+    /** Returns `true` if the object is an instance of the Transaction builder class. */
+    static is(obj: unknown): obj is TransactionBlock;
+    /**
+     * Converts from a serialize transaction kind (built with `build({ onlyTransactionKind: true })`) to a `Transaction` class.
+     * Supports either a byte array, or base64-encoded bytes.
+     */
+    static fromKind(serialized: string | Uint8Array): TransactionBlock;
+    /**
+     * Converts from a serialized transaction format to a `Transaction` class.
+     * There are two supported serialized formats:
+     * - A string returned from `Transaction#serialize`. The serialized format must be compatible, or it will throw an error.
+     * - A byte array (or base64-encoded bytes) containing BCS transaction data.
+     */
+    static from(serialized: string | Uint8Array): TransactionBlock;
+    /** A helper to retrieve the Transaction builder `Transactions` */
+    static get Transactions(): {
+        MoveCall(input: Omit<import("./Transactions").MoveCallTransaction, "kind" | "arguments" | "typeArguments"> & {
+            arguments?: TransactionArgument[];
+            typeArguments?: string[];
+        }): import("./Transactions").MoveCallTransaction;
+        TransferObjects(objects: TransactionArgument[], address: TransactionArgument): import("./Transactions").TransferObjectsTransaction;
+        SplitCoins(coin: TransactionArgument, amounts: TransactionArgument[]): import("./Transactions").SplitCoinsTransaction;
+        MergeCoins(destination: TransactionArgument, sources: TransactionArgument[]): import("./Transactions").MergeCoinsTransaction;
+        Publish(modules: number[][], dependencies: ObjectId[]): import("./Transactions").PublishTransaction;
+        MakeMoveVec({ type, objects, }: Omit<import("./Transactions").MakeMoveVecTransaction, "kind" | "type"> & {
+            type?: string;
+        }): import("./Transactions").MakeMoveVecTransaction;
+    };
+    /** A helper to retrieve the Transaction builder `Inputs` */
+    static get Inputs(): {
+        Pure(data: unknown, type?: string): import("./Inputs").PureCallArg;
+        ObjectRef(ref: SuiObjectRef): ObjectCallArg;
+        SharedObjectRef(ref: import("../types").SharedObjectRef): ObjectCallArg;
+    };
+    setSender(sender: string): void;
+    /**
+     * Sets the sender only if it has not already been set.
+     * This is useful for sponsored transaction flows where the sender may not be the same as the signer address.
+     */
+    setSenderIfNotSet(sender: string): void;
+    setExpiration(expiration?: TransactionExpiration): void;
+    setGasPrice(price: number | bigint): void;
+    setGasBudget(budget: number | bigint): void;
+    setGasOwner(owner: string): void;
+    setGasPayment(payments: SuiObjectRef[]): void;
+    /** Get a snapshot of the transaction data, in JSON form: */
+    get blockData(): {
+        version: 1;
+        transactions: ({
+            target: `${string}::${string}::${string}`;
+            arguments: ({
+                kind: "Input";
+                index: number;
+                value?: any;
+                type?: "object" | "pure" | undefined;
+            } | {
+                kind: "GasCoin";
+            } | {
+                kind: "Result";
+                index: number;
+            } | {
+                resultIndex: number;
+                kind: "NestedResult";
+                index: number;
+            })[];
+            kind: "MoveCall";
+            typeArguments: string[];
+        } | {
+            objects: ({
+                kind: "Input";
+                index: number;
+                value?: any;
+                type?: "object" | "pure" | undefined;
+            } | {
+                kind: "GasCoin";
+            } | {
+                kind: "Result";
+                index: number;
+            } | {
+                resultIndex: number;
+                kind: "NestedResult";
+                index: number;
+            })[];
+            kind: "TransferObjects";
+            address: {
+                kind: "Input";
+                index: number;
+                value?: any;
+                type?: "object" | "pure" | undefined;
+            } | {
+                kind: "GasCoin";
+            } | {
+                kind: "Result";
+                index: number;
+            } | {
+                resultIndex: number;
+                kind: "NestedResult";
+                index: number;
+            };
+        } | {
+            coin: {
+                kind: "Input";
+                index: number;
+                value?: any;
+                type?: "object" | "pure" | undefined;
+            } | {
+                kind: "GasCoin";
+            } | {
+                kind: "Result";
+                index: number;
+            } | {
+                resultIndex: number;
+                kind: "NestedResult";
+                index: number;
+            };
+            kind: "SplitCoins";
+            amounts: ({
+                kind: "Input";
+                index: number;
+                value?: any;
+                type?: "object" | "pure" | undefined;
+            } | {
+                kind: "GasCoin";
+            } | {
+                kind: "Result";
+                index: number;
+            } | {
+                resultIndex: number;
+                kind: "NestedResult";
+                index: number;
+            })[];
+        } | {
+            kind: "MergeCoins";
+            destination: {
+                kind: "Input";
+                index: number;
+                value?: any;
+                type?: "object" | "pure" | undefined;
+            } | {
+                kind: "GasCoin";
+            } | {
+                kind: "Result";
+                index: number;
+            } | {
+                resultIndex: number;
+                kind: "NestedResult";
+                index: number;
+            };
+            sources: ({
+                kind: "Input";
+                index: number;
+                value?: any;
+                type?: "object" | "pure" | undefined;
+            } | {
+                kind: "GasCoin";
+            } | {
+                kind: "Result";
+                index: number;
+            } | {
+                resultIndex: number;
+                kind: "NestedResult";
+                index: number;
+            })[];
+        } | {
+            kind: "Publish";
+            modules: number[][];
+            dependencies: string[];
+        } | {
+            objects: ({
+                kind: "Input";
+                index: number;
+                value?: any;
+                type?: "object" | "pure" | undefined;
+            } | {
+                kind: "GasCoin";
+            } | {
+                kind: "Result";
+                index: number;
+            } | {
+                resultIndex: number;
+                kind: "NestedResult";
+                index: number;
+            })[];
+            kind: "MakeMoveVec";
+            type?: {
+                None: null;
+            } | {
+                Some: string;
+            } | undefined;
+        })[];
+        inputs: {
+            kind: "Input";
+            index: number;
+            value?: any;
+            type?: "object" | "pure" | undefined;
+        }[];
+        gasConfig: {
+            budget?: string | undefined;
+            price?: string | undefined;
+            payment?: {
+                digest: string;
+                objectId: string;
+                version: string | number;
+            }[] | undefined;
+            owner?: string | undefined;
+        };
+        sender?: string | undefined;
+        expiration?: {
+            Epoch: number;
+        } | {
+            None: true | null;
+        } | null | undefined;
+    };
+    get [TRANSACTION_BRAND](): boolean;
+    constructor(transaction?: TransactionBlock);
+    /** Returns an argument for the gas coin, to be used in a transaction. */
+    get gas(): TransactionArgument;
+    /**
+     * Dynamically create a new input, which is separate from the `input`. This is important
+     * for generated clients to be able to define unique inputs that are non-overlapping with the
+     * defined inputs.
+     *
+     * For `Uint8Array` type automatically convert the input into a `Pure` CallArg, since this
+     * is the format required for custom serialization.
+     *
+     */
+    input(type: 'object' | 'pure', value?: unknown): {
+        kind: "Input";
+        index: number;
+        value?: any;
+        type?: "object" | "pure" | undefined;
+    };
+    /**
+     * Add a new object input to the transaction.
+     */
+    object(value: ObjectId | ObjectCallArg): {
+        kind: "Input";
+        index: number;
+        value?: any;
+        type?: "object" | "pure" | undefined;
+    };
+    /**
+     * Add a new non-object input to the transaction.
+     */
+    pure(
+    /**
+     * The pure value that will be used as the input value. If this is a Uint8Array, then the value
+     * is assumed to be raw bytes, and will be used directly.
+     */
+    value: unknown, 
+    /**
+     * The BCS type to serialize the value into. If not provided, the type will automatically be determined
+     * based on how the input is used.
+     */
+    type?: string): {
+        kind: "Input";
+        index: number;
+        value?: any;
+        type?: "object" | "pure" | undefined;
+    };
+    /** Add a transaction to the transaction block. */
+    add(transaction: TransactionType): TransactionResult;
+    splitCoins(...args: Parameters<(typeof Transactions)['SplitCoins']>): TransactionResult;
+    mergeCoins(...args: Parameters<(typeof Transactions)['MergeCoins']>): TransactionResult;
+    publish(...args: Parameters<(typeof Transactions)['Publish']>): TransactionResult;
+    moveCall(...args: Parameters<(typeof Transactions)['MoveCall']>): TransactionResult;
+    transferObjects(...args: Parameters<(typeof Transactions)['TransferObjects']>): TransactionResult;
+    makeMoveVec(...args: Parameters<(typeof Transactions)['MakeMoveVec']>): TransactionResult;
+    /**
+     * Serialize the transaction to a string so that it can be sent to a separate context.
+     * This is different from `build` in that it does not serialize to BCS bytes, and instead
+     * uses a separate format that is unique to the transaction builder. This allows
+     * us to serialize partially-complete transactions, that can then be completed and
+     * built in a separate context.
+     *
+     * For example, a dapp can construct a transaction, but not provide gas objects
+     * or a gas budget. The transaction then can be sent to the wallet, where this
+     * information is automatically filled in (e.g. by querying for coin objects
+     * and performing a dry run).
+     */
+    serialize(): string;
+    /** Build the transaction to BCS bytes. */
+    build({ onlyTransactionKind }?: BuildOptions): Promise<Uint8Array>;
+    /** Derive transaction digest */
+    getDigest(): Promise<string>;
+}
+export {};
+//# sourceMappingURL=TransactionBlock.d.ts.map

package/dist/src/lib/mystenlab/builder/TransactionBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionBlock.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/TransactionBlock.ts"],"names":[],"mappings":"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"}