wowok 2.1.10 → 2.1.13

package/dist/esm/transactions/Transaction.js

@@ -1,731 +1,646 @@
-var __defProp = Object.defineProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _serializationPlugins, _buildPlugins, _intentResolvers, _inputSection, _commandSection, _availableResults, _pendingPromises, _added, _data, _Transaction_instances, fork_fn, addCommand_fn, addInput_fn, normalizeTransactionArgument_fn, resolveArgument_fn, prepareBuild_fn, runPlugins_fn, waitForPendingTasks_fn, sortCommandsAndInputs_fn;
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+var _a;
 import { fromBase64, isSerializedBcs } from "@mysten/bcs";
 import { is, parse } from "valibot";
 import { normalizeWowAddress } from "../utils/sui-types.js";
 import { Commands } from "./Commands.js";
-import {
-  ArgumentSchema,
-  NormalizedCallArg,
-  ObjectRefSchema,
-  TransactionExpiration
-} from "./data/internal.js";
+import { ArgumentSchema, NormalizedCallArg, ObjectRefSchema, TransactionExpiration, } from "./data/internal.js";
 import { serializeV1TransactionData } from "./data/v1.js";
 import { SerializedTransactionDataV2Schema } from "./data/v2.js";
 import { Inputs } from "./Inputs.js";
-import {
-  needsTransactionResolution,
-  resolveTransactionPlugin
-} from "./resolve.js";
+import { needsTransactionResolution, resolveTransactionPlugin, } from "./resolve.js";
 import { createObjectMethods } from "./object.js";
 import { createPure } from "./pure.js";
 import { TransactionDataBuilder } from "./TransactionData.js";
 import { getIdFromCallArg } from "./utils.js";
 import { namedPackagesPlugin } from "./plugins/NamedPackagesPlugin.js";
 function createTransactionResult(index, length = Infinity) {
-  const baseResult = {
-    $kind: "Result",
-    get Result() {
-      return typeof index === "function" ? index() : index;
-    }
-  };
-  const nestedResults = [];
-  const nestedResultFor = (resultIndex) => nestedResults[resultIndex] ?? (nestedResults[resultIndex] = {
-    $kind: "NestedResult",
-    get NestedResult() {
-      return [
-        typeof index === "function" ? index() : 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) {
-      if (property in target) {
-        return Reflect.get(target, property);
-      }
-      if (property === Symbol.iterator) {
-        return function* () {
-          let i = 0;
-          while (i < length) {
-            yield nestedResultFor(i);
-            i++;
-          }
-        };
-      }
-      if (typeof property === "symbol") return;
-      const resultIndex = parseInt(property, 10);
-      if (Number.isNaN(resultIndex) || resultIndex < 0) return;
-      return nestedResultFor(resultIndex);
-    }
-  });
+    const baseResult = {
+        $kind: "Result",
+        get Result() {
+            return typeof index === "function" ? index() : index;
+        },
+    };
+    const nestedResults = [];
+    const nestedResultFor = (resultIndex) => (nestedResults[resultIndex] ??= {
+        $kind: "NestedResult",
+        get NestedResult() {
+            return [
+                typeof index === "function" ? index() : 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 (i < length) {
+                        yield nestedResultFor(i);
+                        i++;
+                    }
+                };
+            }
+            if (typeof property === "symbol")
+                return;
+            const resultIndex = parseInt(property, 10);
+            if (Number.isNaN(resultIndex) || resultIndex < 0)
+                return;
+            return nestedResultFor(resultIndex);
+        },
+    });
 }
-const TRANSACTION_BRAND = /* @__PURE__ */ Symbol.for("@mysten/transaction");
-function isTransaction(obj) {
-  return !!obj && typeof obj === "object" && obj[TRANSACTION_BRAND] === true;
+const TRANSACTION_BRAND = Symbol.for("@mysten/transaction");
+export function isTransaction(obj) {
+    return (!!obj &&
+        typeof obj === "object" &&
+        obj[TRANSACTION_BRAND] === true);
 }
 const modulePluginRegistry = {
-  buildPlugins: /* @__PURE__ */ new Map(),
-  serializationPlugins: /* @__PURE__ */ new Map()
+    buildPlugins: new Map(),
+    serializationPlugins: new Map(),
 };
-const TRANSACTION_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("@mysten/transaction/registry");
+const TRANSACTION_REGISTRY_KEY = Symbol.for("@mysten/transaction/registry");
 function getGlobalPluginRegistry() {
-  try {
-    const target = globalThis;
-    if (!target[TRANSACTION_REGISTRY_KEY]) {
-      target[TRANSACTION_REGISTRY_KEY] = modulePluginRegistry;
-    }
-    return target[TRANSACTION_REGISTRY_KEY];
-  } catch {
-    return modulePluginRegistry;
-  }
+    try {
+        const target = globalThis;
+        if (!target[TRANSACTION_REGISTRY_KEY]) {
+            target[TRANSACTION_REGISTRY_KEY] = modulePluginRegistry;
+        }
+        return target[TRANSACTION_REGISTRY_KEY];
+    }
+    catch {
+        return modulePluginRegistry;
+    }
 }
-const _Transaction = class _Transaction {
-  constructor() {
-    __privateAdd(this, _Transaction_instances);
-    __privateAdd(this, _serializationPlugins);
-    __privateAdd(this, _buildPlugins);
-    __privateAdd(this, _intentResolvers, /* @__PURE__ */ new Map());
-    __privateAdd(this, _inputSection, []);
-    __privateAdd(this, _commandSection, []);
-    __privateAdd(this, _availableResults, /* @__PURE__ */ new Set());
-    __privateAdd(this, _pendingPromises, /* @__PURE__ */ new Set());
-    __privateAdd(this, _added, /* @__PURE__ */ new Map());
-    __privateAdd(this, _data);
+/**
+ * Transaction Builder
+ */
+export class Transaction {
+    #serializationPlugins;
+    #buildPlugins;
+    #intentResolvers = new Map();
+    #inputSection = [];
+    #commandSection = [];
+    #availableResults = new Set();
+    #pendingPromises = new Set();
+    #added = new Map();
+    /**
+     * 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 _a();
+        tx.#data = TransactionDataBuilder.fromKindBytes(typeof serialized === "string"
+            ? fromBase64(serialized)
+            : serialized);
+        tx.#inputSection = tx.#data.inputs.slice();
+        tx.#commandSection = tx.#data.commands.slice();
+        tx.#availableResults = new Set(tx.#commandSection.map((_, i) => i));
+        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(transaction) {
+        const newTransaction = new _a();
+        if (isTransaction(transaction)) {
+            newTransaction.#data = TransactionDataBuilder.restore(transaction.getData());
+        }
+        else if (typeof transaction !== "string" ||
+            !transaction.startsWith("{")) {
+            newTransaction.#data = TransactionDataBuilder.fromBytes(typeof transaction === "string"
+                ? fromBase64(transaction)
+                : transaction);
+        }
+        else {
+            newTransaction.#data = TransactionDataBuilder.restore(JSON.parse(transaction));
+        }
+        newTransaction.#inputSection = newTransaction.#data.inputs.slice();
+        newTransaction.#commandSection = newTransaction.#data.commands.slice();
+        newTransaction.#availableResults = new Set(newTransaction.#commandSection.map((_, i) => i));
+        return newTransaction;
+    }
+    static registerGlobalSerializationPlugin(stepOrStep, step) {
+        getGlobalPluginRegistry().serializationPlugins.set(stepOrStep, step ?? stepOrStep);
+    }
+    static unregisterGlobalSerializationPlugin(name) {
+        getGlobalPluginRegistry().serializationPlugins.delete(name);
+    }
+    static registerGlobalBuildPlugin(stepOrStep, step) {
+        getGlobalPluginRegistry().buildPlugins.set(stepOrStep, step ?? stepOrStep);
+    }
+    static unregisterGlobalBuildPlugin(name) {
+        getGlobalPluginRegistry().buildPlugins.delete(name);
+    }
+    addSerializationPlugin(step) {
+        this.#serializationPlugins.push(step);
+    }
+    addBuildPlugin(step) {
+        this.#buildPlugins.push(step);
+    }
+    addIntentResolver(intent, resolver) {
+        if (this.#intentResolvers.has(intent) &&
+            this.#intentResolvers.get(intent) !== resolver) {
+            throw new Error(`Intent resolver for ${intent} already exists`);
+        }
+        this.#intentResolvers.set(intent, resolver);
+    }
+    setSender(sender) {
+        this.#data.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 (!this.#data.sender) {
+            this.#data.sender = sender;
+        }
+    }
+    setExpiration(expiration) {
+        this.#data.expiration = expiration
+            ? parse(TransactionExpiration, expiration)
+            : null;
+    }
+    setGasPrice(price) {
+        this.#data.gasConfig.price = String(price);
+    }
+    setGasBudget(budget) {
+        this.#data.gasConfig.budget = String(budget);
+    }
+    setGasBudgetIfNotSet(budget) {
+        if (this.#data.gasData.budget == null) {
+            this.#data.gasConfig.budget = String(budget);
+        }
+    }
+    setGasOwner(owner) {
+        this.#data.gasConfig.owner = owner;
+    }
+    setGasPayment(payments) {
+        this.#data.gasConfig.payment = payments.map((payment) => parse(ObjectRefSchema, payment));
+    }
+    #data;
+    /** @deprecated Use `getData()` instead. */
+    get blockData() {
+        return serializeV1TransactionData(this.#data.snapshot());
+    }
+    /** Get a snapshot of the transaction data, in JSON form: */
+    getData() {
+        return this.#data.snapshot();
+    }
+    // Used to brand transaction classes so that they can be identified, even between multiple copies
+    // of the builder.
+    get [TRANSACTION_BRAND]() {
+        return true;
+    }
+    // Temporary workaround for the wallet interface accidentally serializing transactions via postMessage
+    get pure() {
+        Object.defineProperty(this, "pure", {
+            enumerable: false,
+            value: createPure((value) => {
+                if (isSerializedBcs(value)) {
+                    return this.#addInput("pure", {
+                        $kind: "Pure",
+                        Pure: {
+                            bytes: value.toBase64(),
+                        },
+                    });
+                }
+                // TODO: we can also do some deduplication here
+                return this.#addInput("pure", is(NormalizedCallArg, value)
+                    ? parse(NormalizedCallArg, value)
+                    : value instanceof Uint8Array
+                        ? Inputs.Pure(value)
+                        : {
+                            $kind: "UnresolvedPure",
+                            UnresolvedPure: { value },
+                        });
+            }),
+        });
+        return this.pure;
+    }
+    constructor() {
+        const globalPlugins = getGlobalPluginRegistry();
+        this.#data = new TransactionDataBuilder();
+        this.#buildPlugins = [...globalPlugins.buildPlugins.values()];
+        this.#serializationPlugins = [
+            ...globalPlugins.serializationPlugins.values(),
+        ];
+    }
+    /** Returns an argument for the gas coin, to be used in a transaction. */
+    get gas() {
+        return { $kind: "GasCoin", GasCoin: true };
+    }
     /**
      * Add a new object input to the transaction.
      */
-    __publicField(this, "object", createObjectMethods(
-      (value) => {
+    object = createObjectMethods((value) => {
         if (typeof value === "function") {
-          return this.object(
-            this.add(
-              value
-            )
-          );
+            return this.object(this.add(value));
         }
         if (typeof value === "object" && is(ArgumentSchema, value)) {
-          return value;
+            return value;
         }
         const id = getIdFromCallArg(value);
-        const inserted = __privateGet(this, _data).inputs.find(
-          (i) => id === getIdFromCallArg(i)
-        );
-        if (inserted?.Object?.SharedObject && typeof value === "object" && value.Object?.SharedObject) {
-          inserted.Object.SharedObject.mutable = inserted.Object.SharedObject.mutable || value.Object.SharedObject.mutable;
+        const inserted = this.#data.inputs.find((i) => id === getIdFromCallArg(i));
+        // Upgrade shared object inputs to mutable if needed:
+        if (inserted?.Object?.SharedObject &&
+            typeof value === "object" &&
+            value.Object?.SharedObject) {
+            inserted.Object.SharedObject.mutable =
+                inserted.Object.SharedObject.mutable ||
+                    value.Object.SharedObject.mutable;
         }
-        return inserted ? {
-          $kind: "Input",
-          Input: __privateGet(this, _data).inputs.indexOf(inserted),
-          type: "object"
-        } : __privateMethod(this, _Transaction_instances, addInput_fn).call(this, "object", typeof value === "string" ? {
-          $kind: "UnresolvedObject",
-          UnresolvedObject: {
-            objectId: normalizeWowAddress(value)
-          }
-        } : value);
-      }
-    ));
-    const globalPlugins = getGlobalPluginRegistry();
-    __privateSet(this, _data, new TransactionDataBuilder());
-    __privateSet(this, _buildPlugins, [...globalPlugins.buildPlugins.values()]);
-    __privateSet(this, _serializationPlugins, [
-      ...globalPlugins.serializationPlugins.values()
-    ]);
-  }
-  /**
-   * 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();
-    __privateSet(tx, _data, TransactionDataBuilder.fromKindBytes(
-      typeof serialized === "string" ? fromBase64(serialized) : serialized
-    ));
-    __privateSet(tx, _inputSection, __privateGet(tx, _data).inputs.slice());
-    __privateSet(tx, _commandSection, __privateGet(tx, _data).commands.slice());
-    __privateSet(tx, _availableResults, new Set(__privateGet(tx, _commandSection).map((_, i) => i)));
-    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(transaction) {
-    const newTransaction = new _Transaction();
-    if (isTransaction(transaction)) {
-      __privateSet(newTransaction, _data, TransactionDataBuilder.restore(
-        transaction.getData()
-      ));
-    } else if (typeof transaction !== "string" || !transaction.startsWith("{")) {
-      __privateSet(newTransaction, _data, TransactionDataBuilder.fromBytes(
-        typeof transaction === "string" ? fromBase64(transaction) : transaction
-      ));
-    } else {
-      __privateSet(newTransaction, _data, TransactionDataBuilder.restore(
-        JSON.parse(transaction)
-      ));
-    }
-    __privateSet(newTransaction, _inputSection, __privateGet(newTransaction, _data).inputs.slice());
-    __privateSet(newTransaction, _commandSection, __privateGet(newTransaction, _data).commands.slice());
-    __privateSet(newTransaction, _availableResults, new Set(
-      __privateGet(newTransaction, _commandSection).map((_, i) => i)
-    ));
-    return newTransaction;
-  }
-  static registerGlobalSerializationPlugin(stepOrStep, step) {
-    getGlobalPluginRegistry().serializationPlugins.set(
-      stepOrStep,
-      step ?? stepOrStep
-    );
-  }
-  static unregisterGlobalSerializationPlugin(name) {
-    getGlobalPluginRegistry().serializationPlugins.delete(name);
-  }
-  static registerGlobalBuildPlugin(stepOrStep, step) {
-    getGlobalPluginRegistry().buildPlugins.set(
-      stepOrStep,
-      step ?? stepOrStep
-    );
-  }
-  static unregisterGlobalBuildPlugin(name) {
-    getGlobalPluginRegistry().buildPlugins.delete(name);
-  }
-  addSerializationPlugin(step) {
-    __privateGet(this, _serializationPlugins).push(step);
-  }
-  addBuildPlugin(step) {
-    __privateGet(this, _buildPlugins).push(step);
-  }
-  addIntentResolver(intent, resolver) {
-    if (__privateGet(this, _intentResolvers).has(intent) && __privateGet(this, _intentResolvers).get(intent) !== resolver) {
-      throw new Error(`Intent resolver for ${intent} already exists`);
-    }
-    __privateGet(this, _intentResolvers).set(intent, resolver);
-  }
-  setSender(sender) {
-    __privateGet(this, _data).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 (!__privateGet(this, _data).sender) {
-      __privateGet(this, _data).sender = sender;
-    }
-  }
-  setExpiration(expiration) {
-    __privateGet(this, _data).expiration = expiration ? parse(TransactionExpiration, expiration) : null;
-  }
-  setGasPrice(price) {
-    __privateGet(this, _data).gasConfig.price = String(price);
-  }
-  setGasBudget(budget) {
-    __privateGet(this, _data).gasConfig.budget = String(budget);
-  }
-  setGasBudgetIfNotSet(budget) {
-    if (__privateGet(this, _data).gasData.budget == null) {
-      __privateGet(this, _data).gasConfig.budget = String(budget);
-    }
-  }
-  setGasOwner(owner) {
-    __privateGet(this, _data).gasConfig.owner = owner;
-  }
-  setGasPayment(payments) {
-    __privateGet(this, _data).gasConfig.payment = payments.map(
-      (payment) => parse(ObjectRefSchema, payment)
-    );
-  }
-  /** @deprecated Use `getData()` instead. */
-  get blockData() {
-    return serializeV1TransactionData(__privateGet(this, _data).snapshot());
-  }
-  /** Get a snapshot of the transaction data, in JSON form: */
-  getData() {
-    return __privateGet(this, _data).snapshot();
-  }
-  // Used to brand transaction classes so that they can be identified, even between multiple copies
-  // of the builder.
-  get [TRANSACTION_BRAND]() {
-    return true;
-  }
-  // Temporary workaround for the wallet interface accidentally serializing transactions via postMessage
-  get pure() {
-    Object.defineProperty(this, "pure", {
-      enumerable: false,
-      value: createPure((value) => {
-        if (isSerializedBcs(value)) {
-          return __privateMethod(this, _Transaction_instances, addInput_fn).call(this, "pure", {
-            $kind: "Pure",
-            Pure: {
-              bytes: value.toBase64()
+        return inserted
+            ? {
+                $kind: "Input",
+                Input: this.#data.inputs.indexOf(inserted),
+                type: "object",
+            }
+            : this.#addInput("object", typeof value === "string"
+                ? {
+                    $kind: "UnresolvedObject",
+                    UnresolvedObject: {
+                        objectId: normalizeWowAddress(value),
+                    },
+                }
+                : value);
+    });
+    /**
+     * Add a new object input to the transaction using the fully-resolved object reference.
+     * If you only have an object ID, use `builder.object(id)` instead.
+     */
+    objectRef(...args) {
+        return this.object(Inputs.ObjectRef(...args));
+    }
+    /**
+     * Add a new receiving input to the transaction using the fully-resolved object reference.
+     * If you only have an object ID, use `builder.object(id)` instead.
+     */
+    receivingRef(...args) {
+        return this.object(Inputs.ReceivingRef(...args));
+    }
+    /**
+     * Add a new shared object input to the transaction using the fully-resolved shared object reference.
+     * If you only have an object ID, use `builder.object(id)` instead.
+     */
+    sharedObjectRef(...args) {
+        return this.object(Inputs.SharedObjectRef(...args));
+    }
+    #fork() {
+        const fork = new _a();
+        fork.#data = this.#data;
+        fork.#serializationPlugins = this.#serializationPlugins;
+        fork.#buildPlugins = this.#buildPlugins;
+        fork.#intentResolvers = this.#intentResolvers;
+        fork.#pendingPromises = this.#pendingPromises;
+        fork.#availableResults = new Set(this.#availableResults);
+        fork.#added = this.#added;
+        this.#inputSection.push(fork.#inputSection);
+        this.#commandSection.push(fork.#commandSection);
+        return fork;
+    }
+    add(command) {
+        if (typeof command === "function") {
+            if (this.#added.has(command)) {
+                return this.#added.get(command);
             }
-          });
+            const fork = this.#fork();
+            const result = command(fork);
+            if (!(result && typeof result === "object" && "then" in result)) {
+                this.#availableResults = fork.#availableResults;
+                this.#added.set(command, result);
+                return result;
+            }
+            const placeholder = this.#addCommand({
+                $kind: "$Intent",
+                $Intent: {
+                    name: "AsyncTransactionThunk",
+                    inputs: {},
+                    data: {
+                        resultIndex: this.#data.commands.length,
+                        result: null,
+                    },
+                },
+            });
+            this.#pendingPromises.add(Promise.resolve(result).then((result) => {
+                placeholder.$Intent.data.result = result;
+            }));
+            const txResult = createTransactionResult(() => placeholder.$Intent.data.resultIndex);
+            this.#added.set(command, txResult);
+            return txResult;
+        }
+        else {
+            this.#addCommand(command);
         }
-        return __privateMethod(this, _Transaction_instances, addInput_fn).call(this, "pure", is(NormalizedCallArg, value) ? parse(NormalizedCallArg, value) : value instanceof Uint8Array ? Inputs.Pure(value) : {
-          $kind: "UnresolvedPure",
-          UnresolvedPure: { value }
+        return createTransactionResult(this.#data.commands.length - 1);
+    }
+    #addCommand(command) {
+        const resultIndex = this.#data.commands.length;
+        this.#commandSection.push(command);
+        this.#availableResults.add(resultIndex);
+        this.#data.commands.push(command);
+        this.#data.mapCommandArguments(resultIndex, (arg) => {
+            if (arg.$kind === "Result" &&
+                !this.#availableResults.has(arg.Result)) {
+                throw new Error(`Result { Result: ${arg.Result} } is not available to use in the current transaction`);
+            }
+            if (arg.$kind === "NestedResult" &&
+                !this.#availableResults.has(arg.NestedResult[0])) {
+                throw new Error(`Result { NestedResult: [${arg.NestedResult[0]}, ${arg.NestedResult[1]}] } is not available to use in the current transaction`);
+            }
+            if (arg.$kind === "Input" &&
+                arg.Input >= this.#data.inputs.length) {
+                throw new Error(`Input { Input: ${arg.Input} } references an input that does not exist in the current transaction`);
+            }
+            return arg;
         });
-      })
-    });
-    return this.pure;
-  }
-  /** Returns an argument for the gas coin, to be used in a transaction. */
-  get gas() {
-    return { $kind: "GasCoin", GasCoin: true };
-  }
-  /**
-   * Add a new object input to the transaction using the fully-resolved object reference.
-   * If you only have an object ID, use `builder.object(id)` instead.
-   */
-  objectRef(...args) {
-    return this.object(Inputs.ObjectRef(...args));
-  }
-  /**
-   * Add a new receiving input to the transaction using the fully-resolved object reference.
-   * If you only have an object ID, use `builder.object(id)` instead.
-   */
-  receivingRef(...args) {
-    return this.object(Inputs.ReceivingRef(...args));
-  }
-  /**
-   * Add a new shared object input to the transaction using the fully-resolved shared object reference.
-   * If you only have an object ID, use `builder.object(id)` instead.
-   */
-  sharedObjectRef(...args) {
-    return this.object(Inputs.SharedObjectRef(...args));
-  }
-  add(command) {
-    if (typeof command === "function") {
-      if (__privateGet(this, _added).has(command)) {
-        return __privateGet(this, _added).get(command);
-      }
-      const fork = __privateMethod(this, _Transaction_instances, fork_fn).call(this);
-      const result = command(fork);
-      if (!(result && typeof result === "object" && "then" in result)) {
-        __privateSet(this, _availableResults, __privateGet(fork, _availableResults));
-        __privateGet(this, _added).set(command, result);
-        return result;
-      }
-      const placeholder = __privateMethod(this, _Transaction_instances, addCommand_fn).call(this, {
-        $kind: "$Intent",
-        $Intent: {
-          name: "AsyncTransactionThunk",
-          inputs: {},
-          data: {
-            resultIndex: __privateGet(this, _data).commands.length,
-            result: null
-          }
+        return command;
+    }
+    #addInput(type, input) {
+        this.#inputSection.push(input);
+        return this.#data.addInput(type, input);
+    }
+    #normalizeTransactionArgument(arg) {
+        if (isSerializedBcs(arg)) {
+            return this.pure(arg);
         }
-      });
-      __privateGet(this, _pendingPromises).add(
-        Promise.resolve(result).then(
-          (result2) => {
-            placeholder.$Intent.data.result = result2;
-          }
-        )
-      );
-      const txResult = createTransactionResult(
-        () => placeholder.$Intent.data.resultIndex
-      );
-      __privateGet(this, _added).set(command, txResult);
-      return txResult;
-    } else {
-      __privateMethod(this, _Transaction_instances, addCommand_fn).call(this, command);
-    }
-    return createTransactionResult(__privateGet(this, _data).commands.length - 1);
-  }
-  // Method shorthands:
-  splitCoins(coin, amounts) {
-    const command = Commands.SplitCoins(
-      typeof coin === "string" ? this.object(coin) : __privateMethod(this, _Transaction_instances, resolveArgument_fn).call(this, coin),
-      amounts.map(
-        (amount) => typeof amount === "number" || typeof amount === "bigint" || typeof amount === "string" ? this.pure.u64(amount) : __privateMethod(this, _Transaction_instances, normalizeTransactionArgument_fn).call(this, amount)
-      )
-    );
-    __privateMethod(this, _Transaction_instances, addCommand_fn).call(this, command);
-    return createTransactionResult(
-      __privateGet(this, _data).commands.length - 1,
-      amounts.length
-    );
-  }
-  mergeCoins(destination, sources) {
-    return this.add(
-      Commands.MergeCoins(
-        this.object(destination),
-        sources.map((src) => this.object(src))
-      )
-    );
-  }
-  publish({
-    modules,
-    dependencies
-  }) {
-    return this.add(
-      Commands.Publish({
-        modules,
-        dependencies
-      })
-    );
-  }
-  upgrade({
-    modules,
-    dependencies,
-    package: packageId,
-    ticket
-  }) {
-    return this.add(
-      Commands.Upgrade({
-        modules,
-        dependencies,
-        package: packageId,
-        ticket: this.object(ticket)
-      })
-    );
-  }
-  moveCall({
-    arguments: args,
-    ...input
-  }) {
-    return this.add(
-      Commands.MoveCall({
-        ...input,
-        arguments: args?.map(
-          (arg) => __privateMethod(this, _Transaction_instances, normalizeTransactionArgument_fn).call(this, arg)
-        )
-      })
-    );
-  }
-  transferObjects(objects, address) {
-    return this.add(
-      Commands.TransferObjects(
-        objects.map((obj) => this.object(obj)),
-        typeof address === "string" ? this.pure.address(address) : __privateMethod(this, _Transaction_instances, normalizeTransactionArgument_fn).call(this, address)
-      )
-    );
-  }
-  makeMoveVec({
-    type,
-    elements
-  }) {
-    return this.add(
-      Commands.MakeMoveVec({
-        type,
-        elements: elements.map((obj) => this.object(obj))
-      })
-    );
-  }
-  /**
-   * @deprecated Use toJSON instead.
-   * For synchronous serialization, you can use `getData()`
-   * */
-  serialize() {
-    return JSON.stringify(
-      serializeV1TransactionData(__privateGet(this, _data).snapshot())
-    );
-  }
-  async toJSON(options = {}) {
-    await this.prepareForSerialization(options);
-    const fullyResolved = this.isFullyResolved();
-    return JSON.stringify(
-      parse(
-        SerializedTransactionDataV2Schema,
-        fullyResolved ? {
-          ...__privateGet(this, _data).snapshot(),
-          digest: __privateGet(this, _data).getDigest()
-        } : __privateGet(this, _data).snapshot()
-      ),
-      (_key, value) => typeof value === "bigint" ? value.toString() : value,
-      2
-    );
-  }
-  /** Build the transaction to BCS bytes, and sign it with the provided keypair. */
-  async sign(options) {
-    const { signer, ...buildOptions } = options;
-    const bytes = await this.build(buildOptions);
-    return signer.signTransaction(bytes);
-  }
-  /**
-   *  Ensures that:
-   *  - All objects have been fully resolved to a specific version
-   *  - All pure inputs have been serialized to bytes
-   *  - All async thunks have been fully resolved
-   *  - All transaction intents have been resolved
-   * 	- The gas payment, budget, and price have been set
-   *  - The transaction sender has been set
-   *
-   *  When true, the transaction will always be built to the same bytes and digest (unless the transaction is mutated)
-   */
-  isFullyResolved() {
-    if (!__privateGet(this, _data).sender) {
-      return false;
-    }
-    if (__privateGet(this, _pendingPromises).size > 0) {
-      return false;
-    }
-    if (__privateGet(this, _data).commands.some((cmd) => cmd.$Intent)) {
-      return false;
-    }
-    if (needsTransactionResolution(__privateGet(this, _data), {})) {
-      return false;
-    }
-    return true;
-  }
-  /** Build the transaction to BCS bytes. */
-  async build(options = {}) {
-    await this.prepareForSerialization(options);
-    await __privateMethod(this, _Transaction_instances, prepareBuild_fn).call(this, options);
-    return __privateGet(this, _data).build({
-      onlyTransactionKind: options.onlyTransactionKind
-    });
-  }
-  /** Derive transaction digest */
-  async getDigest(options = {}) {
-    await this.prepareForSerialization(options);
-    await __privateMethod(this, _Transaction_instances, prepareBuild_fn).call(this, options);
-    return __privateGet(this, _data).getDigest();
-  }
-  async prepareForSerialization(options) {
-    await __privateMethod(this, _Transaction_instances, waitForPendingTasks_fn).call(this);
-    __privateMethod(this, _Transaction_instances, sortCommandsAndInputs_fn).call(this);
-    const intents = /* @__PURE__ */ new Set();
-    for (const command of __privateGet(this, _data).commands) {
-      if (command.$Intent) {
-        intents.add(command.$Intent.name);
-      }
-    }
-    const steps = [...__privateGet(this, _serializationPlugins)];
-    for (const intent of intents) {
-      if (options.supportedIntents?.includes(intent)) {
-        continue;
-      }
-      if (!__privateGet(this, _intentResolvers).has(intent)) {
-        throw new Error(`Missing intent resolver for ${intent}`);
-      }
-      steps.push(__privateGet(this, _intentResolvers).get(intent));
-    }
-    steps.push(namedPackagesPlugin());
-    await __privateMethod(this, _Transaction_instances, runPlugins_fn).call(this, steps, options);
-  }
-};
-_serializationPlugins = new WeakMap();
-_buildPlugins = new WeakMap();
-_intentResolvers = new WeakMap();
-_inputSection = new WeakMap();
-_commandSection = new WeakMap();
-_availableResults = new WeakMap();
-_pendingPromises = new WeakMap();
-_added = new WeakMap();
-_data = new WeakMap();
-_Transaction_instances = new WeakSet();
-fork_fn = function() {
-  const fork = new _Transaction();
-  __privateSet(fork, _data, __privateGet(this, _data));
-  __privateSet(fork, _serializationPlugins, __privateGet(this, _serializationPlugins));
-  __privateSet(fork, _buildPlugins, __privateGet(this, _buildPlugins));
-  __privateSet(fork, _intentResolvers, __privateGet(this, _intentResolvers));
-  __privateSet(fork, _pendingPromises, __privateGet(this, _pendingPromises));
-  __privateSet(fork, _availableResults, new Set(__privateGet(this, _availableResults)));
-  __privateSet(fork, _added, __privateGet(this, _added));
-  __privateGet(this, _inputSection).push(__privateGet(fork, _inputSection));
-  __privateGet(this, _commandSection).push(__privateGet(fork, _commandSection));
-  return fork;
-};
-addCommand_fn = function(command) {
-  const resultIndex = __privateGet(this, _data).commands.length;
-  __privateGet(this, _commandSection).push(command);
-  __privateGet(this, _availableResults).add(resultIndex);
-  __privateGet(this, _data).commands.push(command);
-  __privateGet(this, _data).mapCommandArguments(resultIndex, (arg) => {
-    if (arg.$kind === "Result" && !__privateGet(this, _availableResults).has(arg.Result)) {
-      throw new Error(
-        `Result { Result: ${arg.Result} } is not available to use in the current transaction`
-      );
-    }
-    if (arg.$kind === "NestedResult" && !__privateGet(this, _availableResults).has(arg.NestedResult[0])) {
-      throw new Error(
-        `Result { NestedResult: [${arg.NestedResult[0]}, ${arg.NestedResult[1]}] } is not available to use in the current transaction`
-      );
-    }
-    if (arg.$kind === "Input" && arg.Input >= __privateGet(this, _data).inputs.length) {
-      throw new Error(
-        `Input { Input: ${arg.Input} } references an input that does not exist in the current transaction`
-      );
-    }
-    return arg;
-  });
-  return command;
-};
-addInput_fn = function(type, input) {
-  __privateGet(this, _inputSection).push(input);
-  return __privateGet(this, _data).addInput(type, input);
-};
-normalizeTransactionArgument_fn = function(arg) {
-  if (isSerializedBcs(arg)) {
-    return this.pure(arg);
-  }
-  return __privateMethod(this, _Transaction_instances, resolveArgument_fn).call(this, arg);
-};
-resolveArgument_fn = function(arg) {
-  if (typeof arg === "function") {
-    const resolved = this.add(arg);
-    if (typeof resolved === "function") {
-      return __privateMethod(this, _Transaction_instances, resolveArgument_fn).call(this, resolved);
-    }
-    return parse(ArgumentSchema, resolved);
-  }
-  return parse(ArgumentSchema, arg);
-};
-prepareBuild_fn = async function(options) {
-  if (!options.onlyTransactionKind && !__privateGet(this, _data).sender) {
-    throw new Error("Missing transaction sender");
-  }
-  await __privateMethod(this, _Transaction_instances, runPlugins_fn).call(this, [...__privateGet(this, _buildPlugins), resolveTransactionPlugin], options);
-};
-runPlugins_fn = async function(plugins, options) {
-  try {
-    const createNext = (i) => {
-      if (i >= plugins.length) {
-        return () => {
-        };
-      }
-      const plugin = plugins[i];
-      return async () => {
-        const next = createNext(i + 1);
-        let calledNext = false;
-        let nextResolved = false;
-        await plugin(__privateGet(this, _data), options, async () => {
-          if (calledNext) {
-            throw new Error(
-              `next() was call multiple times in TransactionPlugin ${i}`
-            );
-          }
-          calledNext = true;
-          await next();
-          nextResolved = true;
+        return this.#resolveArgument(arg);
+    }
+    #resolveArgument(arg) {
+        if (typeof arg === "function") {
+            const resolved = this.add(arg);
+            if (typeof resolved === "function") {
+                return this.#resolveArgument(resolved);
+            }
+            return parse(ArgumentSchema, resolved);
+        }
+        return parse(ArgumentSchema, arg);
+    }
+    // Method shorthands:
+    splitCoins(coin, amounts) {
+        const command = Commands.SplitCoins(typeof coin === "string"
+            ? this.object(coin)
+            : this.#resolveArgument(coin), amounts.map((amount) => typeof amount === "number" ||
+            typeof amount === "bigint" ||
+            typeof amount === "string"
+            ? this.pure.u64(amount)
+            : this.#normalizeTransactionArgument(amount)));
+        this.#addCommand(command);
+        return createTransactionResult(this.#data.commands.length - 1, amounts.length);
+    }
+    mergeCoins(destination, sources) {
+        return this.add(Commands.MergeCoins(this.object(destination), sources.map((src) => this.object(src))));
+    }
+    publish({ modules, dependencies, }) {
+        return this.add(Commands.Publish({
+            modules,
+            dependencies,
+        }));
+    }
+    upgrade({ modules, dependencies, package: packageId, ticket, }) {
+        return this.add(Commands.Upgrade({
+            modules,
+            dependencies,
+            package: packageId,
+            ticket: this.object(ticket),
+        }));
+    }
+    moveCall({ arguments: args, ...input }) {
+        return this.add(Commands.MoveCall({
+            ...input,
+            arguments: args?.map((arg) => this.#normalizeTransactionArgument(arg)),
+        }));
+    }
+    transferObjects(objects, address) {
+        return this.add(Commands.TransferObjects(objects.map((obj) => this.object(obj)), typeof address === "string"
+            ? this.pure.address(address)
+            : this.#normalizeTransactionArgument(address)));
+    }
+    makeMoveVec({ type, elements, }) {
+        return this.add(Commands.MakeMoveVec({
+            type,
+            elements: elements.map((obj) => this.object(obj)),
+        }));
+    }
+    /**
+     * @deprecated Use toJSON instead.
+     * For synchronous serialization, you can use `getData()`
+     * */
+    serialize() {
+        return JSON.stringify(serializeV1TransactionData(this.#data.snapshot()));
+    }
+    async toJSON(options = {}) {
+        await this.prepareForSerialization(options);
+        const fullyResolved = this.isFullyResolved();
+        return JSON.stringify(parse(SerializedTransactionDataV2Schema, fullyResolved
+            ? {
+                ...this.#data.snapshot(),
+                digest: this.#data.getDigest(),
+            }
+            : this.#data.snapshot()), (_key, value) => typeof value === "bigint" ? value.toString() : value, 2);
+    }
+    /** Build the transaction to BCS bytes, and sign it with the provided keypair. */
+    async sign(options) {
+        const { signer, ...buildOptions } = options;
+        const bytes = await this.build(buildOptions);
+        return signer.signTransaction(bytes);
+    }
+    /**
+     *  Ensures that:
+     *  - All objects have been fully resolved to a specific version
+     *  - All pure inputs have been serialized to bytes
+     *  - All async thunks have been fully resolved
+     *  - All transaction intents have been resolved
+     * 	- The gas payment, budget, and price have been set
+     *  - The transaction sender has been set
+     *
+     *  When true, the transaction will always be built to the same bytes and digest (unless the transaction is mutated)
+     */
+    isFullyResolved() {
+        if (!this.#data.sender) {
+            return false;
+        }
+        if (this.#pendingPromises.size > 0) {
+            return false;
+        }
+        if (this.#data.commands.some((cmd) => cmd.$Intent)) {
+            return false;
+        }
+        if (needsTransactionResolution(this.#data, {})) {
+            return false;
+        }
+        return true;
+    }
+    /** Build the transaction to BCS bytes. */
+    async build(options = {}) {
+        await this.prepareForSerialization(options);
+        await this.#prepareBuild(options);
+        return this.#data.build({
+            onlyTransactionKind: options.onlyTransactionKind,
         });
-        if (!calledNext) {
-          throw new Error(
-            `next() was not called in TransactionPlugin ${i}`
-          );
+    }
+    /** Derive transaction digest */
+    async getDigest(options = {}) {
+        await this.prepareForSerialization(options);
+        await this.#prepareBuild(options);
+        return this.#data.getDigest();
+    }
+    /**
+     * Prepare the transaction by validating the transaction data and resolving all inputs
+     * so that it can be built into bytes.
+     */
+    async #prepareBuild(options) {
+        if (!options.onlyTransactionKind && !this.#data.sender) {
+            throw new Error("Missing transaction sender");
         }
-        if (!nextResolved) {
-          throw new Error(
-            `next() was not awaited in TransactionPlugin ${i}`
-          );
+        await this.#runPlugins([...this.#buildPlugins, resolveTransactionPlugin], options);
+    }
+    async #runPlugins(plugins, options) {
+        try {
+            const createNext = (i) => {
+                if (i >= plugins.length) {
+                    return () => { };
+                }
+                const plugin = plugins[i];
+                return async () => {
+                    const next = createNext(i + 1);
+                    let calledNext = false;
+                    let nextResolved = false;
+                    await plugin(this.#data, options, async () => {
+                        if (calledNext) {
+                            throw new Error(`next() was call multiple times in TransactionPlugin ${i}`);
+                        }
+                        calledNext = true;
+                        await next();
+                        nextResolved = true;
+                    });
+                    if (!calledNext) {
+                        throw new Error(`next() was not called in TransactionPlugin ${i}`);
+                    }
+                    if (!nextResolved) {
+                        throw new Error(`next() was not awaited in TransactionPlugin ${i}`);
+                    }
+                };
+            };
+            await createNext(0)();
         }
-      };
-    };
-    await createNext(0)();
-  } finally {
-    __privateSet(this, _inputSection, __privateGet(this, _data).inputs.slice());
-    __privateSet(this, _commandSection, __privateGet(this, _data).commands.slice());
-    __privateSet(this, _availableResults, new Set(
-      __privateGet(this, _commandSection).map((_, i) => i)
-    ));
-  }
-};
-waitForPendingTasks_fn = async function() {
-  while (__privateGet(this, _pendingPromises).size > 0) {
-    const newPromise = Promise.all(__privateGet(this, _pendingPromises));
-    __privateGet(this, _pendingPromises).clear();
-    __privateGet(this, _pendingPromises).add(newPromise);
-    await newPromise;
-    __privateGet(this, _pendingPromises).delete(newPromise);
-  }
-};
-sortCommandsAndInputs_fn = function() {
-  const unorderedCommands = __privateGet(this, _data).commands;
-  const unorderedInputs = __privateGet(this, _data).inputs;
-  const orderedCommands = __privateGet(this, _commandSection).flat(
-    Infinity
-  );
-  const orderedInputs = __privateGet(this, _inputSection).flat(Infinity);
-  if (orderedCommands.length !== unorderedCommands.length) {
-    throw new Error(
-      "Unexpected number of commands found in transaction data"
-    );
-  }
-  if (orderedInputs.length !== unorderedInputs.length) {
-    throw new Error(
-      "Unexpected number of inputs found in transaction data"
-    );
-  }
-  const filteredCommands = orderedCommands.filter(
-    (cmd) => cmd.$Intent?.name !== "AsyncTransactionThunk"
-  );
-  __privateGet(this, _data).commands = filteredCommands;
-  __privateGet(this, _data).inputs = orderedInputs;
-  __privateSet(this, _commandSection, filteredCommands);
-  __privateSet(this, _inputSection, orderedInputs);
-  __privateSet(this, _availableResults, new Set(filteredCommands.map((_, i) => i)));
-  function getOriginalIndex(index) {
-    const command = unorderedCommands[index];
-    if (command.$Intent?.name === "AsyncTransactionThunk") {
-      const result = command.$Intent.data.result;
-      if (result == null) {
-        throw new Error(
-          "AsyncTransactionThunk has not been resolved"
-        );
-      }
-      return getOriginalIndex(result.Result);
-    }
-    const updated = filteredCommands.indexOf(command);
-    if (updated === -1) {
-      throw new Error("Unable to find original index for command");
-    }
-    return updated;
-  }
-  __privateGet(this, _data).mapArguments((arg) => {
-    if (arg.$kind === "Input") {
-      const updated = orderedInputs.indexOf(
-        unorderedInputs[arg.Input]
-      );
-      if (updated === -1) {
-        throw new Error("Input has not been resolved");
-      }
-      return { ...arg, Input: updated };
-    } else if (arg.$kind === "Result") {
-      const updated = getOriginalIndex(arg.Result);
-      return { ...arg, Result: updated };
-    } else if (arg.$kind === "NestedResult") {
-      const updated = getOriginalIndex(arg.NestedResult[0]);
-      return { ...arg, NestedResult: [updated, arg.NestedResult[1]] };
-    }
-    return arg;
-  });
-  for (const [i, cmd] of unorderedCommands.entries()) {
-    if (cmd.$Intent?.name === "AsyncTransactionThunk") {
-      try {
-        cmd.$Intent.data.resultIndex = getOriginalIndex(i);
-      } catch {
-      }
-    }
-  }
-};
-let Transaction = _Transaction;
-export {
-  Transaction,
-  isTransaction
-};
+        finally {
+            this.#inputSection = this.#data.inputs.slice();
+            this.#commandSection = this.#data.commands.slice();
+            this.#availableResults = new Set(this.#commandSection.map((_, i) => i));
+        }
+    }
+    async #waitForPendingTasks() {
+        while (this.#pendingPromises.size > 0) {
+            const newPromise = Promise.all(this.#pendingPromises);
+            this.#pendingPromises.clear();
+            this.#pendingPromises.add(newPromise);
+            await newPromise;
+            this.#pendingPromises.delete(newPromise);
+        }
+    }
+    #sortCommandsAndInputs() {
+        const unorderedCommands = this.#data.commands;
+        const unorderedInputs = this.#data.inputs;
+        const orderedCommands = this.#commandSection.flat(Infinity);
+        const orderedInputs = this.#inputSection.flat(Infinity);
+        if (orderedCommands.length !== unorderedCommands.length) {
+            throw new Error("Unexpected number of commands found in transaction data");
+        }
+        if (orderedInputs.length !== unorderedInputs.length) {
+            throw new Error("Unexpected number of inputs found in transaction data");
+        }
+        const filteredCommands = orderedCommands.filter((cmd) => cmd.$Intent?.name !== "AsyncTransactionThunk");
+        this.#data.commands = filteredCommands;
+        this.#data.inputs = orderedInputs;
+        this.#commandSection = filteredCommands;
+        this.#inputSection = orderedInputs;
+        this.#availableResults = new Set(filteredCommands.map((_, i) => i));
+        function getOriginalIndex(index) {
+            const command = unorderedCommands[index];
+            if (command.$Intent?.name === "AsyncTransactionThunk") {
+                const result = command.$Intent.data
+                    .result;
+                if (result == null) {
+                    throw new Error("AsyncTransactionThunk has not been resolved");
+                }
+                return getOriginalIndex(result.Result);
+            }
+            const updated = filteredCommands.indexOf(command);
+            if (updated === -1) {
+                throw new Error("Unable to find original index for command");
+            }
+            return updated;
+        }
+        this.#data.mapArguments((arg) => {
+            if (arg.$kind === "Input") {
+                const updated = orderedInputs.indexOf(unorderedInputs[arg.Input]);
+                if (updated === -1) {
+                    throw new Error("Input has not been resolved");
+                }
+                return { ...arg, Input: updated };
+            }
+            else if (arg.$kind === "Result") {
+                const updated = getOriginalIndex(arg.Result);
+                return { ...arg, Result: updated };
+            }
+            else if (arg.$kind === "NestedResult") {
+                const updated = getOriginalIndex(arg.NestedResult[0]);
+                return { ...arg, NestedResult: [updated, arg.NestedResult[1]] };
+            }
+            return arg;
+        });
+        for (const [i, cmd] of unorderedCommands.entries()) {
+            if (cmd.$Intent?.name === "AsyncTransactionThunk") {
+                try {
+                    cmd.$Intent.data.resultIndex = getOriginalIndex(i);
+                }
+                catch {
+                    // If async thunk did not return a result, this will error, but is safe to ignore
+                }
+            }
+        }
+    }
+    async prepareForSerialization(options) {
+        await this.#waitForPendingTasks();
+        this.#sortCommandsAndInputs();
+        const intents = new Set();
+        for (const command of this.#data.commands) {
+            if (command.$Intent) {
+                intents.add(command.$Intent.name);
+            }
+        }
+        const steps = [...this.#serializationPlugins];
+        for (const intent of intents) {
+            if (options.supportedIntents?.includes(intent)) {
+                continue;
+            }
+            if (!this.#intentResolvers.has(intent)) {
+                throw new Error(`Missing intent resolver for ${intent}`);
+            }
+            steps.push(this.#intentResolvers.get(intent));
+        }
+        steps.push(namedPackagesPlugin());
+        await this.#runPlugins(steps, options);
+    }
+}
+_a = Transaction;
+//# sourceMappingURL=Transaction.js.map