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

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

@@ -1,254 +0,0 @@
-"use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return privateMap.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
-};
-var _transactionData;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = void 0;
-const bcs_1 = require("@mysten/bcs");
-const superstruct_1 = require("superstruct");
-const types_1 = require("../types");
-const Commands_1 = require("./Commands");
-const Inputs_1 = require("./Inputs");
-const TransactionData_1 = require("./TransactionData");
-const utils_1 = require("./utils");
-function createTransactionResult(index) {
-    const baseResult = { kind: 'Result', index };
-    const nestedResults = [];
-    const nestedResultFor = (resultIndex) => {
-        var _a;
-        return ((_a = nestedResults[resultIndex]) !== null && _a !== void 0 ? _a : (nestedResults[resultIndex] = {
-            kind: 'NestedResult',
-            index,
-            resultIndex,
-        }));
-    };
-    return new Proxy(baseResult, {
-        set() {
-            throw new Error('The transaction result is a proxy, and does not support setting properties directly');
-        },
-        // TODO: Instead of making this return a concrete argument, we should ideally
-        // make it reference-based (so that this gets resolved at build-time), which
-        // allows re-ordering transactions.
-        get(target, property) {
-            // This allows this transaction argument to be used in the singular form:
-            if (property in target) {
-                return Reflect.get(target, property);
-            }
-            // Support destructuring:
-            if (property === Symbol.iterator) {
-                return function* () {
-                    let i = 0;
-                    while (true) {
-                        yield nestedResultFor(i);
-                        i++;
-                    }
-                };
-            }
-            if (typeof property === 'symbol')
-                return;
-            const resultIndex = parseInt(property, 10);
-            if (Number.isNaN(resultIndex) || resultIndex < 0)
-                return;
-            return nestedResultFor(resultIndex);
-        },
-    });
-}
-// The maximum number of gas objects that can be selected for one transaction.
-const MAX_GAS_OBJECTS = 256;
-/**
- * Transaction Builder
- */
-class Transaction {
-    constructor(transaction) {
-        _transactionData.set(this, void 0);
-        __classPrivateFieldSet(this, _transactionData, new TransactionData_1.TransactionDataBuilder(transaction ? __classPrivateFieldGet(transaction, _transactionData) : undefined));
-    }
-    /** Returns `true` if the object is an instance of the Transaction builder class. */
-    static is(obj) {
-        return (!!obj && typeof obj === 'object'
-        // &&
-        // (obj as any)[TRANSACTION_BRAND] === true
-        );
-    }
-    /**
-     * 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) {
-        const tx = new Transaction();
-        __classPrivateFieldSet(tx, _transactionData, TransactionData_1.TransactionDataBuilder.fromKindBytes(typeof serialized === 'string' ? bcs_1.fromB64(serialized) : serialized));
-        return tx;
-    }
-    /**
-     * 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) {
-        const tx = new Transaction();
-        // Check for bytes:
-        if (typeof serialized !== 'string' || !serialized.startsWith('{')) {
-            __classPrivateFieldSet(tx, _transactionData, TransactionData_1.TransactionDataBuilder.fromBytes(typeof serialized === 'string' ? bcs_1.fromB64(serialized) : serialized));
-        }
-        else {
-            __classPrivateFieldSet(tx, _transactionData, TransactionData_1.TransactionDataBuilder.restore(JSON.parse(serialized)));
-        }
-        return tx;
-    }
-    /** A helper to retrieve the Transaction builder `Commands` */
-    static get Commands() {
-        return Commands_1.Commands;
-    }
-    /** A helper to retrieve the Transaction builder `Inputs` */
-    static get Inputs() {
-        return Inputs_1.Inputs;
-    }
-    setSender(sender) {
-        __classPrivateFieldGet(this, _transactionData).sender = sender;
-    }
-    /**
-     * 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) {
-        if (!__classPrivateFieldGet(this, _transactionData).sender) {
-            __classPrivateFieldGet(this, _transactionData).sender = sender;
-        }
-    }
-    setExpiration(expiration) {
-        __classPrivateFieldGet(this, _transactionData).expiration = expiration;
-    }
-    setGasPrice(price) {
-        __classPrivateFieldGet(this, _transactionData).gasConfig.price = String(price);
-    }
-    setGasBudget(budget) {
-        __classPrivateFieldGet(this, _transactionData).gasConfig.budget = String(budget);
-    }
-    setGasOwner(owner) {
-        __classPrivateFieldGet(this, _transactionData).gasConfig.owner = owner;
-    }
-    setGasPayment(payments) {
-        if (payments.length >= MAX_GAS_OBJECTS) {
-            throw new Error(`Payment objects exceed maximum amount ${MAX_GAS_OBJECTS}`);
-        }
-        __classPrivateFieldGet(this, _transactionData).gasConfig.payment = payments.map((payment) => superstruct_1.mask(payment, types_1.SuiObjectRef));
-    }
-    /** Get a snapshot of the transaction data, in JSON form: */
-    get transactionData() {
-        return __classPrivateFieldGet(this, _transactionData).snapshot();
-    }
-    /** Returns an argument for the gas coin, to be used in a transaction. */
-    get gas() {
-        return { kind: 'GasCoin' };
-    }
-    /**
-     * 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, value) {
-        const index = __classPrivateFieldGet(this, _transactionData).inputs.length;
-        const input = utils_1.create({
-            kind: 'Input',
-            // bigints can't be serialized to JSON, so just string-convert them here:
-            value: typeof value === 'bigint' ? String(value) : value,
-            index,
-            type,
-        }, Commands_1.TransactionInput);
-        __classPrivateFieldGet(this, _transactionData).inputs.push(input);
-        return input;
-    }
-    /**
-     * Add a new object input to the transaction.
-     */
-    object(value) {
-        const id = Inputs_1.getIdFromCallArg(value);
-        // deduplicate
-        const inserted = __classPrivateFieldGet(this, _transactionData).inputs.find((i) => i.type === 'object' && id === Inputs_1.getIdFromCallArg(i.value));
-        return inserted !== null && inserted !== void 0 ? inserted : this.input('object', value);
-    }
-    /**
-     * 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, 
-    /**
-     * 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) {
-        // TODO: we can also do some deduplication here
-        return this.input('pure', value instanceof Uint8Array ? Inputs_1.Inputs.Pure(value) : type ? Inputs_1.Inputs.Pure(value, type) : value);
-    }
-    /** Add a command to the transaction. */
-    add(command) {
-        // TODO: This should also look at the command arguments and add any referenced commands that are not present in this transaction.
-        const index = __classPrivateFieldGet(this, _transactionData).commands.push(command);
-        return createTransactionResult(index - 1);
-    }
-    // Method shorthands:
-    splitCoins(...args) {
-        return this.add(Commands_1.Commands.SplitCoins(...args));
-    }
-    mergeCoins(...args) {
-        return this.add(Commands_1.Commands.MergeCoins(...args));
-    }
-    publish(...args) {
-        return this.add(Commands_1.Commands.Publish(...args));
-    }
-    moveCall(...args) {
-        return this.add(Commands_1.Commands.MoveCall(...args));
-    }
-    transferObjects(...args) {
-        return this.add(Commands_1.Commands.TransferObjects(...args));
-    }
-    makeMoveVec(...args) {
-        return this.add(Commands_1.Commands.MakeMoveVec(...args));
-    }
-    /**
-     * 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() {
-        return JSON.stringify(__classPrivateFieldGet(this, _transactionData).snapshot());
-    }
-    /** Build the transaction to BCS bytes. */
-    async build({ onlyTransactionKind } = {}) {
-        return __classPrivateFieldGet(this, _transactionData).build({ onlyTransactionKind });
-    }
-    /** Derive transaction digest */
-    async getDigest() {
-        return __classPrivateFieldGet(this, _transactionData).getDigest();
-    }
-}
-exports.Transaction = Transaction;
-_transactionData = new WeakMap();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Transaction.js","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/Transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { fromB64 } from '@mysten/bcs';\nimport { mask } from 'superstruct';\nimport { ObjectId, SuiObjectRef } from '../types';\nimport { CommandArgument, Commands, TransactionCommand, TransactionInput } from './Commands';\nimport { getIdFromCallArg, Inputs, ObjectCallArg } from './Inputs';\nimport { TransactionDataBuilder, TransactionExpiration } from './TransactionData';\nimport { create } from './utils';\n\ntype TransactionResult = CommandArgument & CommandArgument[];\n\nfunction createTransactionResult(index: number): TransactionResult {\n  const baseResult: CommandArgument = { kind: 'Result', index };\n\n  const nestedResults: CommandArgument[] = [];\n  const nestedResultFor = (resultIndex: number): CommandArgument =>\n    (nestedResults[resultIndex] ??= {\n      kind: 'NestedResult',\n      index,\n      resultIndex,\n    });\n\n  return new Proxy(baseResult, {\n    set() {\n      throw new Error('The transaction result is a proxy, and does not support setting properties directly');\n    },\n    // TODO: Instead of making this return a concrete argument, we should ideally\n    // make it reference-based (so that this gets resolved at build-time), which\n    // allows re-ordering transactions.\n    get(target, property) {\n      // This allows this transaction argument to be used in the singular form:\n      if (property in target) {\n        return Reflect.get(target, property);\n      }\n\n      // Support destructuring:\n      if (property === Symbol.iterator) {\n        return function* () {\n          let i = 0;\n          while (true) {\n            yield nestedResultFor(i);\n            i++;\n          }\n        };\n      }\n\n      if (typeof property === 'symbol') return;\n\n      const resultIndex = parseInt(property, 10);\n      if (Number.isNaN(resultIndex) || resultIndex < 0) return;\n      return nestedResultFor(resultIndex);\n    },\n  }) as TransactionResult;\n}\n\n// The maximum number of gas objects that can be selected for one transaction.\nconst MAX_GAS_OBJECTS = 256;\n\ninterface BuildOptions {\n  onlyTransactionKind?: boolean;\n}\n\n/**\n * Transaction Builder\n */\nexport class Transaction {\n  /** Returns `true` if the object is an instance of the Transaction builder class. */\n  static is(obj: unknown): obj is Transaction {\n    return (\n      !!obj && typeof obj === 'object'\n      // &&\n      // (obj as any)[TRANSACTION_BRAND] === true\n    );\n  }\n\n  /**\n   * Converts from a serialize transaction kind (built with `build({ onlyTransactionKind: true })`) to a `Transaction` class.\n   * Supports either a byte array, or base64-encoded bytes.\n   */\n  static fromKind(serialized: string | Uint8Array) {\n    const tx = new Transaction();\n\n    tx.#transactionData = TransactionDataBuilder.fromKindBytes(\n      typeof serialized === 'string' ? fromB64(serialized) : serialized\n    );\n\n    return tx;\n  }\n\n  /**\n   * Converts from a serialized transaction format to a `Transaction` class.\n   * There are two supported serialized formats:\n   * - A string returned from `Transaction#serialize`. The serialized format must be compatible, or it will throw an error.\n   * - A byte array (or base64-encoded bytes) containing BCS transaction data.\n   */\n  static from(serialized: string | Uint8Array) {\n    const tx = new Transaction();\n\n    // Check for bytes:\n    if (typeof serialized !== 'string' || !serialized.startsWith('{')) {\n      tx.#transactionData = TransactionDataBuilder.fromBytes(\n        typeof serialized === 'string' ? fromB64(serialized) : serialized\n      );\n    } else {\n      tx.#transactionData = TransactionDataBuilder.restore(JSON.parse(serialized));\n    }\n\n    return tx;\n  }\n\n  /** A helper to retrieve the Transaction builder `Commands` */\n  static get Commands() {\n    return Commands;\n  }\n\n  /** A helper to retrieve the Transaction builder `Inputs` */\n  static get Inputs() {\n    return Inputs;\n  }\n\n  setSender(sender: string) {\n    this.#transactionData.sender = sender;\n  }\n\n  /**\n   * Sets the sender only if it has not already been set.\n   * This is useful for sponsored transaction flows where the sender may not be the same as the signer address.\n   */\n  setSenderIfNotSet(sender: string) {\n    if (!this.#transactionData.sender) {\n      this.#transactionData.sender = sender;\n    }\n  }\n\n  setExpiration(expiration?: TransactionExpiration) {\n    this.#transactionData.expiration = expiration;\n  }\n\n  setGasPrice(price: number | bigint) {\n    this.#transactionData.gasConfig.price = String(price);\n  }\n\n  setGasBudget(budget: number | bigint) {\n    this.#transactionData.gasConfig.budget = String(budget);\n  }\n\n  setGasOwner(owner: string) {\n    this.#transactionData.gasConfig.owner = owner;\n  }\n\n  setGasPayment(payments: SuiObjectRef[]) {\n    if (payments.length >= MAX_GAS_OBJECTS) {\n      throw new Error(`Payment objects exceed maximum amount ${MAX_GAS_OBJECTS}`);\n    }\n    this.#transactionData.gasConfig.payment = payments.map((payment) => mask(payment, SuiObjectRef));\n  }\n\n  #transactionData: TransactionDataBuilder;\n  /** Get a snapshot of the transaction data, in JSON form: */\n  get transactionData() {\n    return this.#transactionData.snapshot();\n  }\n\n  constructor(transaction?: Transaction) {\n    this.#transactionData = new TransactionDataBuilder(transaction ? transaction.#transactionData : undefined);\n  }\n\n  /** Returns an argument for the gas coin, to be used in a transaction. */\n  get gas(): CommandArgument {\n    return { kind: 'GasCoin' };\n  }\n\n  /**\n   * Dynamically create a new input, which is separate from the `input`. This is important\n   * for generated clients to be able to define unique inputs that are non-overlapping with the\n   * defined inputs.\n   *\n   * For `Uint8Array` type automatically convert the input into a `Pure` CallArg, since this\n   * is the format required for custom serialization.\n   *\n   */\n  private input(type: 'object' | 'pure', value?: unknown) {\n    const index = this.#transactionData.inputs.length;\n    const input = create(\n      {\n        kind: 'Input',\n        // bigints can't be serialized to JSON, so just string-convert them here:\n        value: typeof value === 'bigint' ? String(value) : value,\n        index,\n        type,\n      },\n      TransactionInput\n    );\n    this.#transactionData.inputs.push(input);\n    return input;\n  }\n\n  /**\n   * Add a new object input to the transaction.\n   */\n  object(value: ObjectId | ObjectCallArg) {\n    const id = getIdFromCallArg(value);\n    // deduplicate\n    const inserted = this.#transactionData.inputs.find((i) => i.type === 'object' && id === getIdFromCallArg(i.value));\n    return inserted ?? this.input('object', value);\n  }\n\n  /**\n   * Add a new non-object input to the transaction.\n   */\n  pure(\n    /**\n     * The pure value that will be used as the input value. If this is a Uint8Array, then the value\n     * is assumed to be raw bytes, and will be used directly.\n     */\n    value: unknown,\n    /**\n     * The BCS type to serialize the value into. If not provided, the type will automatically be determined\n     * based on how the input is used.\n     */\n    type?: string\n  ) {\n    // TODO: we can also do some deduplication here\n    return this.input(\n      'pure',\n      value instanceof Uint8Array ? Inputs.Pure(value) : type ? Inputs.Pure(value, type) : value\n    );\n  }\n\n  /** Add a command to the transaction. */\n  add(command: TransactionCommand) {\n    // TODO: This should also look at the command arguments and add any referenced commands that are not present in this transaction.\n    const index = this.#transactionData.commands.push(command);\n    return createTransactionResult(index - 1);\n  }\n\n  // Method shorthands:\n\n  splitCoins(...args: Parameters<typeof Commands['SplitCoins']>) {\n    return this.add(Commands.SplitCoins(...args));\n  }\n\n  mergeCoins(...args: Parameters<typeof Commands['MergeCoins']>) {\n    return this.add(Commands.MergeCoins(...args));\n  }\n\n  publish(...args: Parameters<typeof Commands['Publish']>) {\n    return this.add(Commands.Publish(...args));\n  }\n\n  moveCall(...args: Parameters<typeof Commands['MoveCall']>) {\n    return this.add(Commands.MoveCall(...args));\n  }\n\n  transferObjects(...args: Parameters<typeof Commands['TransferObjects']>) {\n    return this.add(Commands.TransferObjects(...args));\n  }\n\n  makeMoveVec(...args: Parameters<typeof Commands['MakeMoveVec']>) {\n    return this.add(Commands.MakeMoveVec(...args));\n  }\n\n  /**\n   * Serialize the transaction to a string so that it can be sent to a separate context.\n   * This is different from `build` in that it does not serialize to BCS bytes, and instead\n   * uses a separate format that is unique to the transaction builder. This allows\n   * us to serialize partially-complete transactions, that can then be completed and\n   * built in a separate context.\n   *\n   * For example, a dapp can construct a transaction, but not provide gas objects\n   * or a gas budget. The transaction then can be sent to the wallet, where this\n   * information is automatically filled in (e.g. by querying for coin objects\n   * and performing a dry run).\n   */\n  serialize() {\n    return JSON.stringify(this.#transactionData.snapshot());\n  }\n\n  /** Build the transaction to BCS bytes. */\n  async build({ onlyTransactionKind }: BuildOptions = {}): Promise<Uint8Array> {\n    return this.#transactionData.build({ onlyTransactionKind });\n  }\n\n  /** Derive transaction digest */\n  async getDigest(): Promise<string> {\n    return this.#transactionData.getDigest();\n  }\n}\n"]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"TransactionData.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/TransactionData.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,EASN,MAAM,aAAa,CAAC;AAIrB,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAIlE,eAAO,MAAM,qBAAqB;;;;2BAEjC,CAAC;AACF,oBAAY,qBAAqB,GAAG,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAexE,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;EAKb,CAAC;AACH,aAAK,SAAS,GAAG,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAEzC,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO3C,CAAC;AACH,oBAAY,gCAAgC,GAAG,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAQ9F,eAAO,MAAM,yBAAyB,QAAa,CAAC;AAEpD,qBAAa,sBAAsB;IACjC,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,UAAU;IA8BtC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,UAAU;IAiClC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,gCAAgC;IAOrD;;;;;OAKG;IACH,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,UAAU;IAK3C,OAAO,IAAc;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,qBAAqB,CAAC;IACnC,SAAS,EAAE,SAAS,CAAC;IACrB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,QAAQ,EAAE,kBAAkB,EAAE,CAAC;gBAEnB,KAAK,CAAC,EAAE,sBAAsB;IAQ1C,KAAK,CAAC,EACJ,SAAS,EACT,mBAAmB,GACpB,GAAE;QACD,SAAS,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,EAAE,QAAQ,GAAG,WAAW,GAAG,YAAY,CAAC,CAAC;QACzF,mBAAmB,CAAC,EAAE,OAAO,CAAC;KAC1B;IA0DN,SAAS;IAKT,QAAQ,IAAI,gCAAgC;CAG7C"}

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

@@ -1,171 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionDataBuilder = exports.TRANSACTION_DATA_MAX_SIZE = exports.SerializedTransactionDataBuilder = exports.TransactionExpiration = void 0;
-const bcs_1 = require("@mysten/bcs");
-const superstruct_1 = require("superstruct");
-const hash_1 = require("../cryptography/hash");
-const types_1 = require("../types");
-const bcs_2 = require("./bcs");
-const Commands_1 = require("./Commands");
-const Inputs_1 = require("./Inputs");
-const utils_1 = require("./utils");
-exports.TransactionExpiration = superstruct_1.optional(superstruct_1.nullable(superstruct_1.union([superstruct_1.object({ Epoch: superstruct_1.integer() }), superstruct_1.object({ None: superstruct_1.union([superstruct_1.literal(true), superstruct_1.literal(null)]) })])));
-const SuiAddress = superstruct_1.string();
-const StringEncodedBigint = superstruct_1.define('StringEncodedBigint', (val) => {
-    if (!['string', 'number', 'bigint'].includes(typeof val))
-        return false;
-    try {
-        BigInt(val);
-        return true;
-    }
-    catch {
-        return false;
-    }
-});
-const GasConfig = superstruct_1.object({
-    budget: superstruct_1.optional(StringEncodedBigint),
-    price: superstruct_1.optional(StringEncodedBigint),
-    payment: superstruct_1.optional(superstruct_1.array(types_1.SuiObjectRef)),
-    owner: superstruct_1.optional(SuiAddress),
-});
-exports.SerializedTransactionDataBuilder = superstruct_1.object({
-    version: superstruct_1.literal(1),
-    sender: superstruct_1.optional(SuiAddress),
-    expiration: exports.TransactionExpiration,
-    gasConfig: GasConfig,
-    inputs: superstruct_1.array(Commands_1.TransactionInput),
-    commands: superstruct_1.array(Commands_1.TransactionCommand),
-});
-function prepareSuiAddress(address) {
-    return types_1.normalizeSuiAddress(address).replace('0x', '');
-}
-// NOTE: This value should be kept in sync with the corresponding value in
-// crates/sui-protocol-config/src/lib.rs
-exports.TRANSACTION_DATA_MAX_SIZE = 128 * 1024;
-class TransactionDataBuilder {
-    constructor(clone) {
-        var _a, _b, _c;
-        this.version = 1;
-        this.sender = clone === null || clone === void 0 ? void 0 : clone.sender;
-        this.expiration = clone === null || clone === void 0 ? void 0 : clone.expiration;
-        this.gasConfig = (_a = clone === null || clone === void 0 ? void 0 : clone.gasConfig) !== null && _a !== void 0 ? _a : {};
-        this.inputs = (_b = clone === null || clone === void 0 ? void 0 : clone.inputs) !== null && _b !== void 0 ? _b : [];
-        this.commands = (_c = clone === null || clone === void 0 ? void 0 : clone.commands) !== null && _c !== void 0 ? _c : [];
-    }
-    static fromKindBytes(bytes) {
-        const kind = bcs_2.builder.de('TransactionKind', bytes);
-        const programmableTx = kind === null || kind === void 0 ? void 0 : kind.ProgrammableTransaction;
-        if (!programmableTx) {
-            throw new Error('Unable to deserialize from bytes.');
-        }
-        const serialized = utils_1.create({
-            version: 1,
-            gasConfig: {},
-            inputs: programmableTx.inputs.map((value, index) => utils_1.create({
-                kind: 'Input',
-                value,
-                index,
-                type: superstruct_1.is(value, Inputs_1.PureCallArg) ? 'pure' : 'object',
-            }, Commands_1.TransactionInput)),
-            commands: programmableTx.commands,
-        }, exports.SerializedTransactionDataBuilder);
-        return TransactionDataBuilder.restore(serialized);
-    }
-    static fromBytes(bytes) {
-        var _a;
-        const rawData = bcs_2.builder.de('TransactionData', bytes);
-        const data = rawData === null || rawData === void 0 ? void 0 : rawData.V1;
-        const programmableTx = (_a = data === null || data === void 0 ? void 0 : data.kind) === null || _a === void 0 ? void 0 : _a.ProgrammableTransaction;
-        if (!data || !programmableTx) {
-            throw new Error('Unable to deserialize from bytes.');
-        }
-        const serialized = utils_1.create({
-            version: 1,
-            sender: data.sender,
-            expiration: data.expiration,
-            gasConfig: data.gasData,
-            inputs: programmableTx.inputs.map((value, index) => utils_1.create({
-                kind: 'Input',
-                value,
-                index,
-                type: superstruct_1.is(value, Inputs_1.PureCallArg) ? 'pure' : 'object',
-            }, Commands_1.TransactionInput)),
-            commands: programmableTx.commands,
-        }, exports.SerializedTransactionDataBuilder);
-        return TransactionDataBuilder.restore(serialized);
-    }
-    static restore(data) {
-        superstruct_1.assert(data, exports.SerializedTransactionDataBuilder);
-        const transactionData = new TransactionDataBuilder();
-        Object.assign(transactionData, data);
-        return transactionData;
-    }
-    /**
-     * Generate transaction digest.
-     *
-     * @param bytes BCS serialized transaction data
-     * @returns transaction digest.
-     */
-    static getDigestFromBytes(bytes) {
-        const hash = hash_1.hashTypedData('TransactionData', bytes);
-        return bcs_1.toB58(hash);
-    }
-    build({ overrides, onlyTransactionKind, } = {}) {
-        var _a, _b, _c;
-        // Resolve inputs down to values:
-        const inputs = this.inputs.map((input) => {
-            superstruct_1.assert(input.value, Inputs_1.BuilderCallArg);
-            return input.value;
-        });
-        const kind = {
-            ProgrammableTransaction: {
-                inputs,
-                commands: this.commands,
-            },
-        };
-        if (onlyTransactionKind) {
-            return bcs_2.builder.ser('TransactionKind', kind, { maxSize: exports.TRANSACTION_DATA_MAX_SIZE }).toBytes();
-        }
-        const expiration = (_a = overrides === null || overrides === void 0 ? void 0 : overrides.expiration) !== null && _a !== void 0 ? _a : this.expiration;
-        const sender = (_b = overrides === null || overrides === void 0 ? void 0 : overrides.sender) !== null && _b !== void 0 ? _b : this.sender;
-        const gasConfig = { ...this.gasConfig, ...overrides === null || overrides === void 0 ? void 0 : overrides.gasConfig };
-        if (!sender) {
-            throw new Error('Missing transaction sender');
-        }
-        if (!gasConfig.budget) {
-            throw new Error('Missing gas budget');
-        }
-        if (!gasConfig.payment) {
-            throw new Error('Missing gas payment');
-        }
-        if (!gasConfig.price) {
-            throw new Error('Missing gas price');
-        }
-        const transactionData = {
-            sender: prepareSuiAddress(sender),
-            expiration: expiration ? expiration : { None: true },
-            gasData: {
-                payment: gasConfig.payment,
-                owner: prepareSuiAddress((_c = this.gasConfig.owner) !== null && _c !== void 0 ? _c : sender),
-                price: BigInt(gasConfig.price),
-                budget: BigInt(gasConfig.budget),
-            },
-            kind: {
-                ProgrammableTransaction: {
-                    inputs,
-                    commands: this.commands,
-                },
-            },
-        };
-        return bcs_2.builder.ser('TransactionData', { V1: transactionData }, { maxSize: exports.TRANSACTION_DATA_MAX_SIZE }).toBytes();
-    }
-    getDigest() {
-        const bytes = this.build({ onlyTransactionKind: false });
-        return TransactionDataBuilder.getDigestFromBytes(bytes);
-    }
-    snapshot() {
-        return utils_1.create(this, exports.SerializedTransactionDataBuilder);
-    }
-}
-exports.TransactionDataBuilder = TransactionDataBuilder;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TransactionData.js","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/TransactionData.ts"],"names":[],"mappings":"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","sourcesContent":["import { toB58 } from '@mysten/bcs';\nimport {\n  array,\n  assert,\n  define,\n  Infer,\n  integer,\n  is,\n  literal,\n  nullable,\n  object,\n  optional,\n  string,\n  union,\n} from 'superstruct';\nimport { hashTypedData } from '../cryptography/hash';\nimport { normalizeSuiAddress, SuiObjectRef } from '../types';\nimport { builder } from './bcs';\nimport { TransactionCommand, TransactionInput } from './Commands';\nimport { BuilderCallArg, PureCallArg } from './Inputs';\nimport { create } from './utils';\n\nexport const TransactionExpiration = optional(\n  nullable(union([object({ Epoch: integer() }), object({ None: union([literal(true), literal(null)]) })]))\n);\nexport type TransactionExpiration = Infer<typeof TransactionExpiration>;\n\nconst SuiAddress = string();\n\nconst StringEncodedBigint = define<string>('StringEncodedBigint', (val) => {\n  if (!['string', 'number', 'bigint'].includes(typeof val)) return false;\n\n  try {\n    BigInt(val as string);\n    return true;\n  } catch {\n    return false;\n  }\n});\n\nconst GasConfig = object({\n  budget: optional(StringEncodedBigint),\n  price: optional(StringEncodedBigint),\n  payment: optional(array(SuiObjectRef)),\n  owner: optional(SuiAddress),\n});\ntype GasConfig = Infer<typeof GasConfig>;\n\nexport const SerializedTransactionDataBuilder = object({\n  version: literal(1),\n  sender: optional(SuiAddress),\n  expiration: TransactionExpiration,\n  gasConfig: GasConfig,\n  inputs: array(TransactionInput),\n  commands: array(TransactionCommand),\n});\nexport type SerializedTransactionDataBuilder = Infer<typeof SerializedTransactionDataBuilder>;\n\nfunction prepareSuiAddress(address: string) {\n  return normalizeSuiAddress(address).replace('0x', '');\n}\n\n// NOTE: This value should be kept in sync with the corresponding value in\n// crates/sui-protocol-config/src/lib.rs\nexport const TRANSACTION_DATA_MAX_SIZE = 128 * 1024;\n\nexport class TransactionDataBuilder {\n  static fromKindBytes(bytes: Uint8Array) {\n    const kind = builder.de('TransactionKind', bytes);\n    const programmableTx = kind?.ProgrammableTransaction;\n    if (!programmableTx) {\n      throw new Error('Unable to deserialize from bytes.');\n    }\n\n    const serialized = create(\n      {\n        version: 1,\n        gasConfig: {},\n        inputs: programmableTx.inputs.map((value: unknown, index: number) =>\n          create(\n            {\n              kind: 'Input',\n              value,\n              index,\n              type: is(value, PureCallArg) ? 'pure' : 'object',\n            },\n            TransactionInput\n          )\n        ),\n        commands: programmableTx.commands,\n      },\n      SerializedTransactionDataBuilder\n    );\n\n    return TransactionDataBuilder.restore(serialized);\n  }\n\n  static fromBytes(bytes: Uint8Array) {\n    const rawData = builder.de('TransactionData', bytes);\n    const data = rawData?.V1;\n    const programmableTx = data?.kind?.ProgrammableTransaction;\n    if (!data || !programmableTx) {\n      throw new Error('Unable to deserialize from bytes.');\n    }\n\n    const serialized = create(\n      {\n        version: 1,\n        sender: data.sender,\n        expiration: data.expiration,\n        gasConfig: data.gasData,\n        inputs: programmableTx.inputs.map((value: unknown, index: number) =>\n          create(\n            {\n              kind: 'Input',\n              value,\n              index,\n              type: is(value, PureCallArg) ? 'pure' : 'object',\n            },\n            TransactionInput\n          )\n        ),\n        commands: programmableTx.commands,\n      },\n      SerializedTransactionDataBuilder\n    );\n\n    return TransactionDataBuilder.restore(serialized);\n  }\n\n  static restore(data: SerializedTransactionDataBuilder) {\n    assert(data, SerializedTransactionDataBuilder);\n    const transactionData = new TransactionDataBuilder();\n    Object.assign(transactionData, data);\n    return transactionData;\n  }\n\n  /**\n   * Generate transaction digest.\n   *\n   * @param bytes BCS serialized transaction data\n   * @returns transaction digest.\n   */\n  static getDigestFromBytes(bytes: Uint8Array) {\n    const hash = hashTypedData('TransactionData', bytes);\n    return toB58(hash);\n  }\n\n  version = 1 as const;\n  sender?: string;\n  expiration?: TransactionExpiration;\n  gasConfig: GasConfig;\n  inputs: TransactionInput[];\n  commands: TransactionCommand[];\n\n  constructor(clone?: TransactionDataBuilder) {\n    this.sender = clone?.sender;\n    this.expiration = clone?.expiration;\n    this.gasConfig = clone?.gasConfig ?? {};\n    this.inputs = clone?.inputs ?? [];\n    this.commands = clone?.commands ?? [];\n  }\n\n  build({\n    overrides,\n    onlyTransactionKind,\n  }: {\n    overrides?: Pick<Partial<TransactionDataBuilder>, 'sender' | 'gasConfig' | 'expiration'>;\n    onlyTransactionKind?: boolean;\n  } = {}) {\n    // Resolve inputs down to values:\n    const inputs = this.inputs.map((input) => {\n      assert(input.value, BuilderCallArg);\n      return input.value;\n    });\n\n    const kind = {\n      ProgrammableTransaction: {\n        inputs,\n        commands: this.commands,\n      },\n    };\n\n    if (onlyTransactionKind) {\n      return builder.ser('TransactionKind', kind, { maxSize: TRANSACTION_DATA_MAX_SIZE }).toBytes();\n    }\n\n    const expiration = overrides?.expiration ?? this.expiration;\n    const sender = overrides?.sender ?? this.sender;\n    const gasConfig = { ...this.gasConfig, ...overrides?.gasConfig };\n\n    if (!sender) {\n      throw new Error('Missing transaction sender');\n    }\n\n    if (!gasConfig.budget) {\n      throw new Error('Missing gas budget');\n    }\n\n    if (!gasConfig.payment) {\n      throw new Error('Missing gas payment');\n    }\n\n    if (!gasConfig.price) {\n      throw new Error('Missing gas price');\n    }\n\n    const transactionData = {\n      sender: prepareSuiAddress(sender),\n      expiration: expiration ? expiration : { None: true },\n      gasData: {\n        payment: gasConfig.payment,\n        owner: prepareSuiAddress(this.gasConfig.owner ?? sender),\n        price: BigInt(gasConfig.price),\n        budget: BigInt(gasConfig.budget),\n      },\n      kind: {\n        ProgrammableTransaction: {\n          inputs,\n          commands: this.commands,\n        },\n      },\n    };\n\n    return builder.ser('TransactionData', { V1: transactionData }, { maxSize: TRANSACTION_DATA_MAX_SIZE }).toBytes();\n  }\n\n  getDigest() {\n    const bytes = this.build({ onlyTransactionKind: false });\n    return TransactionDataBuilder.getDigestFromBytes(bytes);\n  }\n\n  snapshot(): SerializedTransactionDataBuilder {\n    return create(this, SerializedTransactionDataBuilder);\n  }\n}\n"]}

package/dist/src/lib/mystenlab/builder/type-tag-serializer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"type-tag-serializer.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/type-tag-serializer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,OAAO,EAAE,MAAM,UAAU,CAAC;AAKxD,qBAAa,iBAAiB;IAC5B,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,gBAAgB,UAAQ,GAAG,OAAO;IA4CnE,MAAM,CAAC,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,gBAAgB,UAAQ,GAAG,OAAO,EAAE;IA0B5E,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM;CAsCzC"}

package/dist/src/lib/mystenlab/builder/type-tag-serializer.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeTagSerializer = void 0;
-const types_1 = require("../types");
-const VECTOR_REGEX = /^vector<(.+)>$/;
-const STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
-class TypeTagSerializer {
-    static parseFromStr(str, normalizeAddress = false) {
-        if (str === 'address') {
-            return { address: null };
-        }
-        else if (str === 'bool') {
-            return { bool: null };
-        }
-        else if (str === 'u8') {
-            return { u8: null };
-        }
-        else if (str === 'u16') {
-            return { u16: null };
-        }
-        else if (str === 'u32') {
-            return { u32: null };
-        }
-        else if (str === 'u64') {
-            return { u64: null };
-        }
-        else if (str === 'u128') {
-            return { u128: null };
-        }
-        else if (str === 'u256') {
-            return { u256: null };
-        }
-        else if (str === 'signer') {
-            return { signer: null };
-        }
-        const vectorMatch = str.match(VECTOR_REGEX);
-        if (vectorMatch) {
-            return {
-                vector: TypeTagSerializer.parseFromStr(vectorMatch[1], normalizeAddress),
-            };
-        }
-        const structMatch = str.match(STRUCT_REGEX);
-        if (structMatch) {
-            const address = normalizeAddress ? types_1.normalizeSuiAddress(structMatch[1]) : structMatch[1];
-            return {
-                struct: {
-                    address,
-                    module: structMatch[2],
-                    name: structMatch[3],
-                    typeParams: structMatch[5] === undefined ? [] : TypeTagSerializer.parseStructTypeArgs(structMatch[5], normalizeAddress),
-                },
-            };
-        }
-        throw new Error(`Encountered unexpected token when parsing type args for ${str}`);
-    }
-    static parseStructTypeArgs(str, normalizeAddress = false) {
-        // split `str` by all `,` outside angle brackets
-        const tok = [];
-        let word = '';
-        let nestedAngleBrackets = 0;
-        for (let i = 0; i < str.length; i++) {
-            const char = str[i];
-            if (char === '<') {
-                nestedAngleBrackets++;
-            }
-            if (char === '>') {
-                nestedAngleBrackets--;
-            }
-            if (nestedAngleBrackets === 0 && char === ',') {
-                tok.push(word.trim());
-                word = '';
-                continue;
-            }
-            word += char;
-        }
-        tok.push(word.trim());
-        return tok.map((tok) => TypeTagSerializer.parseFromStr(tok, normalizeAddress));
-    }
-    static tagToString(tag) {
-        if ('bool' in tag) {
-            return 'bool';
-        }
-        if ('u8' in tag) {
-            return 'u8';
-        }
-        if ('u16' in tag) {
-            return 'u16';
-        }
-        if ('u32' in tag) {
-            return 'u32';
-        }
-        if ('u64' in tag) {
-            return 'u64';
-        }
-        if ('u128' in tag) {
-            return 'u128';
-        }
-        if ('u256' in tag) {
-            return 'u256';
-        }
-        if ('address' in tag) {
-            return 'address';
-        }
-        if ('signer' in tag) {
-            return 'signer';
-        }
-        if ('vector' in tag) {
-            return `vector<${TypeTagSerializer.tagToString(tag.vector)}>`;
-        }
-        if ('struct' in tag) {
-            const struct = tag.struct;
-            const typeParams = struct.typeParams.map(TypeTagSerializer.tagToString).join(', ');
-            return `${struct.address}::${struct.module}::${struct.name}${typeParams ? `<${typeParams}>` : ''}`;
-        }
-        throw new Error('Invalid TypeTag');
-    }
-}
-exports.TypeTagSerializer = TypeTagSerializer;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type-tag-serializer.js","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/builder/type-tag-serializer.ts"],"names":[],"mappings":"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","sourcesContent":["import { normalizeSuiAddress, TypeTag } from '../types';\n\nconst VECTOR_REGEX = /^vector<(.+)>$/;\nconst STRUCT_REGEX = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;\n\nexport class TypeTagSerializer {\n  static parseFromStr(str: string, normalizeAddress = false): TypeTag {\n    if (str === 'address') {\n      return { address: null };\n    } else if (str === 'bool') {\n      return { bool: null };\n    } else if (str === 'u8') {\n      return { u8: null };\n    } else if (str === 'u16') {\n      return { u16: null };\n    } else if (str === 'u32') {\n      return { u32: null };\n    } else if (str === 'u64') {\n      return { u64: null };\n    } else if (str === 'u128') {\n      return { u128: null };\n    } else if (str === 'u256') {\n      return { u256: null };\n    } else if (str === 'signer') {\n      return { signer: null };\n    }\n    const vectorMatch = str.match(VECTOR_REGEX);\n    if (vectorMatch) {\n      return {\n        vector: TypeTagSerializer.parseFromStr(vectorMatch[1], normalizeAddress),\n      };\n    }\n\n    const structMatch = str.match(STRUCT_REGEX);\n    if (structMatch) {\n      const address = normalizeAddress ? normalizeSuiAddress(structMatch[1]) : structMatch[1];\n      return {\n        struct: {\n          address,\n          module: structMatch[2],\n          name: structMatch[3],\n          typeParams:\n            structMatch[5] === undefined ? [] : TypeTagSerializer.parseStructTypeArgs(structMatch[5], normalizeAddress),\n        },\n      };\n    }\n\n    throw new Error(`Encountered unexpected token when parsing type args for ${str}`);\n  }\n\n  static parseStructTypeArgs(str: string, normalizeAddress = false): TypeTag[] {\n    // split `str` by all `,` outside angle brackets\n    const tok: Array<string> = [];\n    let word = '';\n    let nestedAngleBrackets = 0;\n    for (let i = 0; i < str.length; i++) {\n      const char = str[i];\n      if (char === '<') {\n        nestedAngleBrackets++;\n      }\n      if (char === '>') {\n        nestedAngleBrackets--;\n      }\n      if (nestedAngleBrackets === 0 && char === ',') {\n        tok.push(word.trim());\n        word = '';\n        continue;\n      }\n      word += char;\n    }\n\n    tok.push(word.trim());\n\n    return tok.map((tok) => TypeTagSerializer.parseFromStr(tok, normalizeAddress));\n  }\n\n  static tagToString(tag: TypeTag): string {\n    if ('bool' in tag) {\n      return 'bool';\n    }\n    if ('u8' in tag) {\n      return 'u8';\n    }\n    if ('u16' in tag) {\n      return 'u16';\n    }\n    if ('u32' in tag) {\n      return 'u32';\n    }\n    if ('u64' in tag) {\n      return 'u64';\n    }\n    if ('u128' in tag) {\n      return 'u128';\n    }\n    if ('u256' in tag) {\n      return 'u256';\n    }\n    if ('address' in tag) {\n      return 'address';\n    }\n    if ('signer' in tag) {\n      return 'signer';\n    }\n    if ('vector' in tag) {\n      return `vector<${TypeTagSerializer.tagToString(tag.vector)}>`;\n    }\n    if ('struct' in tag) {\n      const struct = tag.struct;\n      const typeParams = struct.typeParams.map(TypeTagSerializer.tagToString).join(', ');\n      return `${struct.address}::${struct.module}::${struct.name}${typeParams ? `<${typeParams}>` : ''}`;\n    }\n    throw new Error('Invalid TypeTag');\n  }\n}\n"]}