@t2000/sdk 5.5.1 → 5.6.1

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var utils = require('@mysten/sui/utils');
 var transactions = require('@mysten/sui/transactions');
 var aggregatorSdk = require('@cetusprotocol/aggregator-sdk');
 var BN = require('bn.js');
@@ -7,7 +8,6 @@ var eventemitter3 = require('eventemitter3');
 var paymentKit = require('@mysten/payment-kit');
 var grpc = require('@mysten/sui/grpc');
 var graphql = require('@mysten/sui/graphql');
-var utils = require('@mysten/sui/utils');
 var ed25519 = require('@mysten/sui/keypairs/ed25519');
 var cryptography = require('@mysten/sui/cryptography');
 var promises = require('fs/promises');
@@ -118,6 +118,37 @@ var init_errors = __esm({
     };
   }
 });
+function preflightFail(code, error) {
+  return { valid: false, code, error };
+}
+function checkPositiveAmount(amount, label = "Amount", max = exports.PREFLIGHT_MAX_AMOUNT) {
+  if (typeof amount !== "number" || !Number.isFinite(amount)) {
+    return preflightFail("INVALID_AMOUNT", `${label} must be a finite number`);
+  }
+  if (amount <= 0) {
+    return preflightFail("INVALID_AMOUNT", `${label} must be greater than zero`);
+  }
+  if (amount > max) {
+    return preflightFail("INVALID_AMOUNT", `${label} ${amount} exceeds the sane maximum (${max})`);
+  }
+  return exports.PREFLIGHT_OK;
+}
+function checkSuiAddress(address, label = "recipient") {
+  try {
+    if (typeof address === "string" && address.trim() !== "" && utils.isValidSuiAddress(utils.normalizeSuiAddress(address))) {
+      return exports.PREFLIGHT_OK;
+    }
+  } catch {
+  }
+  return preflightFail("INVALID_ADDRESS", `Invalid ${label} address: ${address}`);
+}
+exports.PREFLIGHT_MAX_AMOUNT = void 0; exports.PREFLIGHT_OK = void 0;
+var init_preflight = __esm({
+  "src/preflight.ts"() {
+    exports.PREFLIGHT_MAX_AMOUNT = 1e6;
+    exports.PREFLIGHT_OK = { valid: true };
+  }
+});
 
 // src/token-registry.ts
 var token_registry_exports = {};
@@ -244,6 +275,7 @@ var init_token_registry = __esm({
 // src/wallet/coinSelection.ts
 var coinSelection_exports = {};
 __export(coinSelection_exports, {
+  buildCoinToAddressBalanceMigration: () => buildCoinToAddressBalanceMigration,
   fetchAllCoins: () => fetchAllCoins,
   selectAndSplitCoin: () => selectAndSplitCoin,
   selectSuiCoin: () => selectSuiCoin
@@ -357,6 +389,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 exports.T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${coinType} coin objects to migrate`, {
+      available: migratedRaw.toString(),
+      required: minAmount.toString()
+    });
+  }
+  const tx = new transactions.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_TYPE2 } = await Promise.resolve().then(() => (init_token_registry(), token_registry_exports));
@@ -382,10 +440,28 @@ __export(cetus_swap_exports, {
   findSwapRoute: () => findSwapRoute,
   isCetusRouteFresh: () => isCetusRouteFresh,
   isPrecomputedRouteCompatibleWithProviders: () => isPrecomputedRouteCompatibleWithProviders,
+  preflightSwap: () => preflightSwap,
   resolveTokenType: () => resolveTokenType,
   serializeCetusRoute: () => serializeCetusRoute,
   verifyCetusRouteCoinMatch: () => verifyCetusRouteCoinMatch
 });
+function preflightSwap(input) {
+  if (typeof input.from !== "string" || input.from.trim() === "") {
+    return preflightFail("INVALID_ASSET", "A `from` token is required to swap");
+  }
+  if (typeof input.to !== "string" || input.to.trim() === "") {
+    return preflightFail("INVALID_ASSET", "A `to` token is required to swap");
+  }
+  const amountCheck = checkPositiveAmount(input.amount, "Amount", Number.POSITIVE_INFINITY);
+  if (!amountCheck.valid) return amountCheck;
+  const resolvedFrom = resolveTokenType(input.from);
+  const resolvedTo = resolveTokenType(input.to);
+  const sameToken = input.from.trim() === input.to.trim() || resolvedFrom !== null && resolvedFrom === resolvedTo;
+  if (sameToken) {
+    return preflightFail("INVALID_ASSET", `Cannot swap ${input.from} to itself`);
+  }
+  return exports.PREFLIGHT_OK;
+}
 function serializeCetusRoute(route, context) {
   return {
     routerData: serializeRouterDataV3(route.routerData),
@@ -637,6 +713,7 @@ exports.OVERLAY_FEE_RATE = void 0; var clientCache;
 var init_cetus_swap = __esm({
   "src/protocols/cetus-swap.ts"() {
     init_token_registry();
+    init_preflight();
     init_token_registry();
     exports.OVERLAY_FEE_RATE = 1e-3;
     clientCache = /* @__PURE__ */ new Map();
@@ -1010,8 +1087,33 @@ async function executeTx(client, signer, buildTx, options = {}) {
 
 // src/wallet/pay.ts
 init_errors();
+init_preflight();
+function preflightPay(input) {
+  if (typeof input.url !== "string" || input.url.trim() === "") {
+    return preflightFail("FACILITATOR_REJECTION", "A target URL is required to pay");
+  }
+  let parsed;
+  try {
+    parsed = new URL(input.url);
+  } catch {
+    return preflightFail("FACILITATOR_REJECTION", `Invalid URL: ${input.url}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return preflightFail(
+      "FACILITATOR_REJECTION",
+      `URL must be http(s): got ${parsed.protocol}//`
+    );
+  }
+  if (input.maxPrice !== void 0) {
+    const priceCheck = checkPositiveAmount(input.maxPrice, "maxPrice");
+    if (!priceCheck.valid) return priceCheck;
+  }
+  return exports.PREFLIGHT_OK;
+}
 async function payWithMpp(args) {
   const { signer, client, options } = args;
+  const pf = preflightPay({ url: options.url, maxPrice: options.maxPrice });
+  if (!pf.valid) throw new exports.T2000Error(pf.code, pf.error);
   const method = (options.method ?? "GET").toUpperCase();
   const canHaveBody = method !== "GET" && method !== "HEAD";
   const reqInit = {
@@ -1091,40 +1193,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 import('@mysten/sui/transactions');
-  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) {
@@ -1246,6 +1334,25 @@ function normalizeAsset(input) {
 }
 
 // src/wallet/send.ts
+init_preflight();
+function preflightSend(input) {
+  try {
+    assertAllowedAsset("send", input.asset);
+  } catch (e) {
+    return preflightFail("INVALID_ASSET", e.message);
+  }
+  const amountCheck = checkPositiveAmount(input.amount);
+  if (!amountCheck.valid) return amountCheck;
+  if ((input.asset === "USDC" || input.asset === "USDsui") && input.amount < GASLESS_MIN_STABLE_AMOUNT) {
+    return preflightFail(
+      "INVALID_AMOUNT",
+      `Minimum gasless transfer is ${GASLESS_MIN_STABLE_AMOUNT} ${input.asset}. Got ${input.amount}.`
+    );
+  }
+  const addressCheck = checkSuiAddress(input.to);
+  if (!addressCheck.valid) return addressCheck;
+  return exports.PREFLIGHT_OK;
+}
 async function buildSendTx({
   client,
   address,
@@ -1253,17 +1360,11 @@ async function buildSendTx({
   amount,
   asset
 }) {
-  assertAllowedAsset("send", asset);
+  const pf = preflightSend({ to, amount, asset });
+  if (!pf.valid) throw new exports.T2000Error(pf.code, pf.error);
   const recipient = validateAddress(to);
   const assetInfo = SUPPORTED_ASSETS[asset];
   if (!assetInfo) throw new exports.T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
-  if (amount <= 0) throw new exports.T2000Error("INVALID_AMOUNT", "Amount must be greater than zero");
-  if ((asset === "USDC" || asset === "USDsui") && amount < GASLESS_MIN_STABLE_AMOUNT) {
-    throw new exports.T2000Error(
-      "INVALID_AMOUNT",
-      `Minimum gasless transfer is ${GASLESS_MIN_STABLE_AMOUNT} ${asset}. Got ${amount}.`
-    );
-  }
   const rawAmount = displayToRaw(amount, assetInfo.decimals);
   const tx = new transactions.Transaction();
   tx.setSender(address);
@@ -2059,7 +2160,9 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       amountUsd: approxUsdValue(params.from, params.amount) ?? 0,
       force: params.force
     });
-    const { findSwapRoute: findSwapRoute2, buildSwapTx: buildSwapTx2, resolveTokenType: resolveTokenType2 } = await Promise.resolve().then(() => (init_cetus_swap(), cetus_swap_exports));
+    const { findSwapRoute: findSwapRoute2, buildSwapTx: buildSwapTx2, resolveTokenType: resolveTokenType2, preflightSwap: preflightSwap2 } = await Promise.resolve().then(() => (init_cetus_swap(), cetus_swap_exports));
+    const pf = preflightSwap2({ from: params.from, to: params.to, amount: params.amount });
+    if (!pf.valid) throw new exports.T2000Error(pf.code, pf.error);
     const fromType = resolveTokenType2(params.from);
     const toType = resolveTokenType2(params.to);
     if (!fromType) throw new exports.T2000Error("ASSET_NOT_SUPPORTED", `Unknown token: ${params.from}. Provide the full coin type.`);
@@ -2789,6 +2892,9 @@ function displayHandle(label) {
   return `${label}@${parentDisplay}`;
 }
 
+// src/index.ts
+init_preflight();
+
 exports.AUDRIC_PARENT_NAME = AUDRIC_PARENT_NAME;
 exports.AUDRIC_PARENT_NFT_ID = AUDRIC_PARENT_NFT_ID;
 exports.CETUS_USDC_SUI_POOL = CETUS_USDC_SUI_POOL;
@@ -2830,6 +2936,8 @@ exports.buildAddLeafTx = buildAddLeafTx;
 exports.buildRevokeLeafTx = buildRevokeLeafTx;
 exports.buildSendTx = buildSendTx;
 exports.buildSwapTx = buildSwapTx;
+exports.checkPositiveAmount = checkPositiveAmount;
+exports.checkSuiAddress = checkSuiAddress;
 exports.classifyAction = classifyAction;
 exports.classifyLabel = classifyLabel;
 exports.classifyTransaction = classifyTransaction;
@@ -2877,6 +2985,11 @@ exports.normalizeAsset = normalizeAsset;
 exports.normalizeCoinType = normalizeCoinType;
 exports.parseSuiRpcTx = parseSuiRpcTx;
 exports.payWithMpp = payWithMpp;
+exports.preflightFail = preflightFail;
+exports.preflightPay = preflightPay;
+exports.preflightSend = preflightSend;
+exports.preflightSwap = preflightSwap;
+exports.queryBalance = queryBalance;
 exports.queryHistory = queryHistory;
 exports.queryTransaction = queryTransaction;
 exports.rawToStable = rawToStable;