@t2000/mcp 5.6.0 → 5.6.1

package/dist/bin.js

@@ -14750,9 +14750,6 @@ function getIdFromCallArg(arg) {
   }
   if (arg.UnresolvedObject) return normalizeSuiAddress(arg.UnresolvedObject.objectId);
 }
-function isArgument(value) {
-  return is(ArgumentSchema, value);
-}
 function remapCommandArguments(command, inputMapping, commandMapping) {
   const remapArg = (arg) => {
     switch (arg.$kind) {
@@ -14817,8 +14814,6 @@ function remapCommandArguments(command, inputMapping, commandMapping) {
 var init_utils4 = __esm({
   "../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/utils.mjs"() {
     init_sui_types();
-    init_internal();
-    init_dist3();
   }
 });
 
@@ -15389,19 +15384,13 @@ var init_TransactionData = __esm({
 });
 
 // ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/Commands.mjs
-var UpgradePolicy, TransactionCommands;
+var TransactionCommands;
 var init_Commands = __esm({
   "../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/Commands.mjs"() {
     init_sui_types();
     init_internal();
     init_dist2();
     init_dist3();
-    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;
-    })({});
     TransactionCommands = {
       MoveCall(input) {
         const [pkg, mod3 = "", fn = ""] = "target" in input ? input.target.split("::") : [
@@ -15619,58 +15608,6 @@ function getPureBcsSchema(typeSignature) {
       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)}`);
-}
 var init_serializer = __esm({
   "../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/serializer.mjs"() {
     init_sui_types();
@@ -16208,24 +16145,6 @@ var init_chunk = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@mysten+utils@0.3.3/node_modules/@mysten/utils/dist/with-resolver.mjs
-function promiseWithResolvers() {
-  let resolver;
-  let rejecter;
-  return {
-    promise: new Promise((resolve2, reject) => {
-      resolver = resolve2;
-      rejecter = reject;
-    }),
-    resolve: resolver,
-    reject: rejecter
-  };
-}
-var init_with_resolver = __esm({
-  "../../node_modules/.pnpm/@mysten+utils@0.3.3/node_modules/@mysten/utils/dist/with-resolver.mjs"() {
-  }
-});
-
 // ../../node_modules/.pnpm/@mysten+utils@0.3.3/node_modules/@mysten/utils/dist/dataloader.mjs
 function getCurrentBatch(loader) {
   const existingBatch = loader._batch;
@@ -16457,7 +16376,6 @@ var init_dist4 = __esm({
   "../../node_modules/.pnpm/@mysten+utils@0.3.3/node_modules/@mysten/utils/dist/index.mjs"() {
     init_b642();
     init_chunk();
-    init_with_resolver();
     init_dataloader();
   }
 });
@@ -17688,784 +17606,11 @@ var init_Transaction = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/ObjectCache.mjs
-var AsyncCache, InMemoryCache, ObjectCache;
-var init_ObjectCache = __esm({
-  "../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/ObjectCache.mjs"() {
-    init_sui_types();
-    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(object4) {
-        if (object4.owner) await this.set("OwnedObject", object4.objectId, object4);
-        else await this.set("SharedOrImmutableObject", object4.objectId, object4);
-        return object4;
-      }
-      async addObjects(objects) {
-        await Promise.all(objects.map(async (object4) => this.addObject(object4)));
-      }
-      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);
-      }
-    };
-    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();
-      }
-    };
-    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 cached2 = (await this.#cache.getObjects(unresolvedObjects)).filter((obj) => obj !== null);
-          const byId = new Map(cached2.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;
-var init_caching = __esm({
-  "../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/executor/caching.mjs"() {
-    init_bcs3();
-    init_core_resolver();
-    init_Transaction();
-    init_ObjectCache();
-    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, ParallelQueue;
-var init_queue = __esm({
-  "../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/executor/queue.mjs"() {
-    SerialQueue = class {
-      #queue = [];
-      async runTask(task) {
-        return new Promise((resolve2, reject) => {
-          this.#queue.push(() => {
-            task().finally(() => {
-              this.#queue.shift();
-              if (this.#queue.length > 0) this.#queue[0]();
-            }).then(resolve2, reject);
-          });
-          if (this.#queue.length === 1) this.#queue[0]();
-        });
-      }
-    };
-    ParallelQueue = class {
-      #queue = [];
-      constructor(maxTasks) {
-        this.activeTasks = 0;
-        this.maxTasks = maxTasks;
-      }
-      runTask(task) {
-        return new Promise((resolve2, reject) => {
-          if (this.activeTasks < this.maxTasks) {
-            this.activeTasks++;
-            task().finally(() => {
-              if (this.#queue.length > 0) this.#queue.shift()();
-              else this.activeTasks--;
-            }).then(resolve2, reject);
-          } else this.#queue.push(() => {
-            task().finally(() => {
-              if (this.#queue.length > 0) this.#queue.shift()();
-              else this.activeTasks--;
-            }).then(resolve2, reject);
-          });
-        });
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/executor/serial.mjs
-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
-  };
-}
-var EPOCH_BOUNDARY_WINDOW, SerialTransactionExecutor;
-var init_serial = __esm({
-  "../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/executor/serial.mjs"() {
-    init_Transaction();
-    init_caching();
-    init_queue();
-    EPOCH_BOUNDARY_WINDOW = 6e4;
-    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 copy2 = Transaction.from(transaction);
-        if (this.#gasMode === "addressBalance") {
-          copy2.setGasPayment([]);
-          copy2.setExpiration(await this.#getValidDuringExpiration());
-        } else {
-          const gasCoin = await this.#cache.cache.getCustom("gasCoin");
-          if (gasCoin) copy2.setGasPayment([gasCoin]);
-        }
-        copy2.setGasBudgetIfNotSet(this.#defaultGasBudget);
-        copy2.setSenderIfNotSet(this.#signer.toSuiAddress());
-        return this.#cache.buildTransaction({ transaction: copy2 });
-      };
-      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 (error2) => {
-            await this.resetCache();
-            throw error2;
-          });
-        });
-      }
-    };
-  }
-});
-
-// ../../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, EPOCH_BOUNDARY_WINDOW2, ParallelTransactionExecutor;
-var init_parallel = __esm({
-  "../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/executor/parallel.mjs"() {
-    init_TransactionData();
-    init_core_resolver();
-    init_Transaction();
-    init_caching();
-    init_queue();
-    init_dist4();
-    PARALLEL_EXECUTOR_DEFAULTS = {
-      coinBatchSize: 20,
-      initialCoinBalance: 200000000n,
-      minimumCoinBalance: 50000000n,
-      maxPoolSize: 50
-    };
-    EPOCH_BOUNDARY_WINDOW2 = 6e4;
-    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: resolve2, reject } = promiseWithResolvers();
-        const usedObjects = await this.#getUsedObjects(transaction);
-        const execute = () => {
-          this.#executeQueue.runTask(() => {
-            return this.#execute(transaction, usedObjects, include, additionalSignatures).then(resolve2, 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 (error2) {
-          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 error2;
-        } 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;
-var init_Arguments = __esm({
-  "../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/Arguments.mjs"() {
-    init_object();
-    init_pure2();
-    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)
-    };
-  }
-});
-
 // ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/index.mjs
-var transactions_exports = {};
-__export(transactions_exports, {
-  Arguments: () => Arguments,
-  AsyncCache: () => AsyncCache,
-  Inputs: () => Inputs,
-  ObjectCache: () => ObjectCache,
-  ParallelTransactionExecutor: () => ParallelTransactionExecutor,
-  SerialTransactionExecutor: () => SerialTransactionExecutor,
-  Transaction: () => Transaction,
-  TransactionCommands: () => TransactionCommands,
-  TransactionDataBuilder: () => TransactionDataBuilder,
-  UpgradePolicy: () => UpgradePolicy,
-  coinWithBalance: () => coinWithBalance,
-  getPureBcsSchema: () => getPureBcsSchema,
-  isArgument: () => isArgument,
-  isTransaction: () => isTransaction,
-  normalizedTypeToMoveTypeSignature: () => normalizedTypeToMoveTypeSignature
-});
 var init_transactions = __esm({
   "../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/transactions/index.mjs"() {
-    init_utils4();
-    init_TransactionData();
-    init_Commands();
-    init_Inputs();
-    init_serializer();
     init_CoinWithBalance();
     init_Transaction();
-    init_ObjectCache();
-    init_serial();
-    init_parallel();
-    init_Arguments();
   }
 });
 
@@ -78768,6 +77913,7 @@ var init_token_registry = __esm2({
 });
 var coinSelection_exports = {};
 __export2(coinSelection_exports, {
+  buildCoinToAddressBalanceMigration: () => buildCoinToAddressBalanceMigration,
   fetchAllCoins: () => fetchAllCoins,
   selectAndSplitCoin: () => selectAndSplitCoin,
   selectSuiCoin: () => selectSuiCoin
@@ -78882,6 +78028,32 @@ async function selectCoinObjectsOnly(tx, client, owner, coinType, amount, allowS
   });
   return { coin, effectiveAmount, swapAll };
 }
+function buildCoinToAddressBalanceMigration(args) {
+  const { coins, coinType, owner, minAmount } = args;
+  const sorted = [...coins].filter((c) => c.balance > 0n).sort((a, b) => b.balance > a.balance ? 1 : b.balance < a.balance ? -1 : 0);
+  const selected = [];
+  let migratedRaw = 0n;
+  for (const c of sorted) {
+    if (migratedRaw >= minAmount) break;
+    selected.push(c);
+    migratedRaw += c.balance;
+  }
+  if (migratedRaw < minAmount) {
+    throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${coinType} coin objects to migrate`, {
+      available: migratedRaw.toString(),
+      required: minAmount.toString()
+    });
+  }
+  const tx = new Transaction();
+  for (const c of selected) {
+    tx.moveCall({
+      target: "0x2::coin::send_funds",
+      typeArguments: [coinType],
+      arguments: [tx.object(c.objectId), tx.pure.address(owner)]
+    });
+  }
+  return { tx, migratedRaw };
+}
 async function selectSuiCoin(tx, client, owner, amountMist, sponsoredContext, mergeCache) {
   if (sponsoredContext) {
     const { SUI_TYPE: SUI_TYPE22 } = await Promise.resolve().then(() => (init_token_registry(), token_registry_exports));
@@ -79611,40 +78783,26 @@ async function ensureAddressBalanceCovers(args) {
       required: amountRaw.toString()
     });
   }
+  const coins = [];
   let coinSum = 0n;
   let cursor;
   let hasNext = true;
   while (hasNext) {
     const page = await client.core.listCoins({ owner, coinType: asset, cursor: cursor ?? void 0 });
-    for (const c of page.objects) coinSum += BigInt(c.balance);
+    for (const c of page.objects) {
+      coins.push({ objectId: c.objectId, balance: BigInt(c.balance) });
+      coinSum += BigInt(c.balance);
+    }
     cursor = page.cursor;
     hasNext = page.hasNextPage;
   }
   const addressBalance = total - coinSum;
   if (addressBalance >= amountRaw) return 0;
   const shortfall = amountRaw - addressBalance;
-  const { Transaction: Transaction6 } = await Promise.resolve().then(() => (init_transactions(), transactions_exports));
-  const { selectAndSplitCoin: selectAndSplitCoin2 } = await Promise.resolve().then(() => (init_coinSelection(), coinSelection_exports));
+  const { buildCoinToAddressBalanceMigration: buildCoinToAddressBalanceMigration2 } = await Promise.resolve().then(() => (init_coinSelection(), coinSelection_exports));
   const grpcClient = await makeGrpcBuildClient(client);
-  const migration = await executeTx(
-    client,
-    signer,
-    async () => {
-      const tx = new Transaction6();
-      const { coin } = await selectAndSplitCoin2(tx, client, owner, asset, shortfall, {
-        sponsoredContext: true,
-        // coin-objects-only — never the address balance
-        allowSwapAll: false
-      });
-      tx.moveCall({
-        target: "0x2::coin::send_funds",
-        typeArguments: [asset],
-        arguments: [coin, tx.pure.address(owner)]
-      });
-      return tx;
-    },
-    { buildClient: grpcClient }
-  );
+  const { tx } = buildCoinToAddressBalanceMigration2({ coins, coinType: asset, owner, minAmount: shortfall });
+  const migration = await executeTx(client, signer, () => tx, { buildClient: grpcClient });
   return migration.gasCostSui;
 }
 async function finalize(response, opts) {
@@ -81180,7 +80338,7 @@ CRITICAL: When the user asks to use any external or paid API, names a provider (
 Spending is the user's own USDC and every t2000_pay call is bounded by maxPrice. For larger or multi-step spends, state the estimated cost first and proceed once the user is happy. Use t2000_balance to check funds. The v4 wallet is payments-only; savings / lending live on audric.ai.`;
 
 // src/index.ts
-var PKG_VERSION = "5.6.0" ;
+var PKG_VERSION = "5.6.1" ;
 console.log = (...args) => console.error("[log]", ...args);
 console.warn = (...args) => console.error("[warn]", ...args);
 async function startMcpServer(opts) {