@t2000/sdk 5.0.0 → 5.2.0

package/dist/index.cjs

@@ -576,8 +576,8 @@ async function addSwapToTx(tx, client, address, input) {
     inputCoin = result.coin;
     effectiveRaw = result.effectiveAmount;
   } else {
-    const { selectAndSplitCoin: selectAndSplitCoin3 } = await Promise.resolve().then(() => (init_coinSelection(), coinSelection_exports));
-    const result = await selectAndSplitCoin3(tx, client, address, fromType, requestedRaw, {
+    const { selectAndSplitCoin: selectAndSplitCoin2 } = await Promise.resolve().then(() => (init_coinSelection(), coinSelection_exports));
+    const result = await selectAndSplitCoin2(tx, client, address, fromType, requestedRaw, {
       sponsoredContext: input.sponsoredContext ?? false,
       mergeCache: input.coinMergeCache
     });
@@ -997,55 +997,126 @@ async function executeTx(client, signer, buildTx, options = {}) {
   return { digest: txn.digest, gasCostSui, effects };
 }
 
-// src/mpp-cost.ts
-function parseChallengeAmount(challenge) {
-  const raw = challenge?.request?.amount;
-  const n = typeof raw === "string" ? Number(raw) : typeof raw === "number" ? raw : Number.NaN;
-  return Number.isFinite(n) ? n : void 0;
-}
-
 // src/wallet/pay.ts
+init_errors();
 async function payWithMpp(args) {
   const { signer, client, options } = args;
-  const { Mppx } = await import('mppx/client');
-  const { sui, USDC } = await import('@suimpp/mpp/client');
-  const { SuiGrpcClient: SuiGrpcClient2 } = await import('@mysten/sui/grpc');
-  const signerAddress = signer.getAddress();
-  let paymentDigest;
-  let gasCostSui = 0;
-  let chargedAmount;
-  const network = client.network === "testnet" ? "testnet" : "mainnet";
-  const grpcBaseUrl = network === "testnet" ? "https://fullnode.testnet.sui.io" : "https://fullnode.mainnet.sui.io";
-  const grpcClient = new SuiGrpcClient2({ baseUrl: grpcBaseUrl, network });
-  const mppx = Mppx.create({
-    polyfill: false,
-    onChallenge: async (challenge) => {
-      const parsed = parseChallengeAmount(challenge);
-      if (parsed !== void 0) chargedAmount = parsed;
-      return void 0;
-    },
-    methods: [sui({
-      client,
-      currency: USDC,
-      signer: {
-        toSuiAddress: () => signerAddress,
-        signPersonalMessage: (bytes) => signer.signPersonalMessage(bytes)
-      },
-      execute: async (tx) => {
-        const result = await executeTx(client, signer, () => tx, { buildClient: grpcClient });
-        paymentDigest = result.digest;
-        gasCostSui = result.gasCostSui;
-        return { digest: result.digest };
-      }
-    })]
-  });
   const method = (options.method ?? "GET").toUpperCase();
   const canHaveBody = method !== "GET" && method !== "HEAD";
-  const response = await mppx.fetch(options.url, {
+  const reqInit = {
     method,
     headers: options.headers,
     body: canHaveBody ? options.body : void 0
+  };
+  const probe = await fetch(options.url, reqInit);
+  if (probe.status !== 402) {
+    return finalize(probe, { paid: false });
+  }
+  const requirements = await pickSuiExactRequirements(probe, client.network);
+  if (!requirements) {
+    throw new exports.T2000Error(
+      "FACILITATOR_REJECTION",
+      `Endpoint returned 402 without an x402 'exact' / sui:${client.network} payment requirement. This SDK only speaks the x402 dialect.`
+    );
+  }
+  return payViaX402({ signer, client, options, reqInit, requirements });
+}
+async function pickSuiExactRequirements(response, network) {
+  try {
+    const body = await response.clone().json();
+    const want = `sui:${network === "testnet" ? "testnet" : "mainnet"}`;
+    return body.accepts?.find((a) => a.scheme === "exact" && a.network === want);
+  } catch {
+    return void 0;
+  }
+}
+async function payViaX402(args) {
+  const { signer, client, options, reqInit, requirements } = args;
+  const { buildX402SignedPayment, X402_PAYMENT_HEADER, X402_PAYMENT_RESPONSE_HEADER } = await import('@suimpp/mpp/x402');
+  const amountRaw = BigInt(requirements.maxAmountRequired);
+  const migrationGasSui = await ensureAddressBalanceCovers({
+    signer,
+    client,
+    asset: requirements.asset,
+    amountRaw
+  });
+  const signerAdapter = {
+    toSuiAddress: () => signer.getAddress(),
+    signTransaction: (bytes) => signer.signTransaction(bytes)
+  };
+  const { header } = await buildX402SignedPayment({ requirements, signer: signerAdapter });
+  const res = await fetch(options.url, {
+    ...reqInit,
+    headers: { ...options.headers ?? {}, [X402_PAYMENT_HEADER]: header }
   });
+  const settleHeader = res.headers.get(X402_PAYMENT_RESPONSE_HEADER);
+  const paid = !!settleHeader;
+  let digest;
+  if (settleHeader) {
+    try {
+      digest = JSON.parse(new TextDecoder().decode(utils.fromBase64(settleHeader))).transaction;
+    } catch {
+      digest = void 0;
+    }
+  }
+  const result = await finalize(res, { paid });
+  if (!paid) return { ...result, dialect: "x402" };
+  return {
+    ...result,
+    dialect: "x402",
+    cost: atomicToHuman(amountRaw, await assetDecimals(requirements.asset)),
+    gasCostSui: migrationGasSui,
+    receipt: digest ? { reference: digest, timestamp: (/* @__PURE__ */ new Date()).toISOString() } : result.receipt
+  };
+}
+async function ensureAddressBalanceCovers(args) {
+  const { signer, client, asset, amountRaw } = args;
+  const owner = signer.getAddress();
+  const balanceResp = await client.core.getBalance({ owner, coinType: asset });
+  const total = BigInt(balanceResp.balance.balance);
+  if (total < amountRaw) {
+    throw new exports.T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${asset} to pay`, {
+      available: total.toString(),
+      required: amountRaw.toString()
+    });
+  }
+  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);
+    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 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 }
+  );
+  return migration.gasCostSui;
+}
+async function finalize(response, opts) {
   const contentType = response.headers.get("content-type") ?? "";
   let body;
   try {
@@ -1053,15 +1124,25 @@ async function payWithMpp(args) {
   } catch {
     body = null;
   }
-  const paid = !!paymentDigest;
-  return {
-    status: response.status,
-    body,
-    paid,
-    cost: paid ? chargedAmount ?? options.maxPrice ?? void 0 : void 0,
-    gasCostSui: paid ? gasCostSui : void 0,
-    receipt: paymentDigest ? { reference: paymentDigest, timestamp: (/* @__PURE__ */ new Date()).toISOString() } : void 0
-  };
+  return { status: response.status, body, paid: opts.paid };
+}
+async function makeGrpcBuildClient(client) {
+  const { SuiGrpcClient: SuiGrpcClient2 } = await import('@mysten/sui/grpc');
+  const network = client.network === "testnet" ? "testnet" : "mainnet";
+  const baseUrl = network === "testnet" ? "https://fullnode.testnet.sui.io" : "https://fullnode.mainnet.sui.io";
+  return new SuiGrpcClient2({ baseUrl, network });
+}
+function atomicToHuman(raw, decimals) {
+  return Number(raw) / 10 ** decimals;
+}
+async function assetDecimals(coinType) {
+  try {
+    const { getDecimalsForCoinType: getDecimalsForCoinType2 } = await Promise.resolve().then(() => (init_token_registry(), token_registry_exports));
+    const d = getDecimalsForCoinType2(coinType);
+    return typeof d === "number" ? d : 6;
+  } catch {
+    return 6;
+  }
 }
 
 // src/wallet/zkLoginSigner.ts
@@ -1684,170 +1765,198 @@ async function normalizeAddressInput(value, ctx = {}) {
 
 // src/t2000.ts
 init_errors();
+var DEFAULT_CONFIG_DIR = path.join(os.homedir(), ".t2000");
+function resolveConfigPath(configDir) {
+  return path.join(configDir ?? DEFAULT_CONFIG_DIR, "config.json");
+}
+function todayUtc() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function readLimitsFile(configDir) {
+  const path = resolveConfigPath(configDir);
+  try {
+    return sanitize(JSON.parse(fs.readFileSync(path, "utf-8")));
+  } catch {
+    return {};
+  }
+}
+function writeLimitsFile(file, configDir) {
+  const path$1 = resolveConfigPath(configDir);
+  let existing = {};
+  try {
+    existing = JSON.parse(fs.readFileSync(path$1, "utf-8"));
+  } catch {
+    existing = {};
+  }
+  for (const dead of ["maxPerTx", "maxDailySend", "dailyUsed", "dailyResetDate", "locked"]) {
+    delete existing[dead];
+  }
+  const merged = { ...existing };
+  if (file.limits && (file.limits.perTxUsd !== void 0 || file.limits.dailyUsd !== void 0)) {
+    merged.limits = file.limits;
+  } else {
+    delete merged.limits;
+  }
+  if (file.dailySpend) merged.dailySpend = file.dailySpend;
+  else delete merged.dailySpend;
+  const dir = path.dirname(path$1);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path$1, JSON.stringify(merged, null, 2) + "\n", { mode: 384 });
+  return path$1;
+}
+function getLimits(configDir) {
+  return readLimitsFile(configDir).limits;
+}
+function hasLimits(configDir) {
+  const l = readLimitsFile(configDir).limits;
+  return !!l && (l.perTxUsd !== void 0 || l.dailyUsd !== void 0);
+}
+function setLimits(limits, configDir) {
+  const file = readLimitsFile(configDir);
+  const merged = { ...file.limits };
+  if (limits.perTxUsd !== void 0) merged.perTxUsd = limits.perTxUsd;
+  if (limits.dailyUsd !== void 0) merged.dailyUsd = limits.dailyUsd;
+  return writeLimitsFile({ ...file, limits: merged }, configDir);
+}
+function clearLimits(configDir) {
+  const file = readLimitsFile(configDir);
+  return writeLimitsFile({ ...file, limits: void 0 }, configDir);
+}
+function dailySpentToday(configDir) {
+  const { dailySpend } = readLimitsFile(configDir);
+  if (!dailySpend || dailySpend.date !== todayUtc()) return 0;
+  return dailySpend.usd;
+}
+function recordDailySpend(usd, configDir) {
+  if (!Number.isFinite(usd) || usd <= 0) return;
+  const file = readLimitsFile(configDir);
+  const today = todayUtc();
+  const prior = file.dailySpend && file.dailySpend.date === today ? file.dailySpend.usd : 0;
+  writeLimitsFile({ ...file, dailySpend: { date: today, usd: prior + usd } }, configDir);
+}
+function sanitize(raw) {
+  if (typeof raw !== "object" || raw === null) return {};
+  const r = raw;
+  const out = {};
+  if (typeof r.limits === "object" && r.limits !== null) {
+    const l = r.limits;
+    const limits = {};
+    if (typeof l.perTxUsd === "number" && l.perTxUsd > 0) limits.perTxUsd = l.perTxUsd;
+    if (typeof l.dailyUsd === "number" && l.dailyUsd > 0) limits.dailyUsd = l.dailyUsd;
+    else if (typeof l.dailySendUsd === "number" && l.dailySendUsd > 0) limits.dailyUsd = l.dailySendUsd;
+    if (limits.perTxUsd !== void 0 || limits.dailyUsd !== void 0) out.limits = limits;
+  }
+  if (typeof r.dailySpend === "object" && r.dailySpend !== null) {
+    const d = r.dailySpend;
+    if (typeof d.date === "string" && typeof d.usd === "number" && d.usd >= 0) {
+      out.dailySpend = { date: d.date, usd: d.usd };
+    }
+  }
+  return out;
+}
 
-// src/safeguards/types.ts
-var DEFAULT_SAFEGUARD_CONFIG = {
-  locked: false,
-  maxPerTx: 0,
-  maxDailySend: 0,
-  dailyUsed: 0,
-  dailyResetDate: ""
-};
-
-// src/safeguards/errors.ts
-init_errors();
-var SafeguardError = class extends exports.T2000Error {
-  rule;
-  details;
-  constructor(rule, details, message) {
-    const msg = message ?? buildMessage(rule, details);
-    super("SAFEGUARD_BLOCKED", msg, { rule, ...details });
-    this.name = "SafeguardError";
-    this.rule = rule;
-    this.details = details;
+// src/limits/errors.ts
+var LimitExceededError = class extends Error {
+  code = "LIMIT_EXCEEDED";
+  operation;
+  limitKind;
+  limit;
+  attempted;
+  constructor(params) {
+    const label = params.limitKind === "perTxUsd" ? "per-transaction limit" : "daily spend limit";
+    super(
+      `Exceeds ${label} ($${params.limit}). Attempted $${params.attempted.toFixed(2)}. Use --force / force:true to override.`
+    );
+    this.name = "LimitExceededError";
+    this.operation = params.operation;
+    this.limitKind = params.limitKind;
+    this.limit = params.limit;
+    this.attempted = params.attempted;
   }
   toJSON() {
     return {
-      error: "SAFEGUARD_BLOCKED",
+      error: this.code,
       message: this.message,
-      retryable: this.retryable,
-      data: { rule: this.rule, ...this.details }
+      operation: this.operation,
+      limitKind: this.limitKind,
+      limit: this.limit,
+      attempted: this.attempted
     };
   }
 };
-function buildMessage(rule, details) {
-  switch (rule) {
-    case "locked":
-      return "Agent is locked. All operations are frozen.";
-    case "maxPerTx":
-      return `Amount $${(details.attempted ?? 0).toFixed(2)} exceeds per-transaction limit ($${(details.limit ?? 0).toFixed(2)})`;
-    case "maxDailySend":
-      return `Daily send limit reached ($${(details.current ?? 0).toFixed(2)}/$${(details.limit ?? 0).toFixed(2)} used today)`;
+
+// src/limits/enforce.ts
+function approxUsdValue(asset, amount) {
+  const symbol = asset.toUpperCase();
+  if (symbol === "USDC" || symbol === "USDSUI") return amount;
+  return null;
+}
+function assertLimitConfig(input) {
+  if (input.force) return;
+  if (!Number.isFinite(input.amountUsd) || input.amountUsd <= 0) return;
+  const { limits } = input;
+  if (!limits) return;
+  if (limits.perTxUsd !== void 0 && input.amountUsd > limits.perTxUsd) {
+    throw new LimitExceededError({
+      operation: input.operation,
+      limitKind: "perTxUsd",
+      limit: limits.perTxUsd,
+      attempted: input.amountUsd
+    });
+  }
+  if (limits.dailyUsd !== void 0 && input.spentTodayUsd + input.amountUsd > limits.dailyUsd) {
+    throw new LimitExceededError({
+      operation: input.operation,
+      limitKind: "dailyUsd",
+      // The cap is total/day; report the cap (attempted is THIS write's USD).
+      limit: limits.dailyUsd,
+      attempted: input.spentTodayUsd + input.amountUsd
+    });
   }
 }
-
-// src/safeguards/enforcer.ts
-var SafeguardEnforcer = class {
-  config;
-  configPath;
+var LimitEnforcer = class {
   constructor(configDir) {
-    this.config = { ...DEFAULT_SAFEGUARD_CONFIG };
-    this.configPath = configDir ? path.join(configDir, "config.json") : null;
+    this.configDir = configDir;
+  }
+  /** Throws `LimitExceededError` when the write exceeds an opted-in cap. */
+  assert(input) {
+    assertLimitConfig({
+      limits: getLimits(this.configDir),
+      spentTodayUsd: dailySpentToday(this.configDir),
+      operation: input.operation,
+      amountUsd: input.amountUsd,
+      force: input.force
+    });
   }
-  load() {
-    if (!this.configPath) return;
-    try {
-      const raw = JSON.parse(fs.readFileSync(this.configPath, "utf-8"));
-      this.config = {
-        ...DEFAULT_SAFEGUARD_CONFIG,
-        locked: raw.locked ?? false,
-        maxPerTx: raw.maxPerTx ?? 0,
-        maxDailySend: raw.maxDailySend ?? 0,
-        dailyUsed: raw.dailyUsed ?? 0,
-        dailyResetDate: raw.dailyResetDate ?? ""
-      };
-    } catch {
-      this.config = { ...DEFAULT_SAFEGUARD_CONFIG };
-    }
+  /** Add a settled write's USD value to today's cumulative total. */
+  record(amountUsd) {
+    recordDailySpend(amountUsd, this.configDir);
   }
-  assertNotLocked() {
-    this.load();
-    if (this.config.locked) {
-      throw new SafeguardError("locked", {});
-    }
+  getLimits() {
+    return getLimits(this.configDir);
   }
-  check(metadata) {
-    this.load();
-    if (this.config.locked) {
-      throw new SafeguardError("locked", {});
-    }
-    const amount = metadata.amount ?? 0;
-    if (this.config.maxPerTx > 0 && amount > this.config.maxPerTx) {
-      throw new SafeguardError("maxPerTx", {
-        attempted: amount,
-        limit: this.config.maxPerTx
-      });
-    }
-    this.resetDailyIfNewDay();
-    if (this.config.maxDailySend > 0 && this.config.dailyUsed + amount > this.config.maxDailySend) {
-      throw new SafeguardError("maxDailySend", {
-        attempted: amount,
-        limit: this.config.maxDailySend,
-        current: this.config.dailyUsed
-      });
-    }
+  hasLimits() {
+    return hasLimits(this.configDir);
   }
-  recordUsage(amount) {
-    this.resetDailyIfNewDay();
-    this.config.dailyUsed += amount;
-    this.save();
-  }
-  lock() {
-    this.config.locked = true;
-    this.save();
-  }
-  unlock() {
-    this.config.locked = false;
-    this.save();
-  }
-  set(key, value) {
-    if (key === "locked" && typeof value === "boolean") {
-      this.config.locked = value;
-    } else if (key === "maxPerTx" && typeof value === "number") {
-      this.config.maxPerTx = value;
-    } else if (key === "maxDailySend" && typeof value === "number") {
-      this.config.maxDailySend = value;
-    }
-    this.save();
-  }
-  getConfig() {
-    this.load();
-    this.resetDailyIfNewDay();
-    return { ...this.config };
-  }
-  isConfigured() {
-    return this.config.maxPerTx > 0 || this.config.maxDailySend > 0;
-  }
-  resetDailyIfNewDay() {
-    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    if (this.config.dailyResetDate !== today) {
-      this.config.dailyUsed = 0;
-      this.config.dailyResetDate = today;
-      this.save();
-    }
+  setLimits(limits) {
+    setLimits(limits, this.configDir);
   }
-  save() {
-    if (!this.configPath) return;
-    try {
-      let existing = {};
-      try {
-        existing = JSON.parse(fs.readFileSync(this.configPath, "utf-8"));
-      } catch {
-      }
-      const merged = {
-        ...existing,
-        locked: this.config.locked,
-        maxPerTx: this.config.maxPerTx,
-        maxDailySend: this.config.maxDailySend,
-        dailyUsed: this.config.dailyUsed,
-        dailyResetDate: this.config.dailyResetDate
-      };
-      const dir = this.configPath.replace(/[/\\][^/\\]+$/, "");
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      fs.writeFileSync(this.configPath, JSON.stringify(merged, null, 2) + "\n");
-    } catch {
-    }
+  clearLimits() {
+    clearLimits(this.configDir);
+  }
+  dailySpentToday() {
+    return dailySpentToday(this.configDir);
   }
 };
-var DEFAULT_CONFIG_DIR = path.join(os.homedir(), ".t2000");
+var DEFAULT_CONFIG_DIR2 = path.join(os.homedir(), ".t2000");
 var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   _signer;
   _keypair;
   client;
   _address;
-  enforcer;
+  /** Unified spending-limit gate (per-tx + cumulative daily, USD). Shared by
+   *  CLI + MCP + programmatic writes — one gate, no bypass (R-0 Finding 1). */
+  limits;
   constructor(keypairOrSigner, client, configDir, isSignerMode) {
     super();
     if (isSignerMode) {
@@ -1861,8 +1970,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       this._address = getAddress(kp);
     }
     this.client = client;
-    this.enforcer = new SafeguardEnforcer(configDir);
-    this.enforcer.load();
+    this.limits = new LimitEnforcer(configDir);
   }
   static async create(options = {}) {
     const { keyPath, rpcUrl } = options;
@@ -1875,7 +1983,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       );
     }
     const keypair = await loadKey(void 0, keyPath);
-    return new _T2000(keypair, client, DEFAULT_CONFIG_DIR);
+    return new _T2000(keypair, client, DEFAULT_CONFIG_DIR2);
   }
   static fromPrivateKey(privateKey, options = {}) {
     const keypair = keypairFromPrivateKey(privateKey);
@@ -1886,7 +1994,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     const keypair = generateKeypair();
     await saveKey(keypair, void 0, options.keyPath);
     const client = getSuiClient();
-    const agent = new _T2000(keypair, client, DEFAULT_CONFIG_DIR);
+    const agent = new _T2000(keypair, client, DEFAULT_CONFIG_DIR2);
     const address = agent.address();
     return { agent, address };
   }
@@ -1908,11 +2016,10 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   }
   // -- MPP Payments --
   async pay(options) {
-    this.enforcer.assertNotLocked();
-    this.enforcer.check({ operation: "pay", amount: options.maxPrice ?? 1 });
+    this.limits.assert({ operation: "pay", amountUsd: options.maxPrice ?? 0, force: options.force });
     const result = await payWithMpp({ signer: this._signer, client: this.client, options });
     if (result.paid) {
-      this.enforcer.recordUsage(result.cost ?? options.maxPrice ?? 1);
+      this.limits.record(result.cost ?? options.maxPrice ?? 0);
     }
     return result;
   }
@@ -1926,7 +2033,11 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   // and the S.323 build-tracker entry.
   // -- Swap --
   async swap(params) {
-    this.enforcer.assertNotLocked();
+    this.limits.assert({
+      operation: "swap",
+      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 fromType = resolveTokenType2(params.from);
     const toType = resolveTokenType2(params.to);
@@ -2018,6 +2129,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     const fromName = resolveSymbol(fromType);
     const toName = resolveSymbol(toType);
     const routeDesc = route.routerData.paths?.map((p) => p.provider).filter(Boolean).slice(0, 3).join(" + ") ?? "Cetus Aggregator";
+    this.limits.record(approxUsdValue(params.from, params.amount) ?? 0);
     return {
       success: true,
       tx: gasResult.digest,
@@ -2074,7 +2186,6 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
    * the "build via gRPC, execute via JSON-RPC" hybrid).
    */
   async send(params) {
-    this.enforcer.assertNotLocked();
     const asset = params.asset;
     if (!asset) {
       throw new exports.T2000Error(
@@ -2084,6 +2195,11 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     }
     assertAllowedAsset("send", asset);
     const sendableAsset = asset;
+    this.limits.assert({
+      operation: "send",
+      amountUsd: approxUsdValue(sendableAsset, params.amount) ?? 0,
+      force: params.force
+    });
     const resolved = await this.resolveRecipient(params.to);
     const sendAmount = params.amount;
     const sendTo = resolved.address;
@@ -2095,7 +2211,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       () => buildSendTx({ client: this.client, address: this._address, to: sendTo, amount: sendAmount, asset: sendableAsset }),
       { buildClient }
     );
-    this.enforcer.recordUsage(sendAmount);
+    this.limits.record(approxUsdValue(sendableAsset, sendAmount) ?? 0);
     const balance = await this.balance();
     this.emitBalanceChange(sendableAsset, sendAmount, "send", gasResult.digest);
     return {
@@ -2653,7 +2769,6 @@ exports.CETUS_USDC_SUI_POOL = CETUS_USDC_SUI_POOL;
 exports.CLOCK_ID = CLOCK_ID;
 exports.DEFAULT_GRPC_URL = DEFAULT_GRPC_URL;
 exports.DEFAULT_NETWORK = DEFAULT_NETWORK;
-exports.DEFAULT_SAFEGUARD_CONFIG = DEFAULT_SAFEGUARD_CONFIG;
 exports.GASLESS_MIN_STABLE_AMOUNT = GASLESS_MIN_STABLE_AMOUNT;
 exports.GASLESS_STABLE_TYPES = GASLESS_STABLE_TYPES;
 exports.GAS_RESERVE_MIN = GAS_RESERVE_MIN;
@@ -2661,6 +2776,8 @@ exports.InvalidAddressError = InvalidAddressError;
 exports.KNOWN_TARGETS = KNOWN_TARGETS;
 exports.KeypairSigner = KeypairSigner;
 exports.LABEL_PATTERNS = LABEL_PATTERNS;
+exports.LimitEnforcer = LimitEnforcer;
+exports.LimitExceededError = LimitExceededError;
 exports.MIST_PER_SUI = MIST_PER_SUI;
 exports.OPERATION_ASSETS = OPERATION_ASSETS;
 exports.SENDABLE_ASSETS = SENDABLE_ASSETS;
@@ -2671,8 +2788,6 @@ exports.SUI_ADDRESS_REGEX = SUI_ADDRESS_REGEX;
 exports.SUI_ADDRESS_STRICT_REGEX = SUI_ADDRESS_STRICT_REGEX;
 exports.SUI_DECIMALS = SUI_DECIMALS;
 exports.SUPPORTED_ASSETS = SUPPORTED_ASSETS;
-exports.SafeguardEnforcer = SafeguardEnforcer;
-exports.SafeguardError = SafeguardError;
 exports.SuinsNotRegisteredError = SuinsNotRegisteredError;
 exports.SuinsRpcError = SuinsRpcError;
 exports.T2000 = T2000;
@@ -2682,7 +2797,9 @@ exports.WRITE_APPENDER_REGISTRY = WRITE_APPENDER_REGISTRY;
 exports.ZkLoginSigner = ZkLoginSigner;
 exports.addSendToTx = addSendToTx;
 exports.addSwapToTx = addSwapToTx;
+exports.approxUsdValue = approxUsdValue;
 exports.assertAllowedAsset = assertAllowedAsset;
+exports.assertLimitConfig = assertLimitConfig;
 exports.buildAddLeafTx = buildAddLeafTx;
 exports.buildRevokeLeafTx = buildRevokeLeafTx;
 exports.buildSendTx = buildSendTx;
@@ -2690,7 +2807,9 @@ exports.buildSwapTx = buildSwapTx;
 exports.classifyAction = classifyAction;
 exports.classifyLabel = classifyLabel;
 exports.classifyTransaction = classifyTransaction;
+exports.clearLimits = clearLimits;
 exports.composeTx = composeTx;
+exports.dailySpentToday = dailySpentToday;
 exports.deriveAllowedAddressesFromPtb = deriveAllowedAddressesFromPtb;
 exports.deserializeCetusRoute = deserializeCetusRoute;
 exports.displayHandle = displayHandle;
@@ -2712,10 +2831,12 @@ exports.getAddress = getAddress;
 exports.getCoinMeta = getCoinMeta;
 exports.getDecimals = getDecimals;
 exports.getDecimalsForCoinType = getDecimalsForCoinType;
+exports.getLimits = getLimits;
 exports.getSponsoredSwapProviders = getSponsoredSwapProviders;
 exports.getSuiClient = getSuiClient;
 exports.getSuiGrpcClient = getSuiGrpcClient;
 exports.getSwapQuote = getSwapQuote;
+exports.hasLimits = hasLimits;
 exports.isAllowedAsset = isAllowedAsset;
 exports.isCetusRouteFresh = isCetusRouteFresh;
 exports.isInRegistry = isInRegistry;
@@ -2734,6 +2855,8 @@ exports.queryHistory = queryHistory;
 exports.queryTransaction = queryTransaction;
 exports.rawToStable = rawToStable;
 exports.rawToUsdc = rawToUsdc;
+exports.readLimitsFile = readLimitsFile;
+exports.recordDailySpend = recordDailySpend;
 exports.refineLendingLabel = refineLendingLabel;
 exports.resolveAddressToSuinsViaRpc = resolveAddressToSuinsViaRpc;
 exports.resolveSuinsViaRpc = resolveSuinsViaRpc;
@@ -2744,6 +2867,7 @@ exports.saveKey = saveKey;
 exports.selectAndSplitCoin = selectAndSplitCoin;
 exports.selectSuiCoin = selectSuiCoin;
 exports.serializeCetusRoute = serializeCetusRoute;
+exports.setLimits = setLimits;
 exports.simulateTransaction = simulateTransaction;
 exports.stableToRaw = stableToRaw;
 exports.suiToMist = suiToMist;
@@ -2754,5 +2878,6 @@ exports.validateAddress = validateAddress;
 exports.validateLabel = validateLabel;
 exports.verifyCetusRouteCoinMatch = verifyCetusRouteCoinMatch;
 exports.walletExists = walletExists;
+exports.writeLimitsFile = writeLimitsFile;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map