@t2000/cli 5.6.0 → 5.6.1

package/dist/{chunk-ITIKLNK5.js → chunk-TP3M7BAU.js}

@@ -38,7 +38,6 @@ import {
   parse,
   picklist,
   pipe,
-  promiseWithResolvers,
   pureBcsSchemaFromTypeName,
   record,
   replaceNames,
@@ -48,7 +47,7 @@ import {
   tuple,
   union,
   unknown
-} from "./chunk-MPXYF2CX.js";
+} from "./chunk-X6ON6NN5.js";
 import {
   fromBase58,
   fromBase64,
@@ -63,12 +62,6 @@ import {
 } from "./chunk-I2DCISQP.js";
 
 // ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/Commands.mjs
-var UpgradePolicy = /* @__PURE__ */ (function(UpgradePolicy$1) {
-  UpgradePolicy$1[UpgradePolicy$1["COMPATIBLE"] = 0] = "COMPATIBLE";
-  UpgradePolicy$1[UpgradePolicy$1["ADDITIVE"] = 128] = "ADDITIVE";
-  UpgradePolicy$1[UpgradePolicy$1["DEP_ONLY"] = 192] = "DEP_ONLY";
-  return UpgradePolicy$1;
-})({});
 var TransactionCommands = {
   MoveCall(input) {
     const [pkg, mod = "", fn = ""] = "target" in input ? input.target.split("::") : [
@@ -215,121 +208,6 @@ var Inputs = {
   }
 };
 
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/serializer.mjs
-function parseTypeName(typeName) {
-  const parts = typeName.split("::");
-  if (parts.length !== 3) throw new Error(`Invalid type name format: ${typeName}`);
-  return {
-    package: parts[0],
-    module: parts[1],
-    name: parts[2]
-  };
-}
-function isTxContext(param) {
-  if (param.body.$kind !== "datatype") return false;
-  const { package: pkg, module, name } = parseTypeName(param.body.datatype.typeName);
-  return normalizeSuiAddress(pkg) === SUI_FRAMEWORK_ADDRESS && module === "tx_context" && name === "TxContext";
-}
-function getPureBcsSchema(typeSignature) {
-  switch (typeSignature.$kind) {
-    case "address":
-      return suiBcs.Address;
-    case "bool":
-      return suiBcs.Bool;
-    case "u8":
-      return suiBcs.U8;
-    case "u16":
-      return suiBcs.U16;
-    case "u32":
-      return suiBcs.U32;
-    case "u64":
-      return suiBcs.U64;
-    case "u128":
-      return suiBcs.U128;
-    case "u256":
-      return suiBcs.U256;
-    case "vector": {
-      if (typeSignature.vector.$kind === "u8") return suiBcs.byteVector().transform({
-        input: (val) => typeof val === "string" ? new TextEncoder().encode(val) : val,
-        output: (val) => val
-      });
-      const type = getPureBcsSchema(typeSignature.vector);
-      return type ? suiBcs.vector(type) : null;
-    }
-    case "datatype": {
-      const { package: pkg, module, name } = parseTypeName(typeSignature.datatype.typeName);
-      const normalizedPkg = normalizeSuiAddress(pkg);
-      if (normalizedPkg === MOVE_STDLIB_ADDRESS) {
-        if (module === "ascii" && name === "String") return suiBcs.String;
-        if (module === "string" && name === "String") return suiBcs.String;
-        if (module === "option" && name === "Option") {
-          const type = getPureBcsSchema(typeSignature.datatype.typeParameters[0]);
-          return type ? suiBcs.vector(type) : null;
-        }
-      }
-      if (normalizedPkg === SUI_FRAMEWORK_ADDRESS) {
-        if (module === "object" && name === "ID") return suiBcs.Address;
-      }
-      return null;
-    }
-    case "typeParameter":
-    case "unknown":
-      return null;
-  }
-}
-function normalizedTypeToMoveTypeSignature(type) {
-  if (typeof type === "object" && "Reference" in type) return {
-    reference: "immutable",
-    body: normalizedTypeToMoveTypeSignatureBody(type.Reference)
-  };
-  if (typeof type === "object" && "MutableReference" in type) return {
-    reference: "mutable",
-    body: normalizedTypeToMoveTypeSignatureBody(type.MutableReference)
-  };
-  return {
-    reference: null,
-    body: normalizedTypeToMoveTypeSignatureBody(type)
-  };
-}
-function normalizedTypeToMoveTypeSignatureBody(type) {
-  if (typeof type === "string") switch (type) {
-    case "Address":
-      return { $kind: "address" };
-    case "Bool":
-      return { $kind: "bool" };
-    case "U8":
-      return { $kind: "u8" };
-    case "U16":
-      return { $kind: "u16" };
-    case "U32":
-      return { $kind: "u32" };
-    case "U64":
-      return { $kind: "u64" };
-    case "U128":
-      return { $kind: "u128" };
-    case "U256":
-      return { $kind: "u256" };
-    default:
-      throw new Error(`Unexpected type ${type}`);
-  }
-  if ("Vector" in type) return {
-    $kind: "vector",
-    vector: normalizedTypeToMoveTypeSignatureBody(type.Vector)
-  };
-  if ("Struct" in type) return {
-    $kind: "datatype",
-    datatype: {
-      typeName: `${type.Struct.address}::${type.Struct.module}::${type.Struct.name}`,
-      typeParameters: type.Struct.typeArguments.map(normalizedTypeToMoveTypeSignatureBody)
-    }
-  };
-  if ("TypeParameter" in type) return {
-    $kind: "typeParameter",
-    index: type.TypeParameter
-  };
-  throw new Error(`Unexpected type ${JSON.stringify(type)}`);
-}
-
 // ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/intents/CoinWithBalance.mjs
 var COIN_WITH_BALANCE = "CoinWithBalance";
 var SUI_TYPE = normalizeStructTag("0x2::sui::SUI");
@@ -763,6 +641,69 @@ function createCoinReservationRef(reservedBalance, owner, chainIdentifier, epoch
   });
 }
 
+// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/serializer.mjs
+function parseTypeName(typeName) {
+  const parts = typeName.split("::");
+  if (parts.length !== 3) throw new Error(`Invalid type name format: ${typeName}`);
+  return {
+    package: parts[0],
+    module: parts[1],
+    name: parts[2]
+  };
+}
+function isTxContext(param) {
+  if (param.body.$kind !== "datatype") return false;
+  const { package: pkg, module, name } = parseTypeName(param.body.datatype.typeName);
+  return normalizeSuiAddress(pkg) === SUI_FRAMEWORK_ADDRESS && module === "tx_context" && name === "TxContext";
+}
+function getPureBcsSchema(typeSignature) {
+  switch (typeSignature.$kind) {
+    case "address":
+      return suiBcs.Address;
+    case "bool":
+      return suiBcs.Bool;
+    case "u8":
+      return suiBcs.U8;
+    case "u16":
+      return suiBcs.U16;
+    case "u32":
+      return suiBcs.U32;
+    case "u64":
+      return suiBcs.U64;
+    case "u128":
+      return suiBcs.U128;
+    case "u256":
+      return suiBcs.U256;
+    case "vector": {
+      if (typeSignature.vector.$kind === "u8") return suiBcs.byteVector().transform({
+        input: (val) => typeof val === "string" ? new TextEncoder().encode(val) : val,
+        output: (val) => val
+      });
+      const type = getPureBcsSchema(typeSignature.vector);
+      return type ? suiBcs.vector(type) : null;
+    }
+    case "datatype": {
+      const { package: pkg, module, name } = parseTypeName(typeSignature.datatype.typeName);
+      const normalizedPkg = normalizeSuiAddress(pkg);
+      if (normalizedPkg === MOVE_STDLIB_ADDRESS) {
+        if (module === "ascii" && name === "String") return suiBcs.String;
+        if (module === "string" && name === "String") return suiBcs.String;
+        if (module === "option" && name === "Option") {
+          const type = getPureBcsSchema(typeSignature.datatype.typeParameters[0]);
+          return type ? suiBcs.vector(type) : null;
+        }
+      }
+      if (normalizedPkg === SUI_FRAMEWORK_ADDRESS) {
+        if (module === "object" && name === "ID") return suiBcs.Address;
+      }
+      return null;
+    }
+    case "typeParameter":
+    case "unknown":
+      return null;
+  }
+}
+
 // ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/client/core-resolver.mjs
 var MAX_OBJECTS_PER_FETCH = 50;
 var GAS_SAFE_OVERHEAD = 1000n;
@@ -1690,719 +1631,8 @@ var Transaction = class Transaction2 {
   }
 };
 
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/ObjectCache.mjs
-var AsyncCache = class {
-  async getObject(id) {
-    const [owned, shared] = await Promise.all([this.get("OwnedObject", id), this.get("SharedOrImmutableObject", id)]);
-    return owned ?? shared ?? null;
-  }
-  async getObjects(ids) {
-    return Promise.all(ids.map((id) => this.getObject(id)));
-  }
-  async addObject(object2) {
-    if (object2.owner) await this.set("OwnedObject", object2.objectId, object2);
-    else await this.set("SharedOrImmutableObject", object2.objectId, object2);
-    return object2;
-  }
-  async addObjects(objects) {
-    await Promise.all(objects.map(async (object2) => this.addObject(object2)));
-  }
-  async deleteObject(id) {
-    await Promise.all([this.delete("OwnedObject", id), this.delete("SharedOrImmutableObject", id)]);
-  }
-  async deleteObjects(ids) {
-    await Promise.all(ids.map((id) => this.deleteObject(id)));
-  }
-  async getMoveFunctionDefinition(ref) {
-    const functionName = `${normalizeSuiAddress(ref.package)}::${ref.module}::${ref.function}`;
-    return this.get("MoveFunction", functionName);
-  }
-  async addMoveFunctionDefinition(functionEntry) {
-    const pkg = normalizeSuiAddress(functionEntry.package);
-    const functionName = `${pkg}::${functionEntry.module}::${functionEntry.function}`;
-    const entry = {
-      ...functionEntry,
-      package: pkg
-    };
-    await this.set("MoveFunction", functionName, entry);
-    return entry;
-  }
-  async deleteMoveFunctionDefinition(ref) {
-    const functionName = `${normalizeSuiAddress(ref.package)}::${ref.module}::${ref.function}`;
-    await this.delete("MoveFunction", functionName);
-  }
-  async getCustom(key) {
-    return this.get("Custom", key);
-  }
-  async setCustom(key, value) {
-    return this.set("Custom", key, value);
-  }
-  async deleteCustom(key) {
-    return this.delete("Custom", key);
-  }
-};
-var InMemoryCache = class extends AsyncCache {
-  #caches = {
-    OwnedObject: /* @__PURE__ */ new Map(),
-    SharedOrImmutableObject: /* @__PURE__ */ new Map(),
-    MoveFunction: /* @__PURE__ */ new Map(),
-    Custom: /* @__PURE__ */ new Map()
-  };
-  async get(type, key) {
-    return this.#caches[type].get(key) ?? null;
-  }
-  async set(type, key, value) {
-    this.#caches[type].set(key, value);
-  }
-  async delete(type, key) {
-    this.#caches[type].delete(key);
-  }
-  async clear(type) {
-    if (type) this.#caches[type].clear();
-    else for (const cache of Object.values(this.#caches)) cache.clear();
-  }
-};
-var ObjectCache = class {
-  #cache;
-  #onEffects;
-  constructor({ cache = new InMemoryCache(), onEffects }) {
-    this.#cache = cache;
-    this.#onEffects = onEffects;
-  }
-  asPlugin() {
-    return async (transactionData, _options, next) => {
-      const unresolvedObjects = transactionData.inputs.filter((input) => input.UnresolvedObject).map((input) => input.UnresolvedObject.objectId);
-      const cached = (await this.#cache.getObjects(unresolvedObjects)).filter((obj) => obj !== null);
-      const byId = new Map(cached.map((obj) => [obj.objectId, obj]));
-      for (const input of transactionData.inputs) {
-        if (!input.UnresolvedObject) continue;
-        const cached$1 = byId.get(input.UnresolvedObject.objectId);
-        if (!cached$1) continue;
-        if (cached$1.initialSharedVersion && !input.UnresolvedObject.initialSharedVersion) input.UnresolvedObject.initialSharedVersion = cached$1.initialSharedVersion;
-        else {
-          if (cached$1.version && !input.UnresolvedObject.version) input.UnresolvedObject.version = cached$1.version;
-          if (cached$1.digest && !input.UnresolvedObject.digest) input.UnresolvedObject.digest = cached$1.digest;
-        }
-      }
-      await Promise.all(transactionData.commands.map(async (commands) => {
-        if (commands.MoveCall) {
-          const def = await this.getMoveFunctionDefinition({
-            package: commands.MoveCall.package,
-            module: commands.MoveCall.module,
-            function: commands.MoveCall.function
-          });
-          if (def) commands.MoveCall._argumentTypes = def.parameters;
-        }
-      }));
-      await next();
-      await Promise.all(transactionData.commands.map(async (commands) => {
-        if (commands.MoveCall?._argumentTypes) await this.#cache.addMoveFunctionDefinition({
-          package: commands.MoveCall.package,
-          module: commands.MoveCall.module,
-          function: commands.MoveCall.function,
-          parameters: commands.MoveCall._argumentTypes
-        });
-      }));
-    };
-  }
-  async clear() {
-    await this.#cache.clear();
-  }
-  async getMoveFunctionDefinition(ref) {
-    return this.#cache.getMoveFunctionDefinition(ref);
-  }
-  async getObjects(ids) {
-    return this.#cache.getObjects(ids);
-  }
-  async deleteObjects(ids) {
-    return this.#cache.deleteObjects(ids);
-  }
-  async clearOwnedObjects() {
-    await this.#cache.clear("OwnedObject");
-  }
-  async clearCustom() {
-    await this.#cache.clear("Custom");
-  }
-  async getCustom(key) {
-    return this.#cache.getCustom(key);
-  }
-  async setCustom(key, value) {
-    return this.#cache.setCustom(key, value);
-  }
-  async deleteCustom(key) {
-    return this.#cache.deleteCustom(key);
-  }
-  async applyEffects(effects) {
-    if (!effects.V2) throw new Error(`Unsupported transaction effects version ${effects.$kind}`);
-    const { lamportVersion, changedObjects } = effects.V2;
-    const deletedIds = [];
-    const addedObjects = [];
-    changedObjects.forEach(([id, change]) => {
-      if (change.outputState.NotExist) deletedIds.push(id);
-      else if (change.outputState.ObjectWrite) {
-        const [digest, owner] = change.outputState.ObjectWrite;
-        addedObjects.push({
-          objectId: id,
-          digest,
-          version: lamportVersion,
-          owner: owner.AddressOwner ?? owner.ObjectOwner ?? null,
-          initialSharedVersion: owner.Shared?.initialSharedVersion ?? null
-        });
-      }
-    });
-    await Promise.all([
-      this.#cache.addObjects(addedObjects),
-      this.#cache.deleteObjects(deletedIds),
-      this.#onEffects?.(effects)
-    ]);
-  }
-};
-
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/executor/caching.mjs
-var CachingTransactionExecutor = class {
-  #client;
-  #lastDigest = null;
-  constructor({ client, ...options }) {
-    this.#client = client;
-    this.cache = new ObjectCache(options);
-  }
-  /**
-  * Clears all Owned objects
-  * Immutable objects, Shared objects, and Move function definitions will be preserved
-  */
-  async reset() {
-    await Promise.all([
-      this.cache.clearOwnedObjects(),
-      this.cache.clearCustom(),
-      this.waitForLastTransaction()
-    ]);
-  }
-  async buildTransaction({ transaction, ...options }) {
-    transaction.addBuildPlugin(this.cache.asPlugin());
-    transaction.addBuildPlugin(coreClientResolveTransactionPlugin);
-    return transaction.build({
-      client: this.#client,
-      ...options
-    });
-  }
-  async executeTransaction({ transaction, signatures, include }) {
-    const bytes = isTransaction(transaction) ? await this.buildTransaction({ transaction }) : transaction;
-    const results = await this.#client.core.executeTransaction({
-      transaction: bytes,
-      signatures,
-      include: {
-        ...include,
-        effects: true
-      }
-    });
-    const tx = results.$kind === "Transaction" ? results.Transaction : results.FailedTransaction;
-    if (tx.effects?.bcs) {
-      const effects = suiBcs.TransactionEffects.parse(tx.effects.bcs);
-      await this.applyEffects(effects);
-    }
-    return results;
-  }
-  async signAndExecuteTransaction({ include, transaction, signer }) {
-    transaction.setSenderIfNotSet(signer.toSuiAddress());
-    const bytes = await this.buildTransaction({ transaction });
-    const { signature } = await signer.signTransaction(bytes);
-    return this.executeTransaction({
-      transaction: bytes,
-      signatures: [signature],
-      include
-    });
-  }
-  async applyEffects(effects) {
-    this.#lastDigest = effects.V2?.transactionDigest ?? null;
-    await this.cache.applyEffects(effects);
-  }
-  async waitForLastTransaction() {
-    if (this.#lastDigest) {
-      await this.#client.core.waitForTransaction({ digest: this.#lastDigest });
-      this.#lastDigest = null;
-    }
-  }
-};
-
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/executor/queue.mjs
-var SerialQueue = class {
-  #queue = [];
-  async runTask(task) {
-    return new Promise((resolve, reject) => {
-      this.#queue.push(() => {
-        task().finally(() => {
-          this.#queue.shift();
-          if (this.#queue.length > 0) this.#queue[0]();
-        }).then(resolve, reject);
-      });
-      if (this.#queue.length === 1) this.#queue[0]();
-    });
-  }
-};
-var ParallelQueue = class {
-  #queue = [];
-  constructor(maxTasks) {
-    this.activeTasks = 0;
-    this.maxTasks = maxTasks;
-  }
-  runTask(task) {
-    return new Promise((resolve, reject) => {
-      if (this.activeTasks < this.maxTasks) {
-        this.activeTasks++;
-        task().finally(() => {
-          if (this.#queue.length > 0) this.#queue.shift()();
-          else this.activeTasks--;
-        }).then(resolve, reject);
-      } else this.#queue.push(() => {
-        task().finally(() => {
-          if (this.#queue.length > 0) this.#queue.shift()();
-          else this.activeTasks--;
-        }).then(resolve, reject);
-      });
-    });
-  }
-};
-
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/executor/serial.mjs
-var EPOCH_BOUNDARY_WINDOW = 6e4;
-var SerialTransactionExecutor = class {
-  #queue = new SerialQueue();
-  #signer;
-  #client;
-  #cache;
-  #defaultGasBudget;
-  #gasMode;
-  #epochInfo = null;
-  #epochInfoPromise = null;
-  constructor(options) {
-    const { signer, defaultGasBudget = 50000000n, client, cache } = options;
-    this.#signer = signer;
-    this.#client = client;
-    this.#defaultGasBudget = defaultGasBudget;
-    this.#gasMode = options.gasMode ?? "coins";
-    this.#cache = new CachingTransactionExecutor({
-      client,
-      cache,
-      onEffects: (effects) => this.#cacheGasCoin(effects)
-    });
-  }
-  async applyEffects(effects) {
-    return this.#cache.applyEffects(effects);
-  }
-  #cacheGasCoin = async (effects) => {
-    if (this.#gasMode === "addressBalance" || !effects.V2) return;
-    const gasCoin = getGasCoinFromEffects(effects).ref;
-    if (gasCoin) this.#cache.cache.setCustom("gasCoin", gasCoin);
-    else this.#cache.cache.deleteCustom("gasCoin");
-  };
-  async buildTransaction(transaction) {
-    return this.#queue.runTask(() => this.#buildTransaction(transaction));
-  }
-  #buildTransaction = async (transaction) => {
-    await transaction.prepareForSerialization({
-      client: this.#client,
-      supportedIntents: ["CoinWithBalance"]
-    });
-    const copy = Transaction.from(transaction);
-    if (this.#gasMode === "addressBalance") {
-      copy.setGasPayment([]);
-      copy.setExpiration(await this.#getValidDuringExpiration());
-    } else {
-      const gasCoin = await this.#cache.cache.getCustom("gasCoin");
-      if (gasCoin) copy.setGasPayment([gasCoin]);
-    }
-    copy.setGasBudgetIfNotSet(this.#defaultGasBudget);
-    copy.setSenderIfNotSet(this.#signer.toSuiAddress());
-    return this.#cache.buildTransaction({ transaction: copy });
-  };
-  async #getValidDuringExpiration() {
-    await this.#ensureEpochInfo();
-    const currentEpoch = BigInt(this.#epochInfo.epoch);
-    return { ValidDuring: {
-      minEpoch: String(currentEpoch),
-      maxEpoch: String(currentEpoch + 1n),
-      minTimestamp: null,
-      maxTimestamp: null,
-      chain: this.#epochInfo.chainIdentifier,
-      nonce: Math.random() * 4294967296 >>> 0
-    } };
-  }
-  async #ensureEpochInfo() {
-    if (this.#epochInfo && this.#epochInfo.expiration - EPOCH_BOUNDARY_WINDOW - Date.now() > 0) return;
-    if (this.#epochInfoPromise) {
-      await this.#epochInfoPromise;
-      return;
-    }
-    this.#epochInfoPromise = this.#fetchEpochInfo();
-    try {
-      await this.#epochInfoPromise;
-    } finally {
-      this.#epochInfoPromise = null;
-    }
-  }
-  async #fetchEpochInfo() {
-    const [{ systemState }, { chainIdentifier }] = await Promise.all([this.#client.core.getCurrentSystemState(), this.#client.core.getChainIdentifier()]);
-    this.#epochInfo = {
-      epoch: systemState.epoch,
-      expiration: Number(systemState.epochStartTimestampMs) + Number(systemState.parameters.epochDurationMs),
-      chainIdentifier
-    };
-  }
-  resetCache() {
-    return this.#cache.reset();
-  }
-  waitForLastTransaction() {
-    return this.#cache.waitForLastTransaction();
-  }
-  executeTransaction(transaction, include, additionalSignatures = []) {
-    return this.#queue.runTask(async () => {
-      const bytes = isTransaction(transaction) ? await this.#buildTransaction(transaction) : transaction;
-      const { signature } = await this.#signer.signTransaction(bytes);
-      return this.#cache.executeTransaction({
-        signatures: [signature, ...additionalSignatures],
-        transaction: bytes,
-        include
-      }).catch(async (error) => {
-        await this.resetCache();
-        throw error;
-      });
-    });
-  }
-};
-function getGasCoinFromEffects(effects) {
-  if (!effects.V2) throw new Error("Unexpected effects version");
-  const gasObjectChange = effects.V2.changedObjects[effects.V2.gasObjectIndex];
-  if (!gasObjectChange) throw new Error("Gas object not found in effects");
-  const [objectId, { outputState }] = gasObjectChange;
-  if (!outputState.ObjectWrite) throw new Error("Unexpected gas object state");
-  const [digest, owner] = outputState.ObjectWrite;
-  return {
-    ref: {
-      objectId,
-      digest,
-      version: effects.V2.lamportVersion
-    },
-    owner: owner.AddressOwner || owner.ObjectOwner
-  };
-}
-
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/executor/parallel.mjs
-var PARALLEL_EXECUTOR_DEFAULTS = {
-  coinBatchSize: 20,
-  initialCoinBalance: 200000000n,
-  minimumCoinBalance: 50000000n,
-  maxPoolSize: 50
-};
-var EPOCH_BOUNDARY_WINDOW2 = 6e4;
-var ParallelTransactionExecutor = class {
-  #signer;
-  #client;
-  #gasMode;
-  #coinBatchSize;
-  #initialCoinBalance;
-  #minimumCoinBalance;
-  #defaultGasBudget;
-  #maxPoolSize;
-  #sourceCoins;
-  #coinPool = [];
-  #cache;
-  #objectIdQueues = /* @__PURE__ */ new Map();
-  #buildQueue = new SerialQueue();
-  #executeQueue;
-  #lastDigest = null;
-  #cacheLock = null;
-  #pendingTransactions = 0;
-  #epochInfo = null;
-  #epochInfoPromise = null;
-  constructor(options) {
-    this.#signer = options.signer;
-    this.#client = options.client;
-    this.#gasMode = options.gasMode ?? "coins";
-    if (this.#gasMode === "coins") {
-      const coinOptions = options;
-      this.#coinBatchSize = coinOptions.coinBatchSize ?? PARALLEL_EXECUTOR_DEFAULTS.coinBatchSize;
-      this.#initialCoinBalance = coinOptions.initialCoinBalance ?? PARALLEL_EXECUTOR_DEFAULTS.initialCoinBalance;
-      this.#minimumCoinBalance = coinOptions.minimumCoinBalance ?? PARALLEL_EXECUTOR_DEFAULTS.minimumCoinBalance;
-      this.#sourceCoins = coinOptions.sourceCoins ? new Map(coinOptions.sourceCoins.map((id) => [id, null])) : null;
-    } else {
-      this.#coinBatchSize = 0;
-      this.#initialCoinBalance = 0n;
-      this.#minimumCoinBalance = PARALLEL_EXECUTOR_DEFAULTS.minimumCoinBalance;
-      this.#sourceCoins = null;
-    }
-    this.#defaultGasBudget = options.defaultGasBudget ?? this.#minimumCoinBalance;
-    this.#maxPoolSize = options.maxPoolSize ?? PARALLEL_EXECUTOR_DEFAULTS.maxPoolSize;
-    this.#cache = new CachingTransactionExecutor({
-      client: options.client,
-      cache: options.cache
-    });
-    this.#executeQueue = new ParallelQueue(this.#maxPoolSize);
-  }
-  resetCache() {
-    this.#epochInfo = null;
-    return this.#updateCache(() => this.#cache.reset());
-  }
-  async waitForLastTransaction() {
-    await this.#updateCache(() => this.#waitForLastDigest());
-  }
-  async executeTransaction(transaction, include, additionalSignatures = []) {
-    const { promise, resolve, reject } = promiseWithResolvers();
-    const usedObjects = await this.#getUsedObjects(transaction);
-    const execute = () => {
-      this.#executeQueue.runTask(() => {
-        return this.#execute(transaction, usedObjects, include, additionalSignatures).then(resolve, reject);
-      });
-    };
-    const conflicts = /* @__PURE__ */ new Set();
-    usedObjects.forEach((objectId) => {
-      if (this.#objectIdQueues.get(objectId)) {
-        conflicts.add(objectId);
-        this.#objectIdQueues.get(objectId).push(() => {
-          conflicts.delete(objectId);
-          if (conflicts.size === 0) execute();
-        });
-      } else this.#objectIdQueues.set(objectId, []);
-    });
-    if (conflicts.size === 0) execute();
-    return promise;
-  }
-  async #getUsedObjects(transaction) {
-    const usedObjects = /* @__PURE__ */ new Set();
-    let serialized = false;
-    transaction.addSerializationPlugin(async (blockData, _options, next) => {
-      await next();
-      if (serialized) return;
-      serialized = true;
-      blockData.inputs.forEach((input) => {
-        if (input.Object?.ImmOrOwnedObject?.objectId) usedObjects.add(input.Object.ImmOrOwnedObject.objectId);
-        else if (input.Object?.Receiving?.objectId) usedObjects.add(input.Object.Receiving.objectId);
-        else if (input.UnresolvedObject?.objectId && !input.UnresolvedObject.initialSharedVersion) usedObjects.add(input.UnresolvedObject.objectId);
-      });
-    });
-    await transaction.prepareForSerialization({ client: this.#client });
-    return usedObjects;
-  }
-  async #execute(transaction, usedObjects, include, additionalSignatures = []) {
-    let gasCoin = null;
-    try {
-      transaction.setSenderIfNotSet(this.#signer.toSuiAddress());
-      await this.#buildQueue.runTask(async () => {
-        if (!transaction.getData().gasData.price) transaction.setGasPrice(await this.#getGasPrice());
-        transaction.setGasBudgetIfNotSet(this.#defaultGasBudget);
-        await this.#updateCache();
-        this.#pendingTransactions++;
-        if (this.#gasMode === "addressBalance") {
-          transaction.setGasPayment([]);
-          transaction.setExpiration(await this.#getValidDuringExpiration());
-        } else {
-          gasCoin = await this.#getGasCoin();
-          transaction.setGasPayment([{
-            objectId: gasCoin.id,
-            version: gasCoin.version,
-            digest: gasCoin.digest
-          }]);
-        }
-        await this.#cache.buildTransaction({
-          transaction,
-          onlyTransactionKind: true
-        });
-      });
-      const bytes = await transaction.build({ client: this.#client });
-      const { signature } = await this.#signer.signTransaction(bytes);
-      const results = await this.#cache.executeTransaction({
-        transaction: bytes,
-        signatures: [signature, ...additionalSignatures],
-        include
-      });
-      const tx = results.$kind === "Transaction" ? results.Transaction : results.FailedTransaction;
-      const effects = tx.effects;
-      const gasObject = effects.gasObject;
-      const gasUsed = effects.gasUsed;
-      if (gasCoin && gasUsed && gasObject) {
-        const coin = gasCoin;
-        if ((gasObject.outputOwner?.AddressOwner ?? gasObject.outputOwner?.ObjectOwner) === this.#signer.toSuiAddress()) {
-          const totalUsed = BigInt(gasUsed.computationCost) + BigInt(gasUsed.storageCost) - BigInt(gasUsed.storageRebate);
-          const remainingBalance = coin.balance - totalUsed;
-          let usesGasCoin = false;
-          new TransactionDataBuilder(transaction.getData()).mapArguments((arg) => {
-            if (arg.$kind === "GasCoin") usesGasCoin = true;
-            return arg;
-          });
-          const gasRef = {
-            objectId: gasObject.objectId,
-            version: gasObject.outputVersion,
-            digest: gasObject.outputDigest
-          };
-          if (!usesGasCoin && remainingBalance >= this.#minimumCoinBalance) this.#coinPool.push({
-            id: gasRef.objectId,
-            version: gasRef.version,
-            digest: gasRef.digest,
-            balance: remainingBalance
-          });
-          else {
-            if (!this.#sourceCoins) this.#sourceCoins = /* @__PURE__ */ new Map();
-            this.#sourceCoins.set(gasRef.objectId, gasRef);
-          }
-        }
-      }
-      this.#lastDigest = tx.digest;
-      return results;
-    } catch (error) {
-      if (gasCoin) {
-        if (!this.#sourceCoins) this.#sourceCoins = /* @__PURE__ */ new Map();
-        this.#sourceCoins.set(gasCoin.id, null);
-      }
-      await this.#updateCache(async () => {
-        await Promise.all([this.#cache.cache.deleteObjects([...usedObjects]), this.#waitForLastDigest()]);
-      });
-      throw error;
-    } finally {
-      usedObjects.forEach((objectId) => {
-        const queue = this.#objectIdQueues.get(objectId);
-        if (queue && queue.length > 0) queue.shift()();
-        else if (queue) this.#objectIdQueues.delete(objectId);
-      });
-      this.#pendingTransactions--;
-    }
-  }
-  /** Helper for synchronizing cache updates, by ensuring only one update happens at a time.  This can also be used to wait for any pending cache updates  */
-  async #updateCache(fn) {
-    if (this.#cacheLock) await this.#cacheLock;
-    this.#cacheLock = fn?.().then(() => {
-      this.#cacheLock = null;
-    }, () => {
-    }) ?? null;
-  }
-  async #waitForLastDigest() {
-    const digest = this.#lastDigest;
-    if (digest) {
-      this.#lastDigest = null;
-      await this.#client.core.waitForTransaction({ digest });
-    }
-  }
-  async #getGasCoin() {
-    if (this.#coinPool.length === 0 && this.#pendingTransactions <= this.#maxPoolSize) await this.#refillCoinPool();
-    if (this.#coinPool.length === 0) throw new Error("No coins available");
-    return this.#coinPool.shift();
-  }
-  async #getGasPrice() {
-    await this.#ensureEpochInfo();
-    return this.#epochInfo.price;
-  }
-  async #getValidDuringExpiration() {
-    await this.#ensureEpochInfo();
-    const currentEpoch = BigInt(this.#epochInfo.epoch);
-    return { ValidDuring: {
-      minEpoch: String(currentEpoch),
-      maxEpoch: String(currentEpoch + 1n),
-      minTimestamp: null,
-      maxTimestamp: null,
-      chain: this.#epochInfo.chainIdentifier,
-      nonce: Math.random() * 4294967296 >>> 0
-    } };
-  }
-  async #ensureEpochInfo() {
-    if (this.#epochInfo && this.#epochInfo.expiration - EPOCH_BOUNDARY_WINDOW2 - Date.now() > 0) return;
-    if (this.#epochInfoPromise) {
-      await this.#epochInfoPromise;
-      return;
-    }
-    this.#epochInfoPromise = this.#fetchEpochInfo();
-    try {
-      await this.#epochInfoPromise;
-    } finally {
-      this.#epochInfoPromise = null;
-    }
-  }
-  async #fetchEpochInfo() {
-    const [{ systemState }, { chainIdentifier }] = await Promise.all([this.#client.core.getCurrentSystemState(), this.#client.core.getChainIdentifier()]);
-    this.#epochInfo = {
-      epoch: systemState.epoch,
-      price: BigInt(systemState.referenceGasPrice),
-      expiration: Number(systemState.epochStartTimestampMs) + Number(systemState.parameters.epochDurationMs),
-      chainIdentifier
-    };
-  }
-  async #refillCoinPool() {
-    const batchSize = Math.min(this.#coinBatchSize, this.#maxPoolSize - (this.#coinPool.length + this.#pendingTransactions) + 1);
-    if (batchSize === 0) return;
-    const txb = new Transaction();
-    const address = this.#signer.toSuiAddress();
-    txb.setSender(address);
-    if (this.#sourceCoins) {
-      const refs = [];
-      const ids = [];
-      for (const [id, ref] of this.#sourceCoins) if (ref) refs.push(ref);
-      else ids.push(id);
-      if (ids.length > 0) {
-        const { objects } = await this.#client.core.getObjects({ objectIds: ids });
-        refs.push(...objects.filter((obj) => !(obj instanceof Error)).map((obj) => ({
-          objectId: obj.objectId,
-          version: obj.version,
-          digest: obj.digest
-        })));
-      }
-      txb.setGasPayment(refs);
-      this.#sourceCoins = /* @__PURE__ */ new Map();
-    }
-    const amounts = new Array(batchSize).fill(this.#initialCoinBalance);
-    const splitResults = txb.splitCoins(txb.gas, amounts);
-    const coinResults = [];
-    for (let i = 0; i < amounts.length; i++) coinResults.push(splitResults[i]);
-    txb.transferObjects(coinResults, address);
-    await this.waitForLastTransaction();
-    txb.addBuildPlugin(coreClientResolveTransactionPlugin);
-    const bytes = await txb.build({ client: this.#client });
-    const { signature } = await this.#signer.signTransaction(bytes);
-    const result = await this.#client.core.executeTransaction({
-      transaction: bytes,
-      signatures: [signature],
-      include: { effects: true }
-    });
-    const tx = result.$kind === "Transaction" ? result.Transaction : result.FailedTransaction;
-    const effects = tx.effects;
-    effects.changedObjects.forEach((changedObj) => {
-      if (changedObj.objectId === effects.gasObject?.objectId || changedObj.outputState !== "ObjectWrite") return;
-      this.#coinPool.push({
-        id: changedObj.objectId,
-        version: changedObj.outputVersion,
-        digest: changedObj.outputDigest,
-        balance: BigInt(this.#initialCoinBalance)
-      });
-    });
-    if (!this.#sourceCoins) this.#sourceCoins = /* @__PURE__ */ new Map();
-    const gasObject = effects.gasObject;
-    this.#sourceCoins.set(gasObject.objectId, {
-      objectId: gasObject.objectId,
-      version: gasObject.outputVersion,
-      digest: gasObject.outputDigest
-    });
-    await this.#client.core.waitForTransaction({ digest: tx.digest });
-  }
-};
-
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/Arguments.mjs
-var Arguments = {
-  pure: createPure((value) => (tx) => tx.pure(value)),
-  object: createObjectMethods((value) => (tx) => tx.object(value)),
-  sharedObjectRef: (...args) => (tx) => tx.sharedObjectRef(...args),
-  objectRef: (...args) => (tx) => tx.objectRef(...args),
-  receivingRef: (...args) => (tx) => tx.receivingRef(...args)
-};
-
 export {
-  UpgradePolicy,
-  TransactionCommands,
-  Inputs,
-  getPureBcsSchema,
-  normalizedTypeToMoveTypeSignature,
   coinWithBalance,
-  isTransaction,
-  Transaction,
-  AsyncCache,
-  ObjectCache,
-  SerialTransactionExecutor,
-  ParallelTransactionExecutor,
-  Arguments
+  Transaction
 };
-//# sourceMappingURL=chunk-ITIKLNK5.js.map
+//# sourceMappingURL=chunk-TP3M7BAU.js.map