@t2000/cli 10.27.1 → 10.28.0

package/dist/index.js

@@ -28274,28 +28274,6 @@ var SUPPORTED_ASSETS = {
   }
 };
 var STABLE_ASSETS = ["USDC", "USDsui"];
-var OPERATION_ASSETS = {
-  send: ["USDC", "USDsui", "SUI"],
-  swap: "*"
-};
-function isAllowedAsset(op, asset) {
-  const allowed = OPERATION_ASSETS[op];
-  if (allowed === "*") return true;
-  const target = asset.toLowerCase();
-  return allowed.some((a) => a.toLowerCase() === target);
-}
-function assertAllowedAsset(op, asset) {
-  if (!asset) return;
-  if (!isAllowedAsset(op, asset)) {
-    const allowed = OPERATION_ASSETS[op];
-    const list = Array.isArray(allowed) ? allowed.join(", ") : "any";
-    const swapHint = op === "send" ? " Swap to USDC or USDsui first, or send SUI." : "";
-    throw new T2000Error(
-      "INVALID_ASSET",
-      `${op} only supports ${list}. Cannot use ${asset}.${swapHint}`
-    );
-  }
-}
 var GASLESS_STABLE_TYPES = {
   USDC: SUPPORTED_ASSETS.USDC.type,
   USDsui: SUPPORTED_ASSETS.USDsui.type
@@ -28899,19 +28877,42 @@ for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
     ASSET_LOOKUP.set(info.displayName.toUpperCase(), key);
   }
 }
+init_token_registry();
 init_preflight();
-function preflightSend(input) {
+function classifySendAsset(asset) {
+  const coinType = resolveTokenType(asset.trim());
+  if (!coinType) return null;
+  let normalized;
   try {
-    assertAllowedAsset("send", input.asset);
-  } catch (e) {
-    return preflightFail("INVALID_ASSET", e.message);
+    normalized = normalizeStructTag(coinType);
+  } catch {
+    return null;
+  }
+  if (normalized === normalizeStructTag(GASLESS_STABLE_TYPES.USDC)) {
+    return { kind: "gasless-stable", symbol: "USDC", coinType: GASLESS_STABLE_TYPES.USDC };
+  }
+  if (normalized === normalizeStructTag(GASLESS_STABLE_TYPES.USDsui)) {
+    return { kind: "gasless-stable", symbol: "USDsui", coinType: GASLESS_STABLE_TYPES.USDsui };
+  }
+  if (normalized === normalizeStructTag(SUI_TYPE)) {
+    return { kind: "sui", symbol: "SUI", coinType: SUI_TYPE };
+  }
+  return { kind: "coin", symbol: resolveSymbol(coinType), coinType };
+}
+function invalidSendAssetMessage(asset) {
+  return `Unknown asset "${asset}". Use a registry symbol (USDC, USDsui, SUI, MANIFEST, \u2026) or a full coin type (0x\u2026::module::TYPE).`;
+}
+function preflightSend(input) {
+  const cls = classifySendAsset(input.asset);
+  if (!cls) {
+    return preflightFail("INVALID_ASSET", invalidSendAssetMessage(input.asset));
   }
   const amountCheck = checkPositiveAmount(input.amount);
   if (!amountCheck.valid) return amountCheck;
-  if ((input.asset === "USDC" || input.asset === "USDsui") && input.amount < GASLESS_MIN_STABLE_AMOUNT) {
+  if (cls.kind === "gasless-stable" && input.amount < GASLESS_MIN_STABLE_AMOUNT) {
     return preflightFail(
       "INVALID_AMOUNT",
-      `Minimum gasless transfer is ${GASLESS_MIN_STABLE_AMOUNT} ${input.asset}. Got ${input.amount}.`
+      `Minimum gasless transfer is ${GASLESS_MIN_STABLE_AMOUNT} ${cls.symbol}. Got ${input.amount}.`
     );
   }
   const addressCheck = checkSuiAddress(input.to);
@@ -28928,42 +28929,44 @@ async function buildSendTx({
   const pf = preflightSend({ to, amount, asset });
   if (!pf.valid) throw new T2000Error(pf.code, pf.error);
   const recipient = validateAddress(to);
-  const assetInfo = SUPPORTED_ASSETS[asset];
-  if (!assetInfo) throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
-  const rawAmount = displayToRaw(amount, assetInfo.decimals);
+  const cls = classifySendAsset(asset);
+  const decimals = cls.kind === "gasless-stable" || cls.kind === "sui" ? SUPPORTED_ASSETS[cls.symbol].decimals : await resolveCoinDecimals(client, cls.coinType);
+  const rawAmount = displayToRaw(amount, decimals);
   const tx = new Transaction();
   tx.setSender(address);
-  const balanceResp = await client.core.getBalance({ owner: address, coinType: assetInfo.type });
+  const balanceResp = await client.core.getBalance({ owner: address, coinType: cls.coinType });
   const totalBalance = BigInt(balanceResp.balance.balance);
   if (totalBalance < rawAmount) {
-    throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${asset} balance`, {
-      available: Number(totalBalance) / 10 ** assetInfo.decimals,
+    throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${cls.symbol} balance`, {
+      available: Number(totalBalance) / 10 ** decimals,
       required: amount
     });
   }
-  if (asset === "USDC" || asset === "USDsui") {
-    const rawFloor = displayToRaw(GASLESS_MIN_STABLE_AMOUNT, assetInfo.decimals);
-    const remainder = totalBalance - rawAmount;
-    if (remainder > 0n && remainder < rawFloor) {
-      const total = Number(totalBalance) / 10 ** assetInfo.decimals;
-      throw new T2000Error(
-        "INVALID_AMOUNT",
-        `Gasless ${asset} transfers must send the entire balance or leave at least ${GASLESS_MIN_STABLE_AMOUNT} ${asset}. Sending ${amount} of ${total} leaves ${(total - amount).toFixed(assetInfo.decimals)}. Send ${total} (everything) or at most ${(total - GASLESS_MIN_STABLE_AMOUNT).toFixed(assetInfo.decimals)}.`,
-        { available: total, required: amount }
-      );
-    }
-  }
-  if (asset === "SUI") {
+  if (cls.kind === "sui") {
     const [sendCoin] = tx.splitCoins(tx.gas, [rawAmount]);
     tx.transferObjects([sendCoin], recipient);
     return tx;
   }
-  const coinType = GASLESS_STABLE_TYPES[asset];
+  if (cls.kind === "coin") {
+    const sendCoin = coinWithBalance({ type: cls.coinType, balance: rawAmount })(tx);
+    tx.transferObjects([sendCoin], recipient);
+    return tx;
+  }
+  const rawFloor = displayToRaw(GASLESS_MIN_STABLE_AMOUNT, decimals);
+  const remainder = totalBalance - rawAmount;
+  if (remainder > 0n && remainder < rawFloor) {
+    const total = Number(totalBalance) / 10 ** decimals;
+    throw new T2000Error(
+      "INVALID_AMOUNT",
+      `Gasless ${cls.symbol} transfers must send the entire balance or leave at least ${GASLESS_MIN_STABLE_AMOUNT} ${cls.symbol}. Sending ${amount} of ${total} leaves ${(total - amount).toFixed(decimals)}. Send ${total} (everything) or at most ${(total - GASLESS_MIN_STABLE_AMOUNT).toFixed(decimals)}.`,
+      { available: total, required: amount }
+    );
+  }
   tx.moveCall({
     target: "0x2::balance::send_funds",
-    typeArguments: [coinType],
+    typeArguments: [cls.coinType],
     arguments: [
-      tx.balance({ type: coinType, balance: rawAmount }),
+      tx.balance({ type: cls.coinType, balance: rawAmount }),
       tx.pure.address(recipient)
     ]
   });
@@ -30191,11 +30194,21 @@ var T2000 = class _T2000 extends import_index2.default {
     const rawAmount = BigInt(Math.floor(params.amount * 10 ** fromDecimals));
     let route;
     if (params.serializedRoute) {
-      const s = params.serializedRoute;
+      let s = params.serializedRoute;
+      const nested = s.serializedRoute;
+      if (nested && typeof nested === "object" && typeof nested.fromCoinType === "string" && nested.routerData) {
+        s = nested;
+      }
+      if (typeof s.fromCoinType !== "string" || typeof s.toCoinType !== "string") {
+        throw new T2000Error(
+          "SWAP_ROUTE_MISMATCH",
+          "serializedRoute is not the object t2000 quoted \u2014 it is missing fromCoinType/toCoinType. Pass quote.serializedRoute exactly as the quote returned it (not the whole quote response), or omit serializedRoute to discover a fresh route."
+        );
+      }
       if (!verifyCetusRouteCoinMatch2(s, { fromCoinType: fromType, toCoinType: toType })) {
         throw new T2000Error(
           "SWAP_ROUTE_MISMATCH",
-          `The quoted route is for ${s.fromCoinType} -> ${s.toCoinType}, not ${params.from} -> ${params.to}. Re-quote and pass the new serializedRoute.`
+          `The quoted route is for ${s.fromCoinType} -> ${s.toCoinType}, not ${fromType} -> ${toType}. Re-quote and pass the new serializedRoute.`
         );
       }
       if (s.byAmountIn !== byAmountIn || BigInt(s.amountIn) !== rawAmount) {
@@ -30339,18 +30352,17 @@ var T2000 = class _T2000 extends import_index2.default {
   /**
    * Send `amount` of `asset` to `to` (hex address or SuiNS name).
    *
-   * [v4.0 Phase A Day 2 — SPEC_AGENT_WALLET_GREENFIELD §A]
+   * [S.957 — 2026-08-08] `asset` accepts **any held coin type** — a
+   * registry symbol (`USDC`, `MANIFEST`) or a full `0x…::module::TYPE`.
+   * Unresolvable strings throw `INVALID_ASSET`; empty balances throw
+   * `INSUFFICIENT_BALANCE`.
    *
-   * **Breaking changes from v3.x:**
-   * - `asset` is now REQUIRED (no implicit `?? 'USDC'` default). Callers
-   *   must specify `'USDC' | 'USDsui' | 'SUI'`. Sending `'USDT'` /
-   *   `'USDe'` / `'WAL'` / `'ETH'` / `'NAVX'` / `'GOLD'` now errors
-   *   with `INVALID_ASSET` — swap to a stable first.
    * - USDC + USDsui builds go through `SuiGrpcClient` so the gRPC build
    *   resolver auto-detects `0x2::balance::send_funds` eligibility and
-   *   zeros gas at simulate time. Result: **gasless USDC / USDsui sends
-   *   from a zero-SUI wallet.** SUI sends stay on the standard gas-paid
-   *   path.
+   *   zeros gas at simulate time — **gasless sends from a zero-SUI
+   *   wallet.** They remain the ONLY gasless assets.
+   * - SUI and every other coin type are gas-paid (the sender needs SUI).
+   * - `asset` stays REQUIRED (no implicit `?? 'USDC'` default — v4 rule).
    *
    * Submission stays on the JSON-RPC client (the rest of the SDK
    * expects JSON-RPC for read paths, and Sui's docs explicitly support
@@ -30361,30 +30373,31 @@ var T2000 = class _T2000 extends import_index2.default {
     if (!asset) {
       throw new T2000Error(
         "INVALID_ASSET",
-        "send() requires an explicit asset. Use one of: USDC, USDsui, SUI."
+        "send() requires an explicit asset. Use a registry symbol (USDC, USDsui, SUI, MANIFEST, \u2026) or a full coin type (0x\u2026::module::TYPE)."
       );
     }
-    assertAllowedAsset("send", asset);
-    const sendableAsset = asset;
+    const cls = classifySendAsset(asset);
+    if (!cls) {
+      throw new T2000Error("INVALID_ASSET", invalidSendAssetMessage(asset));
+    }
     this.limits.assert({
       operation: "send",
-      amountUsd: approxUsdValue(sendableAsset, params.amount) ?? 0,
+      amountUsd: approxUsdValue(cls.symbol, params.amount) ?? 0,
       force: params.force
     });
     const resolved = await this.resolveRecipient(params.to);
     const sendAmount = params.amount;
     const sendTo = resolved.address;
-    const useGrpc = sendableAsset === "USDC" || sendableAsset === "USDsui";
-    const buildClient = useGrpc ? getSuiGrpcClient() : void 0;
+    const buildClient = cls.kind === "gasless-stable" ? getSuiGrpcClient() : void 0;
     const gasResult = await executeTx(
       this.client,
       this._signer,
-      () => buildSendTx({ client: this.client, address: this._address, to: sendTo, amount: sendAmount, asset: sendableAsset }),
+      () => buildSendTx({ client: this.client, address: this._address, to: sendTo, amount: sendAmount, asset }),
       { buildClient }
     );
-    this.limits.record(approxUsdValue(sendableAsset, sendAmount) ?? 0);
+    this.limits.record(approxUsdValue(cls.symbol, sendAmount) ?? 0);
     const balance = await this.balance();
-    this.emitBalanceChange(sendableAsset, sendAmount, "send", gasResult.digest);
+    this.emitBalanceChange(cls.symbol, sendAmount, "send", gasResult.digest);
     return {
       success: true,
       tx: gasResult.digest,
@@ -34094,20 +34107,19 @@ function registerStatus(program3) {
 
 // src/commands/send.ts
 var import_picocolors6 = __toESM(require_picocolors(), 1);
-var ACCEPTED_ASSETS = ["USDC", "USDsui", "SUI"];
-var ACCEPTED_ASSETS_LIST = ACCEPTED_ASSETS.join(", ");
+var ASSET_HINT = "a registry symbol (USDC, USDsui, SUI, MANIFEST, \u2026) or a full coin type (0x\u2026::module::TYPE)";
 function parseSendArgs(args) {
   const filtered = args.filter((a) => a.toLowerCase() !== "to");
   if (filtered.length < 2) {
     throw new Error(
       `Usage: t2 send <amount> <asset> <recipient>
-  asset must be one of: ${ACCEPTED_ASSETS_LIST}
+  asset is ${ASSET_HINT}
   recipient can be a 0x address or SuiNS name (alice.sui, alice.audric.sui)`
     );
   }
   if (filtered.length === 2) {
     throw new Error(
-      `Missing required <asset> argument. Use one of: ${ACCEPTED_ASSETS_LIST}. Example: t2 send ${filtered[0]} USDC ${filtered[1]}`
+      `Missing required <asset> argument. Use ${ASSET_HINT}. Example: t2 send ${filtered[0]} USDC ${filtered[1]}`
     );
   }
   const amount = parseFloat(filtered[0]);
@@ -34115,36 +34127,34 @@ function parseSendArgs(args) {
     throw new Error(`Amount must be a positive number (got "${filtered[0]}").`);
   }
   const candidate = filtered[1];
-  const normalized = normalizeAssetSymbol(candidate);
-  if (!normalized) {
+  const cls = classifySendAsset(candidate);
+  if (!cls) {
     throw new Error(
-      `Unsupported asset "${candidate}". Use one of: ${ACCEPTED_ASSETS_LIST}. Swap to USDC or USDsui first with \`t2 swap\`, or send SUI.`
+      `Unknown asset "${candidate}". Use ${ASSET_HINT}. Check your holdings with \`t2 balance\`.`
     );
   }
   const recipient = filtered[2];
   if (!recipient) {
     throw new Error(`Missing recipient. Usage: t2 send <amount> <asset> <recipient>.`);
   }
-  return { amount, asset: normalized, recipient };
-}
-function normalizeAssetSymbol(input) {
-  const lower = input.toLowerCase();
-  if (lower === "usdc") return "USDC";
-  if (lower === "usdsui") return "USDsui";
-  if (lower === "sui") return "SUI";
-  return void 0;
+  const asset = cls.kind === "gasless-stable" || cls.kind === "sui" ? cls.symbol : candidate;
+  return { amount, asset, recipient };
 }
 function registerSend(program3) {
   program3.command("send").argument("<amount>", "Amount of <asset> to send (denominated in asset units, NOT USD)").argument(
     "[args...]",
-    'Asset (USDC | USDsui | SUI), optional "to" keyword, and recipient (0x address or SuiNS name like alice.sui)'
-  ).description("Send USDC, USDsui, or SUI. USDC + USDsui are gasless (no SUI required).").option("--key <path>", "Custom wallet path (default ~/.t2000/wallet.key)").option("--force", "Override spending limits for this call (see `t2 limit`)").addHelpText(
+    'Asset (registry symbol like USDC / MANIFEST, or a full 0x\u2026::module::TYPE coin type), optional "to" keyword, and recipient (0x address or SuiNS name like alice.sui)'
+  ).description(
+    "Send any held token. USDC + USDsui are gasless; everything else needs SUI for gas."
+  ).option("--key <path>", "Custom wallet path (default ~/.t2000/wallet.key)").option("--force", "Override spending limits for this call (see `t2 limit`)").addHelpText(
     "after",
     `
 Examples:
   $ t2 send 5 USDC 0xabc\u2026              Send 5 USDC (gasless) to a hex address
   $ t2 send 5 USDsui alice.sui         Send 5 USDsui (gasless) to a SuiNS name
   $ t2 send 0.1 SUI alice.audric.sui   Send 0.1 SUI (gas required) to a SuiNS subname
+  $ t2 send 10 MANIFEST 0xabc\u2026         Send any held token (gas required)
+  $ t2 send 10 0xc466\u2026::manifest::MANIFEST 0xabc\u2026   Full coin type works too
 `
   ).action(async (amount, args, opts) => {
     try {
@@ -34153,9 +34163,8 @@ Examples:
       const result = await agent.send({
         to: recipient,
         amount: parsedAmount,
-        // The CLI parser already narrowed asset to USDC / USDsui / SUI;
-        // the SDK accepts `SupportedAsset` and re-validates via
-        // `assertAllowedAsset('send', …)` at runtime.
+        // [S.957] Any resolvable asset string — the SDK re-resolves via
+        // `classifySendAsset` (same rule the parser used).
         asset,
         force: opts.force
       });
@@ -34168,7 +34177,7 @@ Examples:
         return;
       }
       const displayTo = result.suinsName ? `${result.suinsName} ${import_picocolors6.default.dim(`(${truncateAddress(result.to)})`)}` : truncateAddress(result.to);
-      const amountDisplay = asset === "SUI" ? `${result.amount.toFixed(4)} SUI` : `${formatUsd(result.amount)} ${asset}`;
+      const amountDisplay = asset === "USDC" || asset === "USDsui" ? `${formatUsd(result.amount)} ${asset}` : asset === "SUI" ? `${result.amount.toFixed(4)} SUI` : `${result.amount} ${asset}`;
       printBlank();
       printSuccess(`Sent ${amountDisplay} \u2192 ${displayTo}`);
       if (result.gasCost === 0) {