@t2000/sdk 0.21.15 → 0.22.0

package/dist/browser.cjs

@@ -0,0 +1,791 @@
+'use strict';
+
+require('@mysten/sui/jsonRpc');
+var utils = require('@mysten/sui/utils');
+
+// src/wallet/keypairSigner.ts
+var KeypairSigner = class {
+  constructor(keypair) {
+    this.keypair = keypair;
+  }
+  getAddress() {
+    return this.keypair.getPublicKey().toSuiAddress();
+  }
+  async signTransaction(txBytes) {
+    return this.keypair.signTransaction(txBytes);
+  }
+  /** Access the underlying keypair for APIs that still require it directly. */
+  getKeypair() {
+    return this.keypair;
+  }
+};
+
+// src/wallet/zkLoginSigner.ts
+var ZkLoginSigner = class {
+  constructor(ephemeralKeypair, zkProof, userAddress, maxEpoch) {
+    this.ephemeralKeypair = ephemeralKeypair;
+    this.zkProof = zkProof;
+    this.userAddress = userAddress;
+    this.maxEpoch = maxEpoch;
+  }
+  getAddress() {
+    return this.userAddress;
+  }
+  async signTransaction(txBytes) {
+    const { getZkLoginSignature } = await import('@mysten/zklogin');
+    const ephSig = await this.ephemeralKeypair.signTransaction(txBytes);
+    return {
+      signature: getZkLoginSignature({
+        inputs: this.zkProof,
+        maxEpoch: this.maxEpoch,
+        userSignature: ephSig.signature
+      })
+    };
+  }
+  isExpired(currentEpoch) {
+    return currentEpoch >= this.maxEpoch;
+  }
+};
+
+// src/errors.ts
+var T2000Error = class extends Error {
+  code;
+  data;
+  retryable;
+  constructor(code, message, data, retryable = false) {
+    super(message);
+    this.name = "T2000Error";
+    this.code = code;
+    this.data = data;
+    this.retryable = retryable;
+  }
+  toJSON() {
+    return {
+      error: this.code,
+      message: this.message,
+      ...this.data && { data: this.data },
+      retryable: this.retryable
+    };
+  }
+};
+function mapWalletError(error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  if (msg.includes("rejected") || msg.includes("cancelled")) {
+    return new T2000Error("TRANSACTION_FAILED", "Transaction cancelled");
+  }
+  if (msg.includes("Insufficient") || msg.includes("insufficient")) {
+    return new T2000Error("INSUFFICIENT_BALANCE", "Insufficient balance");
+  }
+  return new T2000Error("UNKNOWN", msg, void 0, true);
+}
+function mapMoveAbortCode(code) {
+  const abortMessages = {
+    1: "Protocol is temporarily paused",
+    2: "Amount must be greater than zero",
+    3: "Invalid operation type",
+    4: "Fee rate exceeds maximum",
+    5: "Insufficient treasury balance",
+    6: "Not authorized",
+    7: "Package version mismatch \u2014 upgrade required",
+    8: "Timelock is active \u2014 wait for expiry",
+    9: "No pending change to execute",
+    10: "Already at current version",
+    // NAVI Protocol abort codes
+    1502: "Oracle price is stale \u2014 try again in a moment",
+    1503: 'Withdrawal amount is invalid (zero or dust) \u2014 try a specific amount instead of "all"',
+    1600: "Health factor too low \u2014 withdrawal would risk liquidation",
+    1605: "Asset borrowing is disabled or at capacity on this protocol",
+    // NAVI utils abort codes
+    46e3: "Insufficient balance to repay \u2014 withdraw some savings first to get cash"
+  };
+  return abortMessages[code] ?? `Move abort code: ${code}`;
+}
+function isMoveAbort(msg) {
+  return msg.includes("MoveAbort") || msg.includes("MovePrimitiveRuntimeError");
+}
+function parseMoveAbortMessage(msg) {
+  const abortMatch = msg.match(/abort code:\s*(\d+)/i) ?? msg.match(/MoveAbort[^,]*,\s*(\d+)/);
+  if (abortMatch) {
+    const code = parseInt(abortMatch[1], 10);
+    const moduleMatch = msg.match(/Identifier\("([^"]+)"\)/) ?? msg.match(/in '([^']+)'/);
+    const fnMatch = msg.match(/function_name:\s*Some\("([^"]+)"\)/);
+    const context = `${moduleMatch?.[1] ?? ""}${fnMatch ? `::${fnMatch[1]}` : ""}`.toLowerCase();
+    const suffix = moduleMatch ? ` [${moduleMatch[1]}${fnMatch ? `::${fnMatch[1]}` : ""}]` : "";
+    if (context.includes("slippage")) {
+      return `Slippage too high \u2014 price moved during execution${suffix}`;
+    }
+    if (context.includes("balance::split") || context.includes("balance::ENotEnough")) {
+      return `Insufficient on-chain balance${suffix}`;
+    }
+    const mapped = mapMoveAbortCode(code);
+    return `${mapped}${suffix}`;
+  }
+  return msg;
+}
+
+// src/constants.ts
+var MIST_PER_SUI = 1000000000n;
+var SUI_DECIMALS = 9;
+var USDC_DECIMALS = 6;
+var BPS_DENOMINATOR = 10000n;
+var AUTO_TOPUP_THRESHOLD = 50000000n;
+var GAS_RESERVE_TARGET = 150000000n;
+var AUTO_TOPUP_MIN_USDC = 2000000n;
+var SAVE_FEE_BPS = 10n;
+var BORROW_FEE_BPS = 5n;
+var CLOCK_ID = "0x6";
+var SUPPORTED_ASSETS = {
+  USDC: {
+    type: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+    decimals: 6,
+    symbol: "USDC",
+    displayName: "USDC"
+  },
+  USDT: {
+    type: "0x375f70cf2ae4c00bf37117d0c85a2c71545e6ee05c4a5c7d282cd66a4504b068::usdt::USDT",
+    decimals: 6,
+    symbol: "USDT",
+    displayName: "suiUSDT"
+  },
+  USDe: {
+    type: "0x41d587e5336f1c86cad50d38a7136db99333bb9bda91cea4ba69115defeb1402::sui_usde::SUI_USDE",
+    decimals: 6,
+    symbol: "USDe",
+    displayName: "suiUSDe"
+  },
+  USDsui: {
+    type: "0x44f838219cf67b058f3b37907b655f226153c18e33dfcd0da559a844fea9b1c1::usdsui::USDSUI",
+    decimals: 6,
+    symbol: "USDsui",
+    displayName: "USDsui"
+  },
+  SUI: {
+    type: "0x2::sui::SUI",
+    decimals: 9,
+    symbol: "SUI",
+    displayName: "SUI"
+  },
+  WAL: {
+    type: "0x356a26eb9e012a68958082340d4c4116e7f55615cf27affcff209cf0ae544f59::wal::WAL",
+    decimals: 9,
+    symbol: "WAL",
+    displayName: "WAL"
+  },
+  ETH: {
+    type: "0xd0e89b2af5e4910726fbcd8b8dd37bb79b29e5f83f7491bca830e94f7f226d29::eth::ETH",
+    decimals: 8,
+    symbol: "ETH",
+    displayName: "suiETH"
+  },
+  NAVX: {
+    type: "0xa99b8952d4f7d947ea77fe0ecdcc9e5fc0bcab2841d6e2a5aa00c3044e5544b5::navx::NAVX",
+    decimals: 9,
+    symbol: "NAVX",
+    displayName: "NAVX"
+  },
+  GOLD: {
+    type: "0x9d297676e7a4b771ab023291377b2adfaa4938fb9080b8d12430e4b108b836a9::xaum::XAUM",
+    decimals: 6,
+    symbol: "GOLD",
+    displayName: "XAUM"
+  }
+};
+var STABLE_ASSETS = ["USDC"];
+var ALL_NAVI_ASSETS = Object.keys(SUPPORTED_ASSETS);
+var T2000_PACKAGE_ID = process.env.T2000_PACKAGE_ID ?? "0xab92e9f1fe549ad3d6a52924a73181b45791e76120b975138fac9ec9b75db9f3";
+var T2000_CONFIG_ID = process.env.T2000_CONFIG_ID ?? "0x408add9aa9322f93cfd87523d8f603006eb8713894f4c460283c58a6888dae8a";
+var T2000_TREASURY_ID = process.env.T2000_TREASURY_ID ?? "0x3bb501b8300125dca59019247941a42af6b292a150ce3cfcce9449456be2ec91";
+var DEFAULT_NETWORK = "mainnet";
+var API_BASE_URL = process.env.T2000_API_URL ?? "https://api.t2000.ai";
+var GAS_RESERVE_MIN = 0.05;
+
+// src/gas/autoTopUp.ts
+async function shouldAutoTopUp(client, address) {
+  const [suiBalance, usdcBalance] = await Promise.all([
+    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type }),
+    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.USDC.type })
+  ]);
+  const suiRaw = BigInt(suiBalance.totalBalance);
+  const usdcRaw = BigInt(usdcBalance.totalBalance);
+  if (suiRaw < GAS_RESERVE_TARGET && usdcRaw >= AUTO_TOPUP_MIN_USDC) {
+    return false;
+  }
+  return false;
+}
+async function executeAutoTopUp(_client, _signer) {
+  return { success: false, tx: "", usdcSpent: 0, suiReceived: 0 };
+}
+
+// src/utils/base64.ts
+function toBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function fromBase64(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+// src/gas/gasStation.ts
+async function requestGasSponsorship(txJson, sender, type, txBcsBytes) {
+  const payload = { sender, type };
+  if (txBcsBytes) {
+    payload.txBcsBytes = txBcsBytes;
+  } else {
+    payload.txJson = txJson;
+    payload.txBytes = toBase64(new TextEncoder().encode(txJson));
+  }
+  const res = await fetch(`${API_BASE_URL}/api/gas`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    const errorCode = data.error;
+    if (errorCode === "CIRCUIT_BREAKER" || errorCode === "POOL_DEPLETED" || errorCode === "PRICE_STALE") {
+      throw new T2000Error(
+        "GAS_STATION_UNAVAILABLE",
+        data.message ?? "Gas station temporarily unavailable",
+        { retryAfter: data.retryAfter, reason: errorCode },
+        true
+      );
+    }
+    if (errorCode === "GAS_FEE_EXCEEDED") {
+      throw new T2000Error(
+        "GAS_FEE_EXCEEDED",
+        data.message ?? "Gas fee exceeds ceiling",
+        { retryAfter: data.retryAfter },
+        true
+      );
+    }
+    throw new T2000Error(
+      "GAS_STATION_UNAVAILABLE",
+      data.message ?? "Gas sponsorship request failed",
+      { reason: errorCode },
+      true
+    );
+  }
+  return data;
+}
+async function reportGasUsage(sender, txDigest, gasCostSui, usdcCharged, type) {
+  try {
+    await fetch(`${API_BASE_URL}/api/gas/report`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sender, txDigest, gasCostSui, usdcCharged, type })
+    });
+  } catch {
+  }
+}
+async function getGasStatus(address) {
+  const url = new URL(`${API_BASE_URL}/api/gas/status`);
+  if (address) url.searchParams.set("address", address);
+  const res = await fetch(url.toString());
+  if (!res.ok) {
+    throw new T2000Error("GAS_STATION_UNAVAILABLE", "Failed to fetch gas status", void 0, true);
+  }
+  return await res.json();
+}
+
+// src/gas/manager.ts
+function extractGasCost(effects) {
+  if (!effects?.gasUsed) return 0;
+  return (Number(effects.gasUsed.computationCost) + Number(effects.gasUsed.storageCost) - Number(effects.gasUsed.storageRebate)) / 1e9;
+}
+async function getSuiBalance(client, address) {
+  const bal = await client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type });
+  return BigInt(bal.totalBalance);
+}
+async function assertTxSuccess(effects, digest) {
+  const eff = effects;
+  if (eff?.status?.status === "failure") {
+    const errMsg = eff.status.error ?? "unknown on-chain error";
+    if (isMoveAbort(errMsg)) {
+      throw new T2000Error("TRANSACTION_FAILED", parseMoveAbortMessage(errMsg));
+    }
+    throw new T2000Error("TRANSACTION_FAILED", `Transaction ${digest} failed on-chain: ${errMsg}`);
+  }
+}
+async function trySelfFunded(client, signer, tx) {
+  const address = signer.getAddress();
+  const suiBalance = await getSuiBalance(client, address);
+  if (suiBalance < AUTO_TOPUP_THRESHOLD) return null;
+  tx.setSender(address);
+  const builtBytes = await tx.build({ client });
+  const { signature } = await signer.signTransaction(builtBytes);
+  const result = await client.executeTransactionBlock({
+    transactionBlock: toBase64(builtBytes),
+    signature: [signature],
+    options: { showEffects: true, showBalanceChanges: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  await assertTxSuccess(result.effects, result.digest);
+  return {
+    digest: result.digest,
+    effects: result.effects,
+    balanceChanges: result.balanceChanges,
+    gasMethod: "self-funded",
+    gasCostSui: extractGasCost(result.effects),
+    preTxSuiMist: suiBalance
+  };
+}
+async function tryAutoTopUpThenSelfFund(client, signer, buildTx) {
+  const address = signer.getAddress();
+  const canTopUp = await shouldAutoTopUp(client, address);
+  if (!canTopUp) return null;
+  await executeAutoTopUp();
+  const tx = await buildTx();
+  tx.setSender(address);
+  const suiAfterTopUp = await getSuiBalance(client, address);
+  const builtBytes = await tx.build({ client });
+  const { signature } = await signer.signTransaction(builtBytes);
+  const result = await client.executeTransactionBlock({
+    transactionBlock: toBase64(builtBytes),
+    signature: [signature],
+    options: { showEffects: true, showBalanceChanges: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  await assertTxSuccess(result.effects, result.digest);
+  return {
+    digest: result.digest,
+    effects: result.effects,
+    balanceChanges: result.balanceChanges,
+    gasMethod: "auto-topup",
+    gasCostSui: extractGasCost(result.effects),
+    preTxSuiMist: suiAfterTopUp
+  };
+}
+async function trySponsored(client, signer, tx) {
+  const address = signer.getAddress();
+  const suiBalance = await getSuiBalance(client, address);
+  tx.setSender(address);
+  let txJson;
+  let txBcsBase64;
+  try {
+    txJson = tx.serialize();
+  } catch {
+    const bcsBytes = await tx.build({ client });
+    txBcsBase64 = toBase64(bcsBytes);
+  }
+  const sponsoredResult = await requestGasSponsorship(txJson ?? "", address, void 0, txBcsBase64);
+  const sponsoredTxBytes = fromBase64(sponsoredResult.txBytes);
+  const { signature: agentSig } = await signer.signTransaction(sponsoredTxBytes);
+  const result = await client.executeTransactionBlock({
+    transactionBlock: sponsoredResult.txBytes,
+    signature: [agentSig, sponsoredResult.sponsorSignature],
+    options: { showEffects: true, showBalanceChanges: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  await assertTxSuccess(result.effects, result.digest);
+  const gasCost = extractGasCost(result.effects);
+  reportGasUsage(address, result.digest, gasCost, 0, sponsoredResult.type);
+  return {
+    digest: result.digest,
+    effects: result.effects,
+    balanceChanges: result.balanceChanges,
+    gasMethod: "sponsored",
+    gasCostSui: gasCost,
+    preTxSuiMist: suiBalance
+  };
+}
+async function waitForIndexer(client, digest) {
+  for (let i = 0; i < 3; i++) {
+    try {
+      await client.getTransactionBlock({ digest, options: { showObjectChanges: true } });
+      return;
+    } catch {
+      await new Promise((r) => setTimeout(r, 500));
+    }
+  }
+}
+async function executeWithGas(client, signer, buildTx, options) {
+  if (options?.enforcer && options?.metadata) {
+    options.enforcer.check(options.metadata);
+  }
+  const result = await resolveGas(client, signer, buildTx);
+  try {
+    if (result.preTxSuiMist !== void 0) {
+      const gasCostMist = result.gasMethod === "sponsored" ? 0n : BigInt(Math.round(result.gasCostSui * 1e9));
+      const estimatedRemaining = result.preTxSuiMist - gasCostMist;
+      if (estimatedRemaining < GAS_RESERVE_TARGET) {
+        const address = signer.getAddress();
+        const usdcBal = await client.getBalance({
+          owner: address,
+          coinType: SUPPORTED_ASSETS.USDC.type
+        });
+        if (BigInt(usdcBal.totalBalance) >= AUTO_TOPUP_MIN_USDC) {
+          await executeAutoTopUp(client, signer);
+        }
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+var GAS_RESOLUTION_CODES = /* @__PURE__ */ new Set([
+  "INSUFFICIENT_GAS",
+  "GAS_STATION_UNAVAILABLE",
+  "GAS_FEE_EXCEEDED",
+  "AUTO_TOPUP_FAILED",
+  "SPONSOR_UNAVAILABLE"
+]);
+function isBuildError(err) {
+  return err instanceof T2000Error && !GAS_RESOLUTION_CODES.has(err.code);
+}
+async function resolveGas(client, signer, buildTx) {
+  const errors = [];
+  let lastBuildError;
+  try {
+    const tx = await buildTx();
+    const result = await trySelfFunded(client, signer, tx);
+    if (result) {
+      await waitForIndexer(client, result.digest);
+      return result;
+    }
+    errors.push("self-funded: SUI below threshold");
+  } catch (err) {
+    if (err instanceof T2000Error && err.code === "TRANSACTION_FAILED") throw err;
+    const msg = err instanceof Error ? err.message : String(err);
+    if (isMoveAbort(msg)) {
+      throw new T2000Error("TRANSACTION_FAILED", parseMoveAbortMessage(msg));
+    }
+    if (isBuildError(err)) lastBuildError = err;
+    errors.push(`self-funded: ${msg}`);
+  }
+  try {
+    const result = await tryAutoTopUpThenSelfFund(client, signer, buildTx);
+    if (result) {
+      await waitForIndexer(client, result.digest);
+      return result;
+    }
+    errors.push("auto-topup: not eligible (low USDC or sufficient SUI)");
+  } catch (err) {
+    if (err instanceof T2000Error && err.code === "TRANSACTION_FAILED") throw err;
+    errors.push(`auto-topup: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    const tx = await buildTx();
+    const result = await trySelfFunded(client, signer, tx);
+    if (result) {
+      await waitForIndexer(client, result.digest);
+      return result;
+    }
+  } catch (err) {
+    if (err instanceof T2000Error && err.code === "TRANSACTION_FAILED") throw err;
+    const msg = err instanceof Error ? err.message : String(err);
+    if (isMoveAbort(msg)) {
+      throw new T2000Error("TRANSACTION_FAILED", parseMoveAbortMessage(msg));
+    }
+    if (isBuildError(err)) lastBuildError = err;
+    errors.push(`self-funded-retry: ${msg}`);
+  }
+  try {
+    const tx = await buildTx();
+    const result = await trySponsored(client, signer, tx);
+    if (result) {
+      await waitForIndexer(client, result.digest);
+      return result;
+    }
+    errors.push("sponsored: returned null");
+  } catch (err) {
+    if (err instanceof T2000Error && err.code === "TRANSACTION_FAILED") throw err;
+    if (isBuildError(err)) lastBuildError = err;
+    errors.push(`sponsored: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (lastBuildError) throw lastBuildError;
+  throw new T2000Error(
+    "INSUFFICIENT_GAS",
+    `No SUI for gas and sponsorship unavailable. Fund your wallet with SUI or USDC. [${errors.join(" | ")}]`,
+    { reason: "all_gas_methods_exhausted", errors }
+  );
+}
+function validateAddress(address) {
+  const normalized = utils.normalizeSuiAddress(address);
+  if (!utils.isValidSuiAddress(normalized)) {
+    throw new T2000Error("INVALID_ADDRESS", `Invalid Sui address: ${address}`);
+  }
+  return normalized;
+}
+function truncateAddress(address) {
+  if (address.length <= 10) return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+
+// src/utils/format.ts
+function mistToSui(mist) {
+  return Number(mist) / Number(MIST_PER_SUI);
+}
+function suiToMist(sui) {
+  return BigInt(Math.round(sui * Number(MIST_PER_SUI)));
+}
+function usdcToRaw(amount) {
+  return BigInt(Math.round(amount * 10 ** USDC_DECIMALS));
+}
+function rawToUsdc(raw) {
+  return Number(raw) / 10 ** USDC_DECIMALS;
+}
+function stableToRaw(amount, decimals) {
+  return BigInt(Math.round(amount * 10 ** decimals));
+}
+function rawToStable(raw, decimals) {
+  return Number(raw) / 10 ** decimals;
+}
+function getDecimals(asset) {
+  return SUPPORTED_ASSETS[asset].decimals;
+}
+function formatUsd(amount) {
+  return `$${amount.toFixed(2)}`;
+}
+function formatSui(amount) {
+  if (amount < 1e-3) return `${amount.toFixed(6)} SUI`;
+  return `${amount.toFixed(3)} SUI`;
+}
+function formatAssetAmount(amount, asset) {
+  if (asset === "BTC") return amount.toFixed(8);
+  if (asset === "GOLD") return amount.toFixed(6);
+  if (asset === "ETH") return amount.toFixed(6);
+  return amount.toFixed(4);
+}
+var ASSET_LOOKUP = /* @__PURE__ */ new Map();
+for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
+  ASSET_LOOKUP.set(key.toUpperCase(), key);
+  if (info.displayName && info.displayName.toUpperCase() !== key.toUpperCase()) {
+    ASSET_LOOKUP.set(info.displayName.toUpperCase(), key);
+  }
+}
+
+// src/protocols/protocolFee.ts
+var FEE_RATES = {
+  save: SAVE_FEE_BPS,
+  borrow: BORROW_FEE_BPS
+};
+var OP_CODES = {
+  save: 0,
+  borrow: 2
+};
+function calculateFee(operation, amount) {
+  const bps = FEE_RATES[operation];
+  const feeAmount = amount * Number(bps) / Number(BPS_DENOMINATOR);
+  const rawAmount = usdcToRaw(feeAmount);
+  return {
+    amount: feeAmount,
+    asset: "USDC",
+    rate: Number(bps) / Number(BPS_DENOMINATOR),
+    rawAmount
+  };
+}
+function addCollectFeeToTx(tx, paymentCoin, operation) {
+  const bps = FEE_RATES[operation];
+  if (bps <= 0n) return;
+  tx.moveCall({
+    target: `${T2000_PACKAGE_ID}::treasury::collect_fee`,
+    typeArguments: [SUPPORTED_ASSETS.USDC.type],
+    arguments: [
+      tx.object(T2000_TREASURY_ID),
+      tx.object(T2000_CONFIG_ID),
+      paymentCoin,
+      tx.pure.u8(OP_CODES[operation])
+    ]
+  });
+}
+
+// src/safeguards/errors.ts
+var SafeguardError = class extends 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;
+  }
+  toJSON() {
+    return {
+      error: "SAFEGUARD_BLOCKED",
+      message: this.message,
+      retryable: this.retryable,
+      data: { rule: this.rule, ...this.details }
+    };
+  }
+};
+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/safeguards/types.ts
+var OUTBOUND_OPS = /* @__PURE__ */ new Set([
+  "send",
+  "pay"
+]);
+var DEFAULT_SAFEGUARD_CONFIG = {
+  locked: false,
+  maxPerTx: 0,
+  maxDailySend: 0,
+  dailyUsed: 0,
+  dailyResetDate: ""
+};
+
+// src/token-registry.ts
+var COIN_REGISTRY = {
+  // ── Tier 1 — Financial layer ──────────────────────────────────────────
+  USDC: { type: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC", decimals: 6, symbol: "USDC", tier: 1 },
+  // ── Tier 2 — Swap assets (13 tokens) ──────────────────────────────────
+  SUI: { type: "0x2::sui::SUI", decimals: 9, symbol: "SUI", tier: 2 },
+  wBTC: { type: "0x0041f9f9344cac094454cd574e333c4fdb132d7bcc9379bcd4aab485b2a63942::wbtc::WBTC", decimals: 8, symbol: "wBTC", tier: 2 },
+  ETH: { type: "0xd0e89b2af5e4910726fbcd8b8dd37bb79b29e5f83f7491bca830e94f7f226d29::eth::ETH", decimals: 8, symbol: "ETH", tier: 2 },
+  GOLD: { type: "0x9d297676e7a4b771ab023291377b2adfaa4938fb9080b8d12430e4b108b836a9::xaum::XAUM", decimals: 6, symbol: "GOLD", tier: 2 },
+  DEEP: { type: "0xdeeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270::deep::DEEP", decimals: 6, symbol: "DEEP", tier: 2 },
+  WAL: { type: "0x356a26eb9e012a68958082340d4c4116e7f55615cf27affcff209cf0ae544f59::wal::WAL", decimals: 9, symbol: "WAL", tier: 2 },
+  NS: { type: "0x5145494a5f5100e645e4b0aa950fa6b68f614e8c59e17bc5ded3495123a79178::ns::NS", decimals: 6, symbol: "NS", tier: 2 },
+  IKA: { type: "0x7262fb2f7a3a14c888c438a3cd9b912469a58cf60f367352c46584262e8299aa::ika::IKA", decimals: 9, symbol: "IKA", tier: 2 },
+  CETUS: { type: "0x06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b::cetus::CETUS", decimals: 9, symbol: "CETUS", tier: 2 },
+  NAVX: { type: "0xa99b8952d4f7d947ea77fe0ecdcc9e5fc0bcab2841d6e2a5aa00c3044e5544b5::navx::NAVX", decimals: 9, symbol: "NAVX", tier: 2 },
+  vSUI: { type: "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT", decimals: 9, symbol: "vSUI", tier: 2 },
+  LOFI: { type: "0xf22da9a24ad027cccb5f2d496cbe91de953d363513db08a3a734d361c7c17503::LOFI::LOFI", decimals: 9, symbol: "LOFI", tier: 2 },
+  MANIFEST: { type: "0xc466c28d87b3d5cd34f3d5c088751532d71a38d93a8aae4551dd56272cfb4355::manifest::MANIFEST", decimals: 9, symbol: "MANIFEST", tier: 2 },
+  // ── Legacy — no tier, kept for display accuracy on existing positions ──
+  USDT: { type: "0x375f70cf2ae4c00bf37117d0c85a2c71545e6ee05c4a5c7d282cd66a4504b068::usdt::USDT", decimals: 6, symbol: "USDT" },
+  USDe: { type: "0x41d587e5336f1c86cad50d38a7136db99333bb9bda91cea4ba69115defeb1402::sui_usde::SUI_USDE", decimals: 6, symbol: "USDe" },
+  USDSUI: { type: "0x44f838219cf67b058f3b37907b655f226153c18e33dfcd0da559a844fea9b1c1::usdsui::USDSUI", decimals: 6, symbol: "USDsui" }
+};
+var BY_TYPE = /* @__PURE__ */ new Map();
+for (const meta of Object.values(COIN_REGISTRY)) {
+  BY_TYPE.set(meta.type, meta);
+}
+function isTier1(coinType) {
+  const meta = BY_TYPE.get(coinType);
+  return meta?.tier === 1;
+}
+function isTier2(coinType) {
+  const meta = BY_TYPE.get(coinType);
+  return meta?.tier === 2;
+}
+function isSupported(coinType) {
+  const meta = BY_TYPE.get(coinType);
+  return meta?.tier !== void 0;
+}
+function getTier(coinType) {
+  return BY_TYPE.get(coinType)?.tier;
+}
+function getDecimalsForCoinType(coinType) {
+  const direct = BY_TYPE.get(coinType);
+  if (direct) return direct.decimals;
+  const suffix = coinType.split("::").slice(1).join("::").toUpperCase();
+  if (suffix) {
+    for (const meta of BY_TYPE.values()) {
+      const metaSuffix = meta.type.split("::").slice(1).join("::").toUpperCase();
+      if (metaSuffix === suffix) return meta.decimals;
+    }
+  }
+  return 9;
+}
+function resolveSymbol(coinType) {
+  const direct = BY_TYPE.get(coinType);
+  if (direct) return direct.symbol;
+  const suffix = coinType.split("::").slice(1).join("::").toUpperCase();
+  if (suffix) {
+    for (const meta of BY_TYPE.values()) {
+      const metaSuffix = meta.type.split("::").slice(1).join("::").toUpperCase();
+      if (metaSuffix === suffix) return meta.symbol;
+    }
+  }
+  return coinType.split("::").pop() ?? coinType;
+}
+var TOKEN_MAP = (() => {
+  const map = {};
+  for (const [name, meta] of Object.entries(COIN_REGISTRY)) {
+    map[name] = meta.type;
+    map[name.toUpperCase()] = meta.type;
+  }
+  return map;
+})();
+function resolveTokenType(nameOrType) {
+  if (nameOrType.includes("::")) return nameOrType;
+  return TOKEN_MAP[nameOrType] ?? TOKEN_MAP[nameOrType.toUpperCase()] ?? null;
+}
+var SUI_TYPE = COIN_REGISTRY.SUI.type;
+var USDC_TYPE = COIN_REGISTRY.USDC.type;
+var USDT_TYPE = COIN_REGISTRY.USDT.type;
+var USDSUI_TYPE = COIN_REGISTRY.USDSUI.type;
+var USDE_TYPE = COIN_REGISTRY.USDe.type;
+var ETH_TYPE = COIN_REGISTRY.ETH.type;
+var WBTC_TYPE = COIN_REGISTRY.wBTC.type;
+var WAL_TYPE = COIN_REGISTRY.WAL.type;
+var NAVX_TYPE = COIN_REGISTRY.NAVX.type;
+var IKA_TYPE = COIN_REGISTRY.IKA.type;
+var LOFI_TYPE = COIN_REGISTRY.LOFI.type;
+var MANIFEST_TYPE = COIN_REGISTRY.MANIFEST.type;
+
+exports.ALL_NAVI_ASSETS = ALL_NAVI_ASSETS;
+exports.BPS_DENOMINATOR = BPS_DENOMINATOR;
+exports.CLOCK_ID = CLOCK_ID;
+exports.COIN_REGISTRY = COIN_REGISTRY;
+exports.DEFAULT_NETWORK = DEFAULT_NETWORK;
+exports.DEFAULT_SAFEGUARD_CONFIG = DEFAULT_SAFEGUARD_CONFIG;
+exports.ETH_TYPE = ETH_TYPE;
+exports.GAS_RESERVE_MIN = GAS_RESERVE_MIN;
+exports.IKA_TYPE = IKA_TYPE;
+exports.KeypairSigner = KeypairSigner;
+exports.LOFI_TYPE = LOFI_TYPE;
+exports.MANIFEST_TYPE = MANIFEST_TYPE;
+exports.MIST_PER_SUI = MIST_PER_SUI;
+exports.NAVX_TYPE = NAVX_TYPE;
+exports.OUTBOUND_OPS = OUTBOUND_OPS;
+exports.STABLE_ASSETS = STABLE_ASSETS;
+exports.SUI_DECIMALS = SUI_DECIMALS;
+exports.SUI_TYPE = SUI_TYPE;
+exports.SUPPORTED_ASSETS = SUPPORTED_ASSETS;
+exports.SafeguardError = SafeguardError;
+exports.T2000Error = T2000Error;
+exports.TOKEN_MAP = TOKEN_MAP;
+exports.USDC_DECIMALS = USDC_DECIMALS;
+exports.USDC_TYPE = USDC_TYPE;
+exports.USDE_TYPE = USDE_TYPE;
+exports.USDSUI_TYPE = USDSUI_TYPE;
+exports.USDT_TYPE = USDT_TYPE;
+exports.WAL_TYPE = WAL_TYPE;
+exports.WBTC_TYPE = WBTC_TYPE;
+exports.ZkLoginSigner = ZkLoginSigner;
+exports.addCollectFeeToTx = addCollectFeeToTx;
+exports.calculateFee = calculateFee;
+exports.executeAutoTopUp = executeAutoTopUp;
+exports.executeWithGas = executeWithGas;
+exports.formatAssetAmount = formatAssetAmount;
+exports.formatSui = formatSui;
+exports.formatUsd = formatUsd;
+exports.fromBase64 = fromBase64;
+exports.getDecimals = getDecimals;
+exports.getDecimalsForCoinType = getDecimalsForCoinType;
+exports.getGasStatus = getGasStatus;
+exports.getTier = getTier;
+exports.isSupported = isSupported;
+exports.isTier1 = isTier1;
+exports.isTier2 = isTier2;
+exports.mapMoveAbortCode = mapMoveAbortCode;
+exports.mapWalletError = mapWalletError;
+exports.mistToSui = mistToSui;
+exports.rawToStable = rawToStable;
+exports.rawToUsdc = rawToUsdc;
+exports.resolveSymbol = resolveSymbol;
+exports.resolveTokenType = resolveTokenType;
+exports.shouldAutoTopUp = shouldAutoTopUp;
+exports.stableToRaw = stableToRaw;
+exports.suiToMist = suiToMist;
+exports.toBase64 = toBase64;
+exports.truncateAddress = truncateAddress;
+exports.usdcToRaw = usdcToRaw;
+exports.validateAddress = validateAddress;
+//# sourceMappingURL=browser.cjs.map
+//# sourceMappingURL=browser.cjs.map