@t2000/sdk 3.3.0 → 4.0.1

package/dist/index.js

@@ -4,10 +4,10 @@ import BN from 'bn.js';
 import { EventEmitter } from 'eventemitter3';
 import { createPaymentTransactionUri } from '@mysten/payment-kit';
 import { SuiJsonRpcClient, getJsonRpcFullnodeUrl } from '@mysten/sui/jsonRpc';
+import { SuiGrpcClient } from '@mysten/sui/grpc';
 import { normalizeSuiAddress, isValidSuiAddress, normalizeStructTag } from '@mysten/sui/utils';
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
 import { decodeSuiPrivateKey } from '@mysten/sui/cryptography';
-import { randomBytes, createCipheriv, createDecipheriv, scryptSync } from 'crypto';
 import { access, mkdir, writeFile, readFile } from 'fs/promises';
 import { join as join$1, dirname, resolve } from 'path';
 import { homedir } from 'os';
@@ -1122,7 +1122,7 @@ var OPERATION_ASSETS = {
   borrow: ["USDC", "USDsui"],
   withdraw: "*",
   repay: "*",
-  send: "*",
+  send: ["USDC", "USDsui", "SUI"],
   swap: "*"
 };
 function isAllowedAsset(op, asset) {
@@ -1136,28 +1136,62 @@ function assertAllowedAsset(op, asset) {
   if (!isAllowedAsset(op, asset)) {
     const allowed = OPERATION_ASSETS[op];
     const list = Array.isArray(allowed) ? allowed.join(", ") : "any";
+    const swapHint = op === "save" ? " Swap to USDC or USDsui first." : op === "send" ? " Swap to USDC or USDsui first, or send SUI." : "";
     throw new T2000Error(
       "INVALID_ASSET",
-      `${op} only supports ${list}. Cannot use ${asset}.${op === "save" ? " Swap to USDC or USDsui first." : ""}`
+      `${op} only supports ${list}. Cannot use ${asset}.${swapHint}`
     );
   }
 }
+var SENDABLE_ASSETS = ["USDC", "USDsui", "SUI"];
+var GASLESS_STABLE_TYPES = {
+  USDC: SUPPORTED_ASSETS.USDC.type,
+  USDsui: SUPPORTED_ASSETS.USDsui.type
+};
 var T2000_OVERLAY_FEE_WALLET = process.env.T2000_OVERLAY_FEE_WALLET ?? "0x5366efbf2b4fe5767fe2e78eb197aa5f5d138d88ac3333fbf3f80a1927da473a";
 var DEFAULT_NETWORK = "mainnet";
 var DEFAULT_RPC_URL = "https://fullnode.mainnet.sui.io:443";
+var DEFAULT_GRPC_URL = "https://fullnode.mainnet.sui.io:443";
 var DEFAULT_KEY_PATH = "~/.t2000/wallet.key";
+var GASLESS_MIN_STABLE_AMOUNT = 0.01;
 process.env.T2000_API_URL ?? "https://api.t2000.ai";
 var CETUS_USDC_SUI_POOL = "0x51e883ba7c0b566a26cbc8a94cd33eb0abd418a77cc1e60ad22fd9b1f29cd2ab";
 var GAS_RESERVE_MIN = 0.05;
 
 // src/utils/sui.ts
 init_errors();
-var cachedClient = null;
+function resolveRpcUrl(rpcUrl) {
+  if (rpcUrl) return rpcUrl;
+  const envUrl = process.env.T2000_RPC_URL?.trim();
+  if (envUrl) return envUrl;
+  return DEFAULT_RPC_URL;
+}
+function resolveGrpcUrl(grpcUrl) {
+  if (grpcUrl) return grpcUrl;
+  const envUrl = process.env.T2000_GRPC_URL?.trim();
+  if (envUrl) return envUrl;
+  return DEFAULT_GRPC_URL;
+}
+var rpcClientCache = /* @__PURE__ */ new Map();
 function getSuiClient(rpcUrl) {
-  const url = rpcUrl ?? DEFAULT_RPC_URL;
-  if (cachedClient) return cachedClient;
-  cachedClient = new SuiJsonRpcClient({ url, network: "mainnet" });
-  return cachedClient;
+  const url = resolveRpcUrl(rpcUrl);
+  const cached = rpcClientCache.get(url);
+  if (cached) return cached;
+  const client = new SuiJsonRpcClient({ url, network: "mainnet" });
+  rpcClientCache.set(url, client);
+  return client;
+}
+function createSuiClient(network = "mainnet") {
+  return new SuiJsonRpcClient({ url: getJsonRpcFullnodeUrl(network), network });
+}
+var grpcClientCache = /* @__PURE__ */ new Map();
+function getSuiGrpcClient(grpcUrl) {
+  const baseUrl = resolveGrpcUrl(grpcUrl);
+  const cached = grpcClientCache.get(baseUrl);
+  if (cached) return cached;
+  const client = new SuiGrpcClient({ baseUrl, network: "mainnet" });
+  grpcClientCache.set(baseUrl, client);
+  return client;
 }
 function validateAddress(address) {
   const normalized = normalizeSuiAddress(address);
@@ -1180,49 +1214,10 @@ function normalizeCoinType(coinType) {
 
 // src/wallet/keyManager.ts
 init_errors();
-var ALGORITHM = "aes-256-gcm";
-var SCRYPT_N = 2 ** 14;
-var SCRYPT_R = 8;
-var SCRYPT_P = 1;
-var SALT_LENGTH = 32;
-var IV_LENGTH = 16;
 function expandPath(p) {
   if (p.startsWith("~")) return resolve(homedir(), p.slice(2));
   return resolve(p);
 }
-function deriveKey(passphrase, salt) {
-  return scryptSync(passphrase, salt, 32, { N: SCRYPT_N, r: SCRYPT_R, p: SCRYPT_P });
-}
-function encrypt(data, passphrase) {
-  const salt = randomBytes(SALT_LENGTH);
-  const key = deriveKey(passphrase, salt);
-  const iv = randomBytes(IV_LENGTH);
-  const cipher = createCipheriv(ALGORITHM, key, iv);
-  const ciphertext = Buffer.concat([cipher.update(data), cipher.final()]);
-  const tag = cipher.getAuthTag();
-  return {
-    version: 1,
-    algorithm: ALGORITHM,
-    salt: salt.toString("hex"),
-    iv: iv.toString("hex"),
-    tag: tag.toString("hex"),
-    ciphertext: ciphertext.toString("hex")
-  };
-}
-function decrypt(encrypted, passphrase) {
-  const salt = Buffer.from(encrypted.salt, "hex");
-  const key = deriveKey(passphrase, salt);
-  const iv = Buffer.from(encrypted.iv, "hex");
-  const tag = Buffer.from(encrypted.tag, "hex");
-  const ciphertext = Buffer.from(encrypted.ciphertext, "hex");
-  const decipher = createDecipheriv(ALGORITHM, key, iv);
-  decipher.setAuthTag(tag);
-  try {
-    return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-  } catch {
-    throw new T2000Error("WALLET_LOCKED", "Invalid PIN");
-  }
-}
 function generateKeypair() {
   return Ed25519Keypair.generate();
 }
@@ -1234,7 +1229,30 @@ function keypairFromPrivateKey(privateKey) {
   const bytes = Buffer.from(privateKey.replace(/^0x/, ""), "hex");
   return Ed25519Keypair.fromSecretKey(bytes);
 }
-async function saveKey(keypair, passphrase, keyPath) {
+async function saveKey(keypair, _passphrase, keyPath) {
+  const filePath = expandPath(keyPath ?? DEFAULT_KEY_PATH);
+  try {
+    await access(filePath);
+    throw new T2000Error("WALLET_EXISTS", `Wallet already exists at ${filePath}`);
+  } catch (error) {
+    if (error instanceof T2000Error) throw error;
+  }
+  await mkdir(dirname(filePath), { recursive: true });
+  const payload = {
+    version: 2,
+    secret: keypair.getSecretKey()
+  };
+  await writeFile(filePath, JSON.stringify(payload, null, 2), { mode: 384 });
+  return filePath;
+}
+async function saveBech32(secret, keyPath) {
+  if (!secret.startsWith("suiprivkey")) {
+    throw new T2000Error(
+      "INVALID_KEY",
+      `Secret must be a Bech32 suiprivkey1... string. Got: ${secret.slice(0, 12)}...`
+    );
+  }
+  decodeSuiPrivateKey(secret);
   const filePath = expandPath(keyPath ?? DEFAULT_KEY_PATH);
   try {
     await access(filePath);
@@ -1243,12 +1261,11 @@ async function saveKey(keypair, passphrase, keyPath) {
     if (error instanceof T2000Error) throw error;
   }
   await mkdir(dirname(filePath), { recursive: true });
-  const bech32Key = keypair.getSecretKey();
-  const encrypted = encrypt(Buffer.from(bech32Key, "utf-8"), passphrase);
-  await writeFile(filePath, JSON.stringify(encrypted, null, 2), { mode: 384 });
+  const payload = { version: 2, secret };
+  await writeFile(filePath, JSON.stringify(payload, null, 2), { mode: 384 });
   return filePath;
 }
-async function loadKey(passphrase, keyPath) {
+async function loadKey(_passphrase, keyPath) {
   const filePath = expandPath(keyPath ?? DEFAULT_KEY_PATH);
   let content;
   try {
@@ -1256,10 +1273,22 @@ async function loadKey(passphrase, keyPath) {
   } catch {
     throw new T2000Error("WALLET_NOT_FOUND", `No wallet found at ${filePath}`);
   }
-  const encrypted = JSON.parse(content);
-  const decrypted = decrypt(encrypted, passphrase);
-  const bech32Key = decrypted.toString("utf-8");
-  const decoded = decodeSuiPrivateKey(bech32Key);
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new T2000Error(
+      "WALLET_CORRUPT",
+      `Wallet file at ${filePath} is not a valid v4 wallet. Move or delete the file, then run \`t2 init\`.`
+    );
+  }
+  if (!isPlainKey(parsed)) {
+    throw new T2000Error(
+      "WALLET_CORRUPT",
+      `Wallet file at ${filePath} is not a valid v4 wallet. Expected { version: 2, secret: "suiprivkey1..." }. Move or delete the file, then run \`t2 init\`.`
+    );
+  }
+  const decoded = decodeSuiPrivateKey(parsed.secret);
   return Ed25519Keypair.fromSecretKey(decoded.secretKey);
 }
 async function walletExists(keyPath) {
@@ -1277,6 +1306,9 @@ function exportPrivateKey(keypair) {
 function getAddress(keypair) {
   return keypair.getPublicKey().toSuiAddress();
 }
+function isPlainKey(value) {
+  return typeof value === "object" && value !== null && value.version === 2 && typeof value.secret === "string";
+}
 
 // src/wallet/keypairSigner.ts
 var KeypairSigner = class {
@@ -1384,12 +1416,19 @@ async function buildSendTx({
   address,
   to,
   amount,
-  asset = "USDC"
+  asset
 }) {
+  assertAllowedAsset("send", asset);
   const recipient = validateAddress(to);
   const assetInfo = SUPPORTED_ASSETS[asset];
   if (!assetInfo) throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
   if (amount <= 0) throw new T2000Error("INVALID_AMOUNT", "Amount must be greater than zero");
+  if ((asset === "USDC" || asset === "USDsui") && amount < GASLESS_MIN_STABLE_AMOUNT) {
+    throw new T2000Error(
+      "INVALID_AMOUNT",
+      `Minimum gasless transfer is ${GASLESS_MIN_STABLE_AMOUNT} ${asset}. Got ${amount}.`
+    );
+  }
   const rawAmount = displayToRaw(amount, assetInfo.decimals);
   const tx = new Transaction();
   tx.setSender(address);
@@ -1401,8 +1440,20 @@ async function buildSendTx({
       required: amount
     });
   }
-  const sendCoin = asset === "SUI" ? tx.splitCoins(tx.gas, [rawAmount])[0] : coinWithBalance({ type: assetInfo.type, balance: rawAmount })(tx);
-  tx.transferObjects([sendCoin], recipient);
+  if (asset === "SUI") {
+    const [sendCoin] = tx.splitCoins(tx.gas, [rawAmount]);
+    tx.transferObjects([sendCoin], recipient);
+    return tx;
+  }
+  const coinType = GASLESS_STABLE_TYPES[asset];
+  tx.moveCall({
+    target: "0x2::balance::send_funds",
+    typeArguments: [coinType],
+    arguments: [
+      tx.balance({ type: coinType, balance: rawAmount }),
+      tx.pure.address(recipient)
+    ]
+  });
   return tx;
 }
 function addSendToTx(tx, coin, recipient) {
@@ -6372,8 +6423,7 @@ var ContactManager = class {
       "CONTACT_NOT_FOUND",
       `"${nameOrAddress}" is not a valid Sui address or saved contact.
   Use a SuiNS name (e.g. alex.sui \u2014 register at https://suins.io)
-  or paste the full Sui address (0x... 64 hex characters).
-  Legacy contact aliases: \`t2000 contacts add ${nameOrAddress} 0x...\` (deprecated).`
+  or paste the full Sui address (0x... 64 hex characters).`
     );
   }
   validateName(name) {
@@ -6445,20 +6495,16 @@ var T2000 = class _T2000 extends EventEmitter {
     return registry;
   }
   static async create(options = {}) {
-    const { keyPath, pin, passphrase, rpcUrl } = options;
-    const secret = pin ?? passphrase;
+    const { keyPath, rpcUrl } = options;
     const client = getSuiClient(rpcUrl);
     const exists = await walletExists(keyPath);
     if (!exists) {
       throw new T2000Error(
         "WALLET_NOT_FOUND",
-        "No wallet found. Run `t2000 init` to create one."
+        "No wallet found. Run `t2 init` to create one."
       );
     }
-    if (!secret) {
-      throw new T2000Error("WALLET_LOCKED", "PIN required to unlock wallet");
-    }
-    const keypair = await loadKey(secret, keyPath);
+    const keypair = await loadKey(void 0, keyPath);
     return new _T2000(keypair, client, void 0, DEFAULT_CONFIG_DIR);
   }
   static fromPrivateKey(privateKey, options = {}) {
@@ -6466,10 +6512,9 @@ var T2000 = class _T2000 extends EventEmitter {
     const client = getSuiClient(options.rpcUrl);
     return new _T2000(keypair, client);
   }
-  static async init(options) {
-    const secret = options.pin ?? options.passphrase ?? "";
+  static async init(options = {}) {
     const keypair = generateKeypair();
-    await saveKey(keypair, secret, options.keyPath);
+    await saveKey(keypair, void 0, options.keyPath);
     const client = getSuiClient();
     const agent = new _T2000(keypair, client, void 0, DEFAULT_CONFIG_DIR);
     const address = agent.address();
@@ -6497,7 +6542,7 @@ var T2000 = class _T2000 extends EventEmitter {
     this.enforcer.check({ operation: "pay", amount: options.maxPrice ?? 1 });
     const { Mppx } = await import('mppx/client');
     const { sui, USDC } = await import('@suimpp/mpp/client');
-    const { SuiGrpcClient } = await import('@mysten/sui/grpc');
+    const { SuiGrpcClient: SuiGrpcClient2 } = await import('@mysten/sui/grpc');
     const client = this.client;
     const signer = this._signer;
     const signerAddress = signer.getAddress();
@@ -6505,7 +6550,7 @@ var T2000 = class _T2000 extends EventEmitter {
     let gasCostSui = 0;
     const network = client.network === "testnet" ? "testnet" : "mainnet";
     const grpcBaseUrl = network === "testnet" ? "https://fullnode.testnet.sui.io" : "https://fullnode.mainnet.sui.io";
-    const grpcClient = new SuiGrpcClient({ baseUrl: grpcBaseUrl, network });
+    const grpcClient = new SuiGrpcClient2({ baseUrl: grpcBaseUrl, network });
     const mppx = Mppx.create({
       polyfill: false,
       methods: [sui({
@@ -6688,23 +6733,52 @@ var T2000 = class _T2000 extends EventEmitter {
   address() {
     return this._address;
   }
+  /**
+   * Send `amount` of `asset` to `to` (hex address, SuiNS name, or
+   * `@audric` handle / saved contact).
+   *
+   * [v4.0 Phase A Day 2 — SPEC_AGENT_WALLET_GREENFIELD §A]
+   *
+   * **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.
+   *
+   * Submission stays on the JSON-RPC client (the rest of the SDK
+   * expects JSON-RPC for read paths, and Sui's docs explicitly support
+   * the "build via gRPC, execute via JSON-RPC" hybrid).
+   */
   async send(params) {
     this.enforcer.assertNotLocked();
-    const asset = params.asset ?? "USDC";
-    if (!(asset in SUPPORTED_ASSETS)) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
+    const asset = params.asset;
+    if (!asset) {
+      throw new T2000Error(
+        "INVALID_ASSET",
+        "send() requires an explicit asset. Use one of: USDC, USDsui, SUI."
+      );
     }
+    assertAllowedAsset("send", asset);
+    const sendableAsset = asset;
     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 gasResult = await executeTx(
       this.client,
       this._signer,
-      () => buildSendTx({ client: this.client, address: this._address, to: sendTo, amount: sendAmount, asset })
+      () => buildSendTx({ client: this.client, address: this._address, to: sendTo, amount: sendAmount, asset: sendableAsset }),
+      { buildClient }
     );
     this.enforcer.recordUsage(sendAmount);
     const balance = await this.balance();
-    this.emitBalanceChange(asset, sendAmount, "send", gasResult.digest);
+    this.emitBalanceChange(sendableAsset, sendAmount, "send", gasResult.digest);
     return {
       success: true,
       tx: gasResult.digest,
@@ -6814,11 +6888,12 @@ var T2000 = class _T2000 extends EventEmitter {
     };
   }
   /**
-   * [SPEC_AGENTIC_STACK P1 / SDK F2 (CLI rename support) — 2026-05-25]
-   * Preferred alias of `deposit()`. The CLI surface is `t2000 fund` post-Phase 1
-   * (more intuitive than "deposit" which sounds like a NAVI lending action).
-   * `deposit()` stays as the canonical method name for back-compat; it is NOT
-   * deprecated. This wrapper exists so SDK consumers can mirror CLI naming.
+   * [SPEC_AGENTIC_STACK P1 / SDK F2 — 2026-05-25; refreshed S.342 / 2026-05-26]
+   * Preferred alias of `deposit()`. Was introduced to mirror the v3 `t2000 fund`
+   * CLI command; the v4 CLI surface is `t2 receive` (deleted `fund` in the
+   * S.332 bulk cut). `deposit()` stays as the canonical method name for
+   * back-compat; `fund()` stays as a programmatic alias for audric + other
+   * SDK consumers that prefer the verb.
    */
   async fund() {
     return this.deposit();
@@ -7153,7 +7228,7 @@ var T2000 = class _T2000 extends EventEmitter {
     const adapter = await this.resolveLending(params.protocol, asset, "borrow");
     const maxResult = await adapter.maxBorrow(this._address, asset);
     if (maxResult.maxAmount <= 0) {
-      throw new T2000Error("NO_COLLATERAL", "No collateral deposited. Save first with `t2000 save <amount>`.");
+      throw new T2000Error("NO_COLLATERAL", "No collateral deposited. Make a save deposit first.");
     }
     if (params.amount > maxResult.maxAmount) {
       throw new T2000Error("HEALTH_FACTOR_TOO_LOW", `Max safe borrow: $${maxResult.maxAmount.toFixed(2)}. Only savings deposits count as borrowable collateral.`, {
@@ -7911,34 +7986,68 @@ var WRITE_APPENDER_REGISTRY = {
   },
   send_transfer: async (tx, input, ctx) => {
     const recipient = validateAddress(input.to);
-    const asset = input.asset ?? "USDC";
-    const assetInfo = SUPPORTED_ASSETS[asset];
-    if (!assetInfo) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
+    if (!input.asset) {
+      throw new T2000Error(
+        "INVALID_ASSET",
+        "send_transfer requires an explicit asset. Use one of: USDC, USDsui, SUI."
+      );
     }
+    assertAllowedAsset("send", input.asset);
+    const asset = input.asset;
+    const assetInfo = SUPPORTED_ASSETS[asset];
     if (input.amount <= 0) {
       throw new T2000Error("INVALID_AMOUNT", "Send amount must be greater than zero");
     }
     const rawAmount = BigInt(Math.floor(input.amount * 10 ** assetInfo.decimals));
-    let coin;
-    let effectiveRaw;
     if (ctx.chainedCoin) {
-      coin = ctx.chainedCoin;
-      effectiveRaw = rawAmount;
-    } else if (asset === "SUI") {
+      addSendToTx(tx, ctx.chainedCoin, recipient);
+      return {
+        preview: {
+          toolName: "send_transfer",
+          effectiveAmount: Number(rawAmount) / 10 ** assetInfo.decimals,
+          recipient,
+          asset
+        }
+      };
+    }
+    if (asset === "SUI") {
       const result = await selectSuiCoin(tx, ctx.client, ctx.sender, rawAmount, ctx.sponsoredContext);
-      coin = result.coin;
-      effectiveRaw = result.effectiveAmount;
-    } else {
-      const result = await selectAndSplitCoin(tx, ctx.client, ctx.sender, assetInfo.type, rawAmount);
-      coin = result.coin;
-      effectiveRaw = result.effectiveAmount;
+      addSendToTx(tx, result.coin, recipient);
+      return {
+        preview: {
+          toolName: "send_transfer",
+          effectiveAmount: Number(result.effectiveAmount) / 10 ** assetInfo.decimals,
+          recipient,
+          asset
+        }
+      };
     }
-    addSendToTx(tx, coin, recipient);
+    if (input.amount < GASLESS_MIN_STABLE_AMOUNT) {
+      throw new T2000Error(
+        "INVALID_AMOUNT",
+        `Minimum gasless transfer is ${GASLESS_MIN_STABLE_AMOUNT} ${asset}. Got ${input.amount}.`
+      );
+    }
+    const balanceResp = await ctx.client.getBalance({ owner: ctx.sender, coinType: assetInfo.type });
+    if (BigInt(balanceResp.totalBalance) < rawAmount) {
+      throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${asset} balance`, {
+        available: Number(balanceResp.totalBalance) / 10 ** assetInfo.decimals,
+        required: input.amount
+      });
+    }
+    const coinType = GASLESS_STABLE_TYPES[asset];
+    tx.moveCall({
+      target: "0x2::balance::send_funds",
+      typeArguments: [coinType],
+      arguments: [
+        tx.balance({ type: coinType, balance: rawAmount }),
+        tx.pure.address(recipient)
+      ]
+    });
     return {
       preview: {
         toolName: "send_transfer",
-        effectiveAmount: Number(effectiveRaw) / 10 ** assetInfo.decimals,
+        effectiveAmount: Number(rawAmount) / 10 ** assetInfo.decimals,
         recipient,
         asset
       }
@@ -8013,24 +8122,40 @@ var WRITE_APPENDER_REGISTRY = {
 function deriveAllowedAddressesFromPtb(tx) {
   const addresses = /* @__PURE__ */ new Set();
   const data = tx.getData();
-  for (const cmd of data.commands) {
-    const transferCmd = cmd.TransferObjects;
-    if (!transferCmd) continue;
-    const addressArg = transferCmd.address;
-    if (!addressArg) continue;
-    const addressInputIndex = addressArg.Input;
-    if (addressInputIndex === void 0) continue;
-    const input = data.inputs[addressInputIndex];
-    if (!input) continue;
+  const addAddressFromInput = (inputIndex) => {
+    if (inputIndex === void 0) return;
+    const input = data.inputs[inputIndex];
+    if (!input) return;
     const pureBytes = input.Pure?.bytes;
-    if (!pureBytes) continue;
+    if (!pureBytes) return;
     try {
       const bytes = base64ToBytes(pureBytes);
-      if (bytes.length !== 32) continue;
+      if (bytes.length !== 32) return;
       const hex = "0x" + Array.from(bytes).map((b2) => b2.toString(16).padStart(2, "0")).join("");
       addresses.add(hex);
     } catch {
     }
+  };
+  for (const cmd of data.commands) {
+    const transferCmd = cmd.TransferObjects;
+    if (transferCmd) {
+      const addressArg = transferCmd.address;
+      const addressInputIndex = addressArg?.Input;
+      addAddressFromInput(addressInputIndex);
+      continue;
+    }
+    const moveCall = cmd.MoveCall;
+    if (moveCall) {
+      const mc = moveCall;
+      const isBalanceSendFunds = mc.module === "balance" && mc.function === "send_funds";
+      const isCoinSendFunds = mc.module === "coin" && mc.function === "send_funds";
+      if (isBalanceSendFunds || isCoinSendFunds) {
+        const args = mc.arguments ?? [];
+        const recipientArg = args[1];
+        addAddressFromInput(recipientArg?.Input);
+      }
+      continue;
+    }
   }
   return Array.from(addresses);
 }
@@ -8356,6 +8481,6 @@ function displayHandle(label) {
   (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
-export { ALL_NAVI_ASSETS, AUDRIC_PARENT_NAME, AUDRIC_PARENT_NFT_ID, BORROW_FEE_BPS, BPS_DENOMINATOR, CETUS_USDC_SUI_POOL, CLOCK_ID, COIN_REGISTRY, ContactManager, DEFAULT_NETWORK, DEFAULT_SAFEGUARD_CONFIG, ETH_TYPE, GAS_RESERVE_MIN, HF_CRITICAL_THRESHOLD, HF_WARN_THRESHOLD, IKA_TYPE, InvalidAddressError, KNOWN_TARGETS, KeypairSigner, LABEL_PATTERNS, LOFI_TYPE, MANIFEST_TYPE, MIST_PER_SUI, NAVX_TYPE, NaviAdapter, OPERATION_ASSETS, OUTBOUND_OPS, OVERLAY_FEE_RATE, ProtocolRegistry, SAVEABLE_ASSETS, SAVE_FEE_BPS, SPONSORED_PYTH_DEPENDENT_PROVIDERS, STABLE_ASSETS, SUINS_NAME_REGEX, SUI_ADDRESS_REGEX, SUI_ADDRESS_STRICT_REGEX, SUI_DECIMALS, SUI_TYPE, SUPPORTED_ASSETS, SafeguardEnforcer, SafeguardError, SuinsNotRegisteredError, SuinsRpcError, T2000, T2000Error, T2000_OVERLAY_FEE_WALLET, TOKEN_MAP, USDC_DECIMALS, USDC_TYPE, USDE_TYPE, USDSUI_TYPE, USDT_TYPE, WAL_TYPE, WBTC_TYPE, WRITE_APPENDER_REGISTRY, ZkLoginSigner, addClaimRewardsToTx, addFeeTransfer, addSendToTx, addSwapToTx, aggregateClaimableRewards, allDescriptors, assertAllowedAsset, buildAddLeafTx, buildClaimRewardsTx, buildHarvestRewardsTx, buildRevokeLeafTx, buildSendTx, buildSwapTx, calculateFee, classifyAction, classifyLabel, classifyTransaction, composeTx, deriveAllowedAddressesFromPtb, deserializeCetusRoute, displayHandle, exportPrivateKey, extractAllUserLegs, extractTransferDetails, extractTxCommands, extractTxSender, fallbackLabel, fetchAllCoins, findSwapRoute, formatAssetAmount, formatSui, formatUsd, fullHandle, generateKeypair, getAddress, getCoinMeta, getDecimals, getDecimalsForCoinType, getFinancialSummary, getPendingRewards, getPendingRewardsByAddress, getRates, getSponsoredSwapProviders, getSwapQuote, getTier, isAllowedAsset, isCetusRouteFresh, isInRegistry, isSupported, isTier1, isTier2, keypairFromPrivateKey, loadKey, looksLikeSuiNs, mapMoveAbortCode, mapWalletError, mistToSui, naviDescriptor, normalizeAddressInput, normalizeAsset, normalizeCoinType, parseSuiRpcTx, queryHistory, queryTransaction, rawToStable, rawToUsdc, refineLendingLabel, resolveAddressToSuinsViaRpc, resolveSuinsViaRpc, resolveSymbol, resolveTokenType, saveKey, selectAndSplitCoin, selectSuiCoin, serializeCetusRoute, simulateTransaction, stableToRaw, suiToMist, throwIfSimulationFailed, truncateAddress, usdcToRaw, validateAddress, validateLabel, verifyCetusRouteCoinMatch, walletExists };
+export { ALL_NAVI_ASSETS, AUDRIC_PARENT_NAME, AUDRIC_PARENT_NFT_ID, BORROW_FEE_BPS, BPS_DENOMINATOR, CETUS_USDC_SUI_POOL, CLOCK_ID, COIN_REGISTRY, ContactManager, DEFAULT_GRPC_URL, DEFAULT_NETWORK, DEFAULT_SAFEGUARD_CONFIG, ETH_TYPE, GASLESS_MIN_STABLE_AMOUNT, GASLESS_STABLE_TYPES, GAS_RESERVE_MIN, HF_CRITICAL_THRESHOLD, HF_WARN_THRESHOLD, IKA_TYPE, InvalidAddressError, KNOWN_TARGETS, KeypairSigner, LABEL_PATTERNS, LOFI_TYPE, MANIFEST_TYPE, MIST_PER_SUI, NAVX_TYPE, NaviAdapter, OPERATION_ASSETS, OUTBOUND_OPS, OVERLAY_FEE_RATE, ProtocolRegistry, SAVEABLE_ASSETS, SAVE_FEE_BPS, SENDABLE_ASSETS, SPONSORED_PYTH_DEPENDENT_PROVIDERS, STABLE_ASSETS, SUINS_NAME_REGEX, SUI_ADDRESS_REGEX, SUI_ADDRESS_STRICT_REGEX, SUI_DECIMALS, SUI_TYPE, SUPPORTED_ASSETS, SafeguardEnforcer, SafeguardError, SuinsNotRegisteredError, SuinsRpcError, T2000, T2000Error, T2000_OVERLAY_FEE_WALLET, TOKEN_MAP, USDC_DECIMALS, USDC_TYPE, USDE_TYPE, USDSUI_TYPE, USDT_TYPE, WAL_TYPE, WBTC_TYPE, WRITE_APPENDER_REGISTRY, ZkLoginSigner, addClaimRewardsToTx, addFeeTransfer, addSendToTx, addSwapToTx, aggregateClaimableRewards, allDescriptors, assertAllowedAsset, buildAddLeafTx, buildClaimRewardsTx, buildHarvestRewardsTx, buildRevokeLeafTx, buildSendTx, buildSwapTx, calculateFee, classifyAction, classifyLabel, classifyTransaction, composeTx, createSuiClient, deriveAllowedAddressesFromPtb, deserializeCetusRoute, displayHandle, exportPrivateKey, extractAllUserLegs, extractTransferDetails, extractTxCommands, extractTxSender, fallbackLabel, fetchAllCoins, findSwapRoute, formatAssetAmount, formatSui, formatUsd, fullHandle, generateKeypair, getAddress, getCoinMeta, getDecimals, getDecimalsForCoinType, getFinancialSummary, getPendingRewards, getPendingRewardsByAddress, getRates, getSponsoredSwapProviders, getSuiClient, getSuiGrpcClient, getSwapQuote, getTier, isAllowedAsset, isCetusRouteFresh, isInRegistry, isSupported, isTier1, isTier2, keypairFromPrivateKey, loadKey, looksLikeSuiNs, mapMoveAbortCode, mapWalletError, mistToSui, naviDescriptor, normalizeAddressInput, normalizeAsset, normalizeCoinType, parseSuiRpcTx, queryHistory, queryTransaction, rawToStable, rawToUsdc, refineLendingLabel, resolveAddressToSuinsViaRpc, resolveSuinsViaRpc, resolveSymbol, resolveTokenType, saveBech32, saveKey, selectAndSplitCoin, selectSuiCoin, serializeCetusRoute, simulateTransaction, stableToRaw, suiToMist, throwIfSimulationFailed, truncateAddress, usdcToRaw, validateAddress, validateLabel, verifyCetusRouteCoinMatch, walletExists };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map