@t2000/sdk 3.2.0 → 4.0.0

package/dist/index.js

@@ -1,13 +1,13 @@
-import { Transaction, coinWithBalance } from '@mysten/sui/transactions';
+import { coinWithBalance, Transaction } from '@mysten/sui/transactions';
 import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
 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';
@@ -645,155 +645,6 @@ var require_lodash = __commonJS({
   }
 });
 
-// src/protocols/volo.ts
-var volo_exports = {};
-__export(volo_exports, {
-  MIN_STAKE_MIST: () => MIN_STAKE_MIST,
-  SUI_SYSTEM_STATE: () => SUI_SYSTEM_STATE,
-  VOLO_METADATA: () => VOLO_METADATA,
-  VOLO_PKG: () => VOLO_PKG,
-  VOLO_POOL: () => VOLO_POOL,
-  VSUI_TYPE: () => VSUI_TYPE,
-  addStakeVSuiToTx: () => addStakeVSuiToTx,
-  addUnstakeVSuiToTx: () => addUnstakeVSuiToTx,
-  buildStakeVSuiTx: () => buildStakeVSuiTx,
-  buildUnstakeVSuiTx: () => buildUnstakeVSuiTx,
-  getVoloStats: () => getVoloStats
-});
-async function getVoloStats() {
-  const res = await fetch(VOLO_STATS_URL, {
-    signal: AbortSignal.timeout(8e3)
-  });
-  if (!res.ok) {
-    throw new Error(`VOLO stats API error: HTTP ${res.status}`);
-  }
-  const data = await res.json();
-  const d = data.data ?? data;
-  return {
-    apy: d.apy ?? 0,
-    exchangeRate: d.exchange_rate ?? d.exchangeRate ?? 1,
-    tvl: d.tvl ?? 0
-  };
-}
-async function buildStakeVSuiTx(_client, address, amountMist) {
-  if (amountMist < MIN_STAKE_MIST) {
-    throw new Error(`Minimum stake is 1 SUI (${MIN_STAKE_MIST} MIST). Got: ${amountMist}`);
-  }
-  const tx = new Transaction();
-  tx.setSender(address);
-  const [suiCoin] = tx.splitCoins(tx.gas, [amountMist]);
-  const [vSuiCoin] = tx.moveCall({
-    target: `${VOLO_PKG}::stake_pool::stake`,
-    arguments: [
-      tx.object(VOLO_POOL),
-      tx.object(VOLO_METADATA),
-      tx.object(SUI_SYSTEM_STATE),
-      suiCoin
-    ]
-  });
-  tx.transferObjects([vSuiCoin], address);
-  return tx;
-}
-async function buildUnstakeVSuiTx(client, address, amountMist) {
-  const balResp = await client.getBalance({ owner: address, coinType: VSUI_TYPE });
-  const totalBalance = BigInt(balResp.totalBalance);
-  if (totalBalance === 0n) {
-    throw new Error("No vSUI found in wallet.");
-  }
-  const tx = new Transaction();
-  tx.setSender(address);
-  const requested = amountMist === "all" ? totalBalance : amountMist;
-  if (requested > totalBalance) {
-    throw new Error(`Insufficient vSUI: need ${requested} MIST, have ${totalBalance}`);
-  }
-  const vSuiCoin = coinWithBalance({ type: VSUI_TYPE, balance: requested })(tx);
-  const [suiCoin] = tx.moveCall({
-    target: `${VOLO_PKG}::stake_pool::unstake`,
-    arguments: [
-      tx.object(VOLO_POOL),
-      tx.object(VOLO_METADATA),
-      tx.object(SUI_SYSTEM_STATE),
-      vSuiCoin
-    ]
-  });
-  tx.transferObjects([suiCoin], address);
-  return tx;
-}
-async function addStakeVSuiToTx(tx, client, address, input) {
-  if (input.amountMist < MIN_STAKE_MIST) {
-    throw new Error(`Minimum stake is 1 SUI (${MIN_STAKE_MIST} MIST). Got: ${input.amountMist}`);
-  }
-  let suiCoin;
-  if (input.inputCoin) {
-    suiCoin = input.inputCoin;
-  } else {
-    const balResp = await client.getBalance({ owner: address, coinType: SUI_TYPE });
-    const totalBalance = BigInt(balResp.totalBalance);
-    if (totalBalance < input.amountMist) {
-      throw new Error(`Insufficient SUI: need ${input.amountMist} MIST, have ${totalBalance}`);
-    }
-    suiCoin = coinWithBalance({
-      type: SUI_TYPE,
-      balance: input.amountMist,
-      useGasCoin: false
-    })(tx);
-  }
-  const [vSuiCoin] = tx.moveCall({
-    target: `${VOLO_PKG}::stake_pool::stake`,
-    arguments: [
-      tx.object(VOLO_POOL),
-      tx.object(VOLO_METADATA),
-      tx.object(SUI_SYSTEM_STATE),
-      suiCoin
-    ]
-  });
-  return { coin: vSuiCoin, effectiveAmountMist: input.amountMist };
-}
-async function addUnstakeVSuiToTx(tx, client, address, input) {
-  let vSuiCoin;
-  if (input.inputCoin) {
-    if (input.amountMist === "all") {
-      vSuiCoin = input.inputCoin;
-    } else {
-      [vSuiCoin] = tx.splitCoins(input.inputCoin, [input.amountMist]);
-    }
-  } else {
-    const balResp = await client.getBalance({ owner: address, coinType: VSUI_TYPE });
-    const totalBalance = BigInt(balResp.totalBalance);
-    if (totalBalance === 0n) {
-      throw new Error("No vSUI found in wallet.");
-    }
-    const requested = input.amountMist === "all" ? totalBalance : input.amountMist;
-    if (requested > totalBalance) {
-      throw new Error(`Insufficient vSUI: need ${requested} MIST, have ${totalBalance}`);
-    }
-    vSuiCoin = coinWithBalance({ type: VSUI_TYPE, balance: requested })(tx);
-  }
-  const [suiCoin] = tx.moveCall({
-    target: `${VOLO_PKG}::stake_pool::unstake`,
-    arguments: [
-      tx.object(VOLO_POOL),
-      tx.object(VOLO_METADATA),
-      tx.object(SUI_SYSTEM_STATE),
-      vSuiCoin
-    ]
-  });
-  return { coin: suiCoin, effectiveAmountMist: input.amountMist };
-}
-var VOLO_PKG, VOLO_POOL, VOLO_METADATA, VSUI_TYPE, SUI_SYSTEM_STATE, MIN_STAKE_MIST, VOLO_STATS_URL;
-var init_volo = __esm({
-  "src/protocols/volo.ts"() {
-    init_token_registry();
-    VOLO_PKG = "0x68d22cf8bdbcd11ecba1e094922873e4080d4d11133e2443fddda0bfd11dae20";
-    VOLO_POOL = "0x2d914e23d82fedef1b5f56a32d5c64bdcc3087ccfea2b4d6ea51a71f587840e5";
-    VOLO_METADATA = "0x680cd26af32b2bde8d3361e804c53ec1d1cfe24c7f039eb7f549e8dfde389a60";
-    VSUI_TYPE = "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT";
-    SUI_SYSTEM_STATE = "0x05";
-    MIN_STAKE_MIST = 1000000000n;
-    VOLO_STATS_URL = "https://open-api.naviprotocol.io/api/volo/stats";
-  }
-});
-
 // src/wallet/coinSelection.ts
 var coinSelection_exports = {};
 __export(coinSelection_exports, {
@@ -1271,7 +1122,7 @@ var OPERATION_ASSETS = {
   borrow: ["USDC", "USDsui"],
   withdraw: "*",
   repay: "*",
-  send: "*",
+  send: ["USDC", "USDsui", "SUI"],
   swap: "*"
 };
 function isAllowedAsset(op, asset) {
@@ -1285,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);
@@ -1329,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();
 }
@@ -1383,7 +1229,7 @@ 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);
@@ -1392,12 +1238,34 @@ 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: keypair.getSecretKey()
+  };
+  await writeFile(filePath, JSON.stringify(payload, null, 2), { mode: 384 });
   return filePath;
 }
-async function loadKey(passphrase, keyPath) {
+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);
+    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 };
+  await writeFile(filePath, JSON.stringify(payload, null, 2), { mode: 384 });
+  return filePath;
+}
+async function loadKey(_passphrase, keyPath) {
   const filePath = expandPath(keyPath ?? DEFAULT_KEY_PATH);
   let content;
   try {
@@ -1405,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) {
@@ -1426,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 {
@@ -1533,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);
@@ -1550,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) {
@@ -6521,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) {
@@ -6594,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 = {}) {
@@ -6615,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();
@@ -6646,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();
@@ -6654,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({
@@ -6699,51 +6595,14 @@ var T2000 = class _T2000 extends EventEmitter {
       receipt: paymentDigest ? { reference: paymentDigest, timestamp: (/* @__PURE__ */ new Date()).toISOString() } : void 0
     };
   }
-  // -- VOLO vSUI Staking --
-  async stakeVSui(params) {
-    this.enforcer.assertNotLocked();
-    const { buildStakeVSuiTx: buildStakeVSuiTx2, getVoloStats: getVoloStats2 } = await Promise.resolve().then(() => (init_volo(), volo_exports));
-    const amountMist = BigInt(Math.floor(params.amount * Number(MIST_PER_SUI)));
-    const stats = await getVoloStats2();
-    const gasResult = await executeTx(this.client, this._signer, async () => {
-      return buildStakeVSuiTx2(this.client, this._address, amountMist);
-    });
-    const vSuiReceived = params.amount / stats.exchangeRate;
-    return {
-      success: true,
-      tx: gasResult.digest,
-      amountSui: params.amount,
-      vSuiReceived,
-      apy: stats.apy,
-      gasCost: gasResult.gasCostSui
-    };
-  }
-  async unstakeVSui(params) {
-    this.enforcer.assertNotLocked();
-    const { buildUnstakeVSuiTx: buildUnstakeVSuiTx2, getVoloStats: getVoloStats2, VSUI_TYPE: VSUI_TYPE2 } = await Promise.resolve().then(() => (init_volo(), volo_exports));
-    let amountMist;
-    let vSuiAmount;
-    if (params.amount === "all") {
-      amountMist = "all";
-      const bal = await this.client.getBalance({ owner: this._address, coinType: VSUI_TYPE2 });
-      vSuiAmount = Number(bal.totalBalance) / 1e9;
-    } else {
-      amountMist = BigInt(Math.floor(params.amount * 1e9));
-      vSuiAmount = params.amount;
-    }
-    const stats = await getVoloStats2();
-    const gasResult = await executeTx(this.client, this._signer, async () => {
-      return buildUnstakeVSuiTx2(this.client, this._address, amountMist);
-    });
-    const suiReceived = vSuiAmount * stats.exchangeRate;
-    return {
-      success: true,
-      tx: gasResult.digest,
-      vSuiAmount,
-      suiReceived,
-      gasCost: gasResult.gasCostSui
-    };
-  }
+  // [S.323 / 2026-05-25] VOLO vSUI staking surfaces removed (full cut).
+  // Engine cut Volo in S.277; SDK + CLI + MCP followed in S.323 because the
+  // product surface (five products: Passport / Intelligence / Finance / Pay
+  // / Store) doesn't include a staking primitive. vSUI still appears in the
+  // codebase as a passive token (NAVI reward rewards, Cetus swap routing),
+  // but there is no longer any way to MINT or REDEEM vSUI through t2000.
+  // History: see spec/archive/v07e/AUDIT_V07E_EARNS_ITS_KEEP_2026-05-23.md
+  // and the S.323 build-tracker entry.
   // -- Swap --
   async swap(params) {
     this.enforcer.assertNotLocked();
@@ -6874,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,
@@ -7000,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();
@@ -7339,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.`, {
@@ -7970,7 +7859,6 @@ async function buildHarvestRewardsTx(client, address, options = {}) {
 
 // src/composeTx.ts
 init_cetus_swap();
-init_volo();
 init_coinSelection();
 init_token_registry();
 init_errors();
@@ -8098,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
+        }
+      };
+    }
+    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
+      });
     }
-    addSendToTx(tx, coin, recipient);
+    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
       }
@@ -8194,63 +8116,46 @@ var WRITE_APPENDER_REGISTRY = {
         expectedUsdcDeposited: plan.expectedUsdcDeposited
       }
     };
-  },
-  volo_stake: async (tx, input, ctx) => {
-    if (input.amountSui <= 0) {
-      throw new T2000Error("INVALID_AMOUNT", "Stake amount must be greater than zero");
-    }
-    const amountMist = BigInt(Math.floor(input.amountSui * 1e9));
-    const result = await addStakeVSuiToTx(tx, ctx.client, ctx.sender, {
-      amountMist,
-      inputCoin: ctx.chainedCoin
-    });
-    if (!ctx.isOutputConsumed) {
-      tx.transferObjects([result.coin], ctx.sender);
-    }
-    return {
-      preview: { toolName: "volo_stake", effectiveAmountMist: result.effectiveAmountMist },
-      outputCoin: result.coin
-    };
-  },
-  volo_unstake: async (tx, input, ctx) => {
-    const amountMist = input.amountVSui === "all" ? "all" : BigInt(Math.floor(input.amountVSui * 1e9));
-    if (amountMist !== "all" && amountMist <= 0n) {
-      throw new T2000Error("INVALID_AMOUNT", "Unstake amount must be greater than zero");
-    }
-    const result = await addUnstakeVSuiToTx(tx, ctx.client, ctx.sender, {
-      amountMist,
-      inputCoin: ctx.chainedCoin
-    });
-    if (!ctx.isOutputConsumed) {
-      tx.transferObjects([result.coin], ctx.sender);
-    }
-    return {
-      preview: { toolName: "volo_unstake", effectiveAmountMist: result.effectiveAmountMist },
-      outputCoin: result.coin
-    };
   }
+  // [S.323 / 2026-05-25] volo_stake / volo_unstake appenders removed.
 };
 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);
 }
@@ -8289,7 +8194,7 @@ async function composeTx(opts) {
     if (producer.toolName === "save_deposit" || producer.toolName === "repay_debt" || producer.toolName === "send_transfer" || producer.toolName === "claim_rewards") {
       throw new T2000Error(
         "CHAIN_MODE_INVALID",
-        `Step ${i} (${step.toolName}) references step ${idx} (${producer.toolName}) as producer, but '${producer.toolName}' is a terminal consumer that does not produce a chainable coin handle. Allowed producers: withdraw, borrow, swap_execute, volo_stake, volo_unstake.`
+        `Step ${i} (${step.toolName}) references step ${idx} (${producer.toolName}) as producer, but '${producer.toolName}' is a terminal consumer that does not produce a chainable coin handle. Allowed producers: withdraw, borrow, swap_execute.`
       );
     }
     consumedSteps.add(idx);
@@ -8509,7 +8414,6 @@ function parseMoveAbort(errorStr) {
 init_swap_quote();
 init_cetus_swap();
 init_token_registry();
-init_volo();
 var AUDRIC_PARENT_NAME = "audric.sui";
 var AUDRIC_PARENT_NFT_ID = "0x070456e283ec988b6302bdd6cc5172bbdcb709998cf116586fb98d19b0870198";
 var LABEL_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
@@ -8577,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, VOLO_METADATA, VOLO_PKG, VOLO_POOL, VSUI_TYPE, WAL_TYPE, WBTC_TYPE, WRITE_APPENDER_REGISTRY, ZkLoginSigner, addClaimRewardsToTx, addFeeTransfer, addSendToTx, addStakeVSuiToTx, addSwapToTx, addUnstakeVSuiToTx, aggregateClaimableRewards, allDescriptors, assertAllowedAsset, buildAddLeafTx, buildClaimRewardsTx, buildHarvestRewardsTx, buildRevokeLeafTx, buildSendTx, buildStakeVSuiTx, buildSwapTx, buildUnstakeVSuiTx, 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, getVoloStats, 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