@t2000/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1233 @@
+#!/usr/bin/env node
+
+// src/program.ts
+import { Command } from "commander";
+
+// src/output.ts
+import pc from "picocolors";
+var jsonMode = false;
+function setJsonMode(enabled) {
+  jsonMode = enabled;
+}
+function isJsonMode() {
+  return jsonMode;
+}
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function printSuccess(message) {
+  if (jsonMode) return;
+  console.log(`  ${pc.green("\u2713")} ${message}`);
+}
+function printError(message) {
+  if (jsonMode) return;
+  console.error(`  ${pc.red("\u2717")} ${message}`);
+}
+function printWarning(message) {
+  if (jsonMode) return;
+  console.log(`  ${pc.yellow("\u26A0")} ${message}`);
+}
+function printInfo(message) {
+  if (jsonMode) return;
+  console.log(`  ${pc.dim(message)}`);
+}
+function printHeader(title) {
+  if (jsonMode) return;
+  console.log();
+  console.log(`  ${pc.bold(title)}`);
+  console.log();
+}
+function printKeyValue(key, value, indent = 2) {
+  if (jsonMode) return;
+  const pad = " ".repeat(indent);
+  console.log(`${pad}${pc.dim(key + ":")}  ${value}`);
+}
+function printBlank() {
+  if (jsonMode) return;
+  console.log();
+}
+function printDivider(width = 53) {
+  if (jsonMode) return;
+  console.log(`  ${pc.dim("\u2500".repeat(width))}`);
+}
+function printLine(text) {
+  if (jsonMode) return;
+  console.log(`  ${text}`);
+}
+function printSeparator() {
+  if (jsonMode) return;
+  console.log(`  ${pc.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}`);
+}
+function explorerUrl(txHash, network = "mainnet") {
+  const base = network === "testnet" ? "https://suiscan.xyz/testnet/tx" : "https://suiscan.xyz/mainnet/tx";
+  const suffix = "";
+  return `${base}/${txHash}${suffix}`;
+}
+function handleError(error) {
+  if (jsonMode) {
+    const data = error instanceof Error && "toJSON" in error ? error.toJSON() : { error: "UNKNOWN", message: String(error) };
+    printJson(data);
+  } else {
+    const msg = error instanceof Error ? error.message : String(error);
+    printError(msg);
+  }
+  process.exit(1);
+}
+
+// src/commands/init.ts
+import pc2 from "picocolors";
+import { T2000 } from "@t2000/sdk";
+
+// src/prompts.ts
+import { password, confirm } from "@inquirer/prompts";
+async function askPassphrase(message = "Enter passphrase:") {
+  const value = await password({ message });
+  if (!value || value.length < 8) {
+    throw new Error("Passphrase must be at least 8 characters");
+  }
+  return value;
+}
+async function askPassphraseConfirm() {
+  const pass = await password({ message: "Create passphrase (min 8 chars):" });
+  if (!pass || pass.length < 8) {
+    throw new Error("Passphrase must be at least 8 characters");
+  }
+  const confirm_ = await password({ message: "Confirm passphrase:" });
+  if (pass !== confirm_) {
+    throw new Error("Passphrases do not match");
+  }
+  return pass;
+}
+async function askConfirm(message) {
+  return confirm({ message });
+}
+function getPassphraseFromEnv() {
+  return process.env.T2000_PASSPHRASE;
+}
+
+// src/commands/init.ts
+function registerInit(program2) {
+  program2.command("init").description("Create a new agent wallet").option("--name <name>", "Agent name").option("--key <path>", "Key file path").option("--no-sponsor", "Skip gas sponsorship").action(async (opts) => {
+    try {
+      const passphrase = getPassphraseFromEnv() ?? await askPassphraseConfirm();
+      if (!isJsonMode()) {
+        printBlank();
+        printInfo("Creating agent wallet...");
+      }
+      const { agent, address, sponsored } = await T2000.init({
+        passphrase,
+        keyPath: opts.key,
+        name: opts.name,
+        sponsored: opts.sponsor
+      });
+      if (isJsonMode()) {
+        printJson({ address, sponsored });
+        return;
+      }
+      printSuccess("Keypair generated");
+      printSuccess(`Network ${pc2.dim("Sui mainnet")}`);
+      printSuccess(`Gas sponsorship ${pc2.dim(sponsored ? "enabled" : "disabled")}`);
+      printBlank();
+      printInfo("Setting up accounts...");
+      printLine(
+        `${pc2.green("\u2713")} Checking  ${pc2.green("\u2713")} Savings  ${pc2.green("\u2713")} Credit  ${pc2.green("\u2713")} Exchange  ${pc2.green("\u2713")} 402 Pay`
+      );
+      printBlank();
+      printLine(`\u{1F389} ${pc2.green("Bank account created")}`);
+      printKeyValue("Address", pc2.yellow(address));
+      printBlank();
+      printLine(`Deposit USDC on Sui network only.`);
+      printDivider();
+      printBlank();
+      printLine(`${pc2.cyan("t2000 balance")}            check for funds`);
+      printLine(`${pc2.cyan("t2000 save all")}           start earning yield`);
+      printLine(`${pc2.cyan("t2000 address")}            show address again`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/send.ts
+import { T2000 as T20002 } from "@t2000/sdk";
+import { truncateAddress, formatUsd } from "@t2000/sdk";
+function registerSend(program2) {
+  program2.command("send <amount> <asset> [to_keyword] <address>").description("Send USDC (or other asset) to an address").option("--key <path>", "Key file path").action(async (amount, asset, toOrAddress, address, opts) => {
+    try {
+      const recipient = address ?? toOrAddress;
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T20002.create({ passphrase, keyPath: opts.key });
+      const result = await agent.send({
+        to: recipient,
+        amount: parseFloat(amount),
+        asset: asset.toUpperCase()
+      });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      printSuccess(`Sent ${formatUsd(result.amount)} ${asset.toUpperCase()} \u2192 ${truncateAddress(result.to)}`);
+      printKeyValue("Gas", `${result.gasCost.toFixed(4)} ${result.gasCostUnit} (${result.gasMethod})`);
+      printKeyValue("Balance", formatUsd(result.balance.available) + " USDC");
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/balance.ts
+import pc3 from "picocolors";
+import { T2000 as T20003, formatUsd as formatUsd2, getRates } from "@t2000/sdk";
+async function fetchLimits(agent) {
+  const [maxWithdraw, maxBorrow, hf] = await Promise.all([
+    agent.maxWithdraw(),
+    agent.maxBorrow(),
+    agent.healthFactor()
+  ]);
+  return {
+    maxWithdraw: maxWithdraw.maxAmount.toFixed(2),
+    maxBorrow: maxBorrow.maxAmount.toFixed(2),
+    healthFactor: hf.borrowed > 0 ? hf.healthFactor : null
+  };
+}
+function registerBalance(program2) {
+  program2.command("balance").description("Show wallet balance").option("--key <path>", "Key file path").option("--show-limits", "Include maxWithdraw, maxBorrow, and health factor").action(async (opts) => {
+    try {
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T20003.create({ passphrase, keyPath: opts.key });
+      const bal = await agent.balance();
+      const limits = opts.showLimits ? await fetchLimits(agent) : void 0;
+      if (isJsonMode()) {
+        const output = limits ? { ...bal, limits } : bal;
+        printJson(output);
+        return;
+      }
+      let apyStr = "";
+      if (bal.savings > 0) {
+        try {
+          const rates = await getRates(agent.suiClient);
+          const apy = rates.USDC.saveApy;
+          apyStr = `  ${pc3.dim(`(earning ${apy.toFixed(2)}% APY)`)}`;
+        } catch {
+        }
+      }
+      printBlank();
+      printKeyValue("Available", `${formatUsd2(bal.available)} USDC  ${pc3.dim("(checking \u2014 spendable)")}`);
+      printKeyValue("Savings", `${formatUsd2(bal.savings)} USDC${apyStr}`);
+      printKeyValue("Gas", `${bal.gasReserve.sui.toFixed(2)} SUI    ${pc3.dim(`(~${formatUsd2(bal.gasReserve.usdEquiv)})`)}`);
+      printSeparator();
+      printKeyValue("Total", `${formatUsd2(bal.total)} USDC`);
+      if (bal.savings > 0 && apyStr) {
+        try {
+          const rates = await getRates(agent.suiClient);
+          const dailyEarning = bal.savings * rates.USDC.saveApy / 100 / 365;
+          if (dailyEarning > 1e-3) {
+            printLine(pc3.dim(`Earning ~${formatUsd2(dailyEarning)}/day`));
+          }
+        } catch {
+        }
+      }
+      if (limits) {
+        printBlank();
+        printHeader("Limits");
+        printKeyValue("Max withdraw", `${formatUsd2(Number(limits.maxWithdraw))} USDC`, 4);
+        printKeyValue("Max borrow", `${formatUsd2(Number(limits.maxBorrow))} USDC`, 4);
+        const hfDisplay = limits.healthFactor !== null ? limits.healthFactor.toFixed(2) : `${pc3.green("\u221E")}  ${pc3.dim("(no active loan)")}`;
+        printKeyValue("Health factor", hfDisplay, 4);
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/address.ts
+import { T2000 as T20004 } from "@t2000/sdk";
+function registerAddress(program2) {
+  program2.command("address").description("Show wallet address").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T20004.create({ passphrase, keyPath: opts.key });
+      if (isJsonMode()) {
+        printJson({ address: agent.address() });
+        return;
+      }
+      printBlank();
+      printKeyValue("Address", agent.address());
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/deposit.ts
+import { T2000 as T20005 } from "@t2000/sdk";
+function registerDeposit(program2) {
+  program2.command("deposit").description("Show funding instructions").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T20005.create({ passphrase, keyPath: opts.key });
+      const info = await agent.deposit();
+      if (isJsonMode()) {
+        printJson(info);
+        return;
+      }
+      printHeader("Fund your wallet");
+      console.log(info.instructions);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/history.ts
+import { T2000 as T20006, truncateAddress as truncateAddress2 } from "@t2000/sdk";
+function registerHistory(program2) {
+  program2.command("history").description("Show transaction history").option("--limit <n>", "Number of transactions", "20").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T20006.create({ passphrase, keyPath: opts.key });
+      const txns = await agent.history({ limit: parseInt(opts.limit, 10) });
+      if (isJsonMode()) {
+        printJson(txns);
+        return;
+      }
+      printHeader("Transaction History");
+      if (txns.length === 0) {
+        console.log("  No transactions yet.");
+      } else {
+        for (const tx of txns) {
+          const time = tx.timestamp ? new Date(tx.timestamp).toLocaleString() : "unknown";
+          const gas = tx.gasMethod ? ` (${tx.gasMethod})` : "";
+          console.log(`  ${truncateAddress2(tx.digest)}  ${tx.action}${gas}  ${time}`);
+        }
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/exportKey.ts
+import { T2000 as T20007 } from "@t2000/sdk";
+function registerExport(program2) {
+  program2.command("export").description("Export private key (raw Ed25519 hex)").option("--key <path>", "Key file path").option("--yes", "Skip confirmation").action(async (opts) => {
+    try {
+      if (!opts.yes && !isJsonMode()) {
+        const proceed = await askConfirm(
+          "WARNING: This will display your raw private key. Anyone with this key controls your wallet. Continue?"
+        );
+        if (!proceed) return;
+      }
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T20007.create({ passphrase, keyPath: opts.key });
+      const hex = agent.exportKey();
+      if (isJsonMode()) {
+        printJson({ privateKey: hex, format: "ed25519_hex" });
+        return;
+      }
+      printBlank();
+      printSuccess("Private key (Ed25519, hex):");
+      console.log(`  ${hex}`);
+      printBlank();
+      printInfo("Not a BIP39 mnemonic. Store securely and never share.");
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/importKey.ts
+import { keypairFromPrivateKey, saveKey } from "@t2000/sdk";
+import { password as password2 } from "@inquirer/prompts";
+function registerImport(program2) {
+  program2.command("import").description("Import a wallet from private key").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      let privateKey;
+      if (process.env.T2000_PRIVATE_KEY) {
+        privateKey = process.env.T2000_PRIVATE_KEY;
+      } else {
+        privateKey = await password2({ message: "Enter private key (hex):" });
+      }
+      if (!privateKey) throw new Error("Private key is required");
+      const passphrase = getPassphraseFromEnv() ?? await askPassphraseConfirm();
+      const keypair = keypairFromPrivateKey(privateKey);
+      const address = keypair.getPublicKey().toSuiAddress();
+      await saveKey(keypair, passphrase, opts.key);
+      if (isJsonMode()) {
+        printJson({ address, imported: true });
+        return;
+      }
+      printBlank();
+      printSuccess("Wallet imported (encrypted)");
+      printKeyValue("Address", address);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/save.ts
+import pc4 from "picocolors";
+import { T2000 as T20009, formatUsd as formatUsd3 } from "@t2000/sdk";
+function registerSave(program2) {
+  const action = async (amountStr, opts) => {
+    try {
+      const amount = amountStr === "all" ? "all" : parseFloat(amountStr);
+      if (amount !== "all" && (isNaN(amount) || amount <= 0)) {
+        throw new Error('Amount must be a positive number or "all"');
+      }
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T20009.create({ passphrase, keyPath: opts.key });
+      const globalOpts = program2.optsWithGlobals();
+      if (!globalOpts.yes) {
+        const label = amount === "all" ? "all available USDC" : `$${amount.toFixed(2)} USDC`;
+        const ok = await askConfirm(`Save ${label} to earn yield?`);
+        if (!ok) return;
+      }
+      let gasManagerUsdc = 0;
+      agent.on("gasAutoTopUp", (data) => {
+        gasManagerUsdc = data.usdcSpent;
+      });
+      const result = await agent.save({ amount });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      if (gasManagerUsdc > 0) {
+        printSuccess(`Gas manager: ${pc4.yellow(formatUsd3(gasManagerUsdc))} USDC \u2192 SUI`);
+      }
+      printSuccess(`Saved ${pc4.yellow(formatUsd3(result.amount))} USDC to NAVI`);
+      if (result.fee > 0) {
+        const feeRate = (result.fee / result.amount * 100).toFixed(1);
+        printSuccess(`Protocol fee: ${pc4.dim(`${formatUsd3(result.fee)} USDC (${feeRate}%)`)}`);
+      }
+      printSuccess(`Current APY: ${pc4.green(`${result.apy.toFixed(2)}%`)}`);
+      const savingsBalance = result.amount - result.fee;
+      printSuccess(`Savings balance: ${pc4.yellow(formatUsd3(savingsBalance))} USDC`);
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  };
+  program2.command("save").description("Deposit USDC into savings (NAVI Protocol)").argument("<amount>", 'Amount in USDC to save (or "all")').option("--key <path>", "Key file path").action(action);
+  program2.command("supply").description("Deposit USDC into savings (alias for save)").argument("<amount>", 'Amount in USDC to save (or "all")').option("--key <path>", "Key file path").action(action);
+}
+
+// src/commands/withdraw.ts
+import { T2000 as T200010 } from "@t2000/sdk";
+function registerWithdraw(program2) {
+  program2.command("withdraw").description("Withdraw USDC from savings").argument("<amount>", 'Amount in USDC to withdraw (or "all")').option("--key <path>", "Key file path").action(async (amountStr, opts) => {
+    try {
+      const amount = amountStr === "all" ? "all" : parseFloat(amountStr);
+      if (amount !== "all" && (isNaN(amount) || amount <= 0)) {
+        throw new Error('Amount must be a positive number or "all"');
+      }
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T200010.create({ passphrase, keyPath: opts.key });
+      if (amount !== "all") {
+        const maxResult = await agent.maxWithdraw();
+        if (amount > maxResult.maxAmount) {
+          printWarning(`Max safe withdrawal: $${maxResult.maxAmount.toFixed(2)} (HF ${maxResult.currentHF.toFixed(2)} \u2192 ${maxResult.healthFactorAfter.toFixed(2)})`);
+          return;
+        }
+      }
+      const globalOpts = program2.optsWithGlobals();
+      if (!globalOpts.yes) {
+        const label = amount === "all" ? "all savings" : `$${amount.toFixed(2)} USDC`;
+        const ok = await askConfirm(`Withdraw ${label} from savings?`);
+        if (!ok) return;
+      }
+      const result = await agent.withdraw({ amount });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      printSuccess(`Withdrew $${result.amount.toFixed(2)} USDC`);
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/borrow.ts
+import { T2000 as T200011 } from "@t2000/sdk";
+function registerBorrow(program2) {
+  program2.command("borrow").description("Borrow USDC against savings collateral").argument("<amount>", "Amount in USDC to borrow").option("--key <path>", "Key file path").action(async (amountStr, opts) => {
+    try {
+      const amount = parseFloat(amountStr);
+      if (isNaN(amount) || amount <= 0) {
+        throw new Error("Amount must be a positive number");
+      }
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T200011.create({ passphrase, keyPath: opts.key });
+      const maxResult = await agent.maxBorrow();
+      if (amount > maxResult.maxAmount) {
+        printWarning(`Max safe borrow: $${maxResult.maxAmount.toFixed(2)} (HF ${maxResult.currentHF.toFixed(2)} \u2192 min 1.5)`);
+        return;
+      }
+      const globalOpts = program2.optsWithGlobals();
+      if (!globalOpts.yes) {
+        const ok = await askConfirm(`Borrow $${amount.toFixed(2)} USDC?`);
+        if (!ok) return;
+      }
+      const result = await agent.borrow({ amount });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      printSuccess(`Borrowed $${amount.toFixed(2)} USDC`);
+      printKeyValue("Health Factor", result.healthFactor.toFixed(2));
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/repay.ts
+import { T2000 as T200012 } from "@t2000/sdk";
+function registerRepay(program2) {
+  program2.command("repay").description("Repay borrowed USDC").argument("<amount>", 'Amount in USDC to repay (or "all")').option("--key <path>", "Key file path").action(async (amountStr, opts) => {
+    try {
+      const amount = amountStr === "all" ? "all" : parseFloat(amountStr);
+      if (amount !== "all" && (isNaN(amount) || amount <= 0)) {
+        throw new Error('Amount must be a positive number or "all"');
+      }
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T200012.create({ passphrase, keyPath: opts.key });
+      const globalOpts = program2.optsWithGlobals();
+      if (!globalOpts.yes) {
+        const label = amount === "all" ? "all outstanding USDC debt" : `$${amount.toFixed(2)} USDC`;
+        const ok = await askConfirm(`Repay ${label}?`);
+        if (!ok) return;
+      }
+      const result = await agent.repay({ amount });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      printSuccess(`Repaid $${result.amount.toFixed(2)} USDC`);
+      printKeyValue("Remaining Debt", `$${result.remainingDebt.toFixed(2)}`);
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/health.ts
+import { T2000 as T200013 } from "@t2000/sdk";
+function registerHealth(program2) {
+  program2.command("health").description("Check savings health factor").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T200013.create({ passphrase, keyPath: opts.key });
+      const hf = await agent.healthFactor();
+      if (isJsonMode()) {
+        printJson(hf);
+        return;
+      }
+      printBlank();
+      const hfStr = hf.healthFactor === Infinity ? "\u221E" : hf.healthFactor.toFixed(2);
+      if (hf.healthFactor >= 2) {
+        printSuccess(`Health Factor: ${hfStr} (healthy)`);
+      } else if (hf.healthFactor >= 1.5) {
+        printWarning(`Health Factor: ${hfStr} (moderate)`);
+      } else if (hf.healthFactor >= 1.2) {
+        printWarning(`Health Factor: ${hfStr} (low)`);
+      } else {
+        printError(`Health Factor: ${hfStr} (CRITICAL)`);
+      }
+      printBlank();
+      printKeyValue("Supplied", `$${hf.supplied.toFixed(2)} USDC`);
+      printKeyValue("Borrowed", `$${hf.borrowed.toFixed(2)} USDC`);
+      printKeyValue("Max Borrow", `$${hf.maxBorrow.toFixed(2)} USDC`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/rates.ts
+import { T2000 as T200014 } from "@t2000/sdk";
+function registerRates(program2) {
+  program2.command("rates").description("Show current NAVI Protocol APY rates").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T200014.create({ passphrase, keyPath: opts.key });
+      const rates = await agent.rates();
+      if (isJsonMode()) {
+        printJson(rates);
+        return;
+      }
+      printBlank();
+      printInfo("USDC Rates (NAVI Protocol)");
+      printKeyValue("Save APY", `${rates.USDC.saveApy.toFixed(2)}%`);
+      printKeyValue("Borrow APY", `${rates.USDC.borrowApy.toFixed(2)}%`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/positions.ts
+import { T2000 as T200015 } from "@t2000/sdk";
+function registerPositions(program2) {
+  program2.command("positions").description("Show savings & borrow positions").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T200015.create({ passphrase, keyPath: opts.key });
+      const result = await agent.positions();
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      if (result.positions.length === 0) {
+        printInfo("No positions. Use `t2000 save <amount>` to start earning.");
+      } else {
+        for (const pos of result.positions) {
+          const label = pos.type === "save" ? "\u{1F4C8} Saving" : "\u{1F4C9} Borrowing";
+          printKeyValue(label, `$${pos.amount.toFixed(2)} ${pos.asset} (${pos.protocol})`);
+        }
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/swap.ts
+import { T2000 as T200016 } from "@t2000/sdk";
+function registerSwap(program2) {
+  program2.command("swap").description("Swap between assets (e.g. swap 10 USDC SUI)").argument("<amount>", "Amount to swap").argument("<from>", "Asset to swap from (USDC or SUI)").argument("<to>", "Asset to swap to (USDC or SUI)").option("--slippage <percent>", "Max slippage percentage", "3").option("--key <path>", "Key file path").action(async (amountStr, from, to, opts) => {
+    try {
+      const amount = parseFloat(amountStr);
+      if (isNaN(amount) || amount <= 0) {
+        throw new Error("Amount must be a positive number");
+      }
+      const maxSlippage = parseFloat(opts.slippage ?? "3") / 100;
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T200016.create({ passphrase, keyPath: opts.key });
+      const quote = await agent.swapQuote({ from, to, amount });
+      const globalOpts = program2.optsWithGlobals();
+      if (!globalOpts.yes) {
+        printBlank();
+        printKeyValue("Swap", `${amount} ${from.toUpperCase()} \u2192 ${quote.expectedOutput.toFixed(4)} ${to.toUpperCase()}`);
+        printKeyValue("Pool Price", `1 SUI = $${quote.poolPrice.toFixed(2)}`);
+        if (quote.fee.amount > 0) {
+          printKeyValue("Protocol Fee", `$${quote.fee.amount.toFixed(4)} (${quote.fee.rate}%)`);
+        }
+        printBlank();
+        const ok = await askConfirm("Execute swap?");
+        if (!ok) return;
+      }
+      const result = await agent.swap({ from, to, amount, maxSlippage });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      printSuccess(`Swapped ${result.fromAmount} ${result.fromAsset} \u2192 ${result.toAmount.toFixed(4)} ${result.toAsset}`);
+      if (result.priceImpact > 1e-3) {
+        printWarning(`Price impact: ${(result.priceImpact * 100).toFixed(2)}%`);
+      }
+      if (result.fee > 0) {
+        printKeyValue("Fee", `$${result.fee.toFixed(4)}`);
+      }
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/earnings.ts
+import { T2000 as T200017 } from "@t2000/sdk";
+function registerEarnings(program2) {
+  program2.command("earnings").description("Show yield earned to date").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T200017.create({ passphrase, keyPath: opts.key });
+      const result = await agent.earnings();
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      printKeyValue("Saved", `$${result.supplied.toFixed(2)} USDC`);
+      printKeyValue("APY", `${result.currentApy.toFixed(2)}%`);
+      printKeyValue("Daily Yield", `~$${result.dailyEarning.toFixed(4)}/day`);
+      printKeyValue("Est. Earned", `~$${result.totalYieldEarned.toFixed(4)}`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/fundStatus.ts
+import { T2000 as T200018 } from "@t2000/sdk";
+function registerFundStatus(program2) {
+  program2.command("fund-status").description("Full savings summary").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T200018.create({ passphrase, keyPath: opts.key });
+      const result = await agent.fundStatus();
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      if (result.supplied > 0) {
+        printSuccess("Savings: ACTIVE");
+      } else {
+        console.log("  Savings: INACTIVE \u2014 deposit USDC and run `t2000 save`");
+      }
+      printBlank();
+      printKeyValue("Saved", `$${result.supplied.toFixed(2)} USDC @ ${result.apy.toFixed(1)}% APY`);
+      printKeyValue("Earned today", `~$${result.earnedToday.toFixed(4)}`);
+      printKeyValue("Earned all time", `~$${result.earnedAllTime.toFixed(4)}`);
+      printKeyValue("Monthly projected", `~$${result.projectedMonthly.toFixed(2)}/month`);
+      printBlank();
+      if (result.supplied > 0) {
+        console.log("  Withdraw anytime: t2000 withdraw <amount>");
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".t2000");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+function registerConfig(program2) {
+  const configCmd = program2.command("config").description("Show or set configuration");
+  configCmd.command("get").argument("[key]", "Config key to get (omit for all)").action((key) => {
+    try {
+      const config = loadConfig();
+      if (isJsonMode()) {
+        printJson(key ? { [key]: config[key] } : config);
+        return;
+      }
+      printBlank();
+      if (key) {
+        printKeyValue(key, String(config[key] ?? "(not set)"));
+      } else {
+        if (Object.keys(config).length === 0) {
+          console.log("  No configuration set.");
+        } else {
+          for (const [k, v] of Object.entries(config)) {
+            printKeyValue(k, String(v));
+          }
+        }
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  configCmd.command("set").argument("<key>", "Config key").argument("<value>", "Config value").action((key, value) => {
+    try {
+      const config = loadConfig();
+      let parsed = value;
+      if (value === "true") parsed = true;
+      else if (value === "false") parsed = false;
+      else if (!isNaN(Number(value)) && value.trim() !== "") parsed = Number(value);
+      config[key] = parsed;
+      saveConfig(config);
+      if (isJsonMode()) {
+        printJson({ [key]: parsed });
+        return;
+      }
+      console.log(`  Set ${key} = ${String(parsed)}`);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/serve.ts
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { randomBytes } from "crypto";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { T2000 as T200019 } from "@t2000/sdk";
+import { streamSSE } from "hono/streaming";
+var CONFIG_DIR2 = join2(homedir2(), ".t2000");
+var TOKEN_PATH = join2(CONFIG_DIR2, "config.json");
+function generateToken() {
+  return `t2k_${randomBytes(24).toString("hex")}`;
+}
+function saveToken(token) {
+  if (!existsSync2(CONFIG_DIR2)) {
+    mkdirSync2(CONFIG_DIR2, { recursive: true });
+  }
+  let config = {};
+  try {
+    config = JSON.parse(readFileSync2(TOKEN_PATH, "utf-8"));
+  } catch {
+  }
+  config.authToken = token;
+  writeFileSync2(TOKEN_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+function envelope(data) {
+  return { success: true, data, timestamp: Math.floor(Date.now() / 1e3) };
+}
+function errorResponse(code, message, data, retryable = false) {
+  return {
+    success: false,
+    error: { code, message, data, retryable },
+    timestamp: Math.floor(Date.now() / 1e3)
+  };
+}
+function registerServe(program2) {
+  program2.command("serve").description("Start HTTP API server").option("--port <port>", "Port number", "3001").option("--rate-limit <rps>", "Max requests per second", "10").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T200019.create({ passphrase, keyPath: opts.key });
+      const port = parseInt(opts.port, 10);
+      const rateLimit = parseInt(opts.rateLimit, 10);
+      const token = generateToken();
+      saveToken(token);
+      const app = buildApp(agent, token, rateLimit);
+      serve({ fetch: app.fetch, port });
+      console.log(`  \u2713 API server running on http://localhost:${port}`);
+      console.log(`  \u2713 Auth token: ${token}`);
+      console.log("");
+      console.log("  Endpoints:");
+      console.log("    GET  /v1/balance        POST /v1/send");
+      console.log("    GET  /v1/address         POST /v1/save");
+      console.log("    GET  /v1/history         POST /v1/withdraw");
+      console.log("    GET  /v1/earnings        POST /v1/swap");
+      console.log("    GET  /v1/rates           POST /v1/borrow");
+      console.log("    GET  /v1/health-factor   POST /v1/repay");
+      console.log("    GET  /v1/positions");
+      console.log("    GET  /v1/events          (SSE)");
+      console.log("");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+function buildApp(agent, authToken, rateLimit) {
+  const app = new Hono();
+  app.use("*", cors());
+  const requestLog = [];
+  app.use("/v1/*", async (c, next) => {
+    const now = Date.now();
+    const windowMs = 1e3;
+    while (requestLog.length > 0 && requestLog[0] < now - windowMs) {
+      requestLog.shift();
+    }
+    if (requestLog.length >= rateLimit) {
+      c.status(429);
+      c.header("Retry-After", "1");
+      return c.json(errorResponse("RATE_LIMITED", "Too many requests", null, true));
+    }
+    requestLog.push(now);
+    await next();
+  });
+  app.use("/v1/*", async (c, next) => {
+    const auth = c.req.header("Authorization");
+    if (!auth || auth !== `Bearer ${authToken}`) {
+      c.status(401);
+      return c.json(errorResponse("UNAUTHORIZED", "Invalid or missing Bearer token"));
+    }
+    await next();
+  });
+  app.get("/v1/address", (c) => {
+    return c.json(envelope({ address: agent.address }));
+  });
+  app.get("/v1/balance", async (c) => {
+    try {
+      const balance = await agent.balance();
+      return c.json(envelope(balance));
+    } catch (err) {
+      return c.json(errorResponse("BALANCE_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/history", async (c) => {
+    try {
+      const limit = parseInt(c.req.query("limit") ?? "20", 10);
+      const history = await agent.history({ limit });
+      return c.json(envelope(history));
+    } catch (err) {
+      return c.json(errorResponse("HISTORY_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/deposit", (c) => {
+    return c.json(envelope({
+      address: agent.address,
+      network: "mainnet",
+      instructions: "Send USDC to this address on Sui mainnet."
+    }));
+  });
+  app.get("/v1/earnings", async (c) => {
+    try {
+      const earnings = await agent.earnings();
+      return c.json(envelope(earnings));
+    } catch (err) {
+      return c.json(errorResponse("EARNINGS_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/rates", async (c) => {
+    try {
+      const rates = await agent.rates();
+      return c.json(envelope(rates));
+    } catch (err) {
+      return c.json(errorResponse("RATES_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/health-factor", async (c) => {
+    try {
+      const hf = await agent.healthFactor();
+      return c.json(envelope(hf));
+    } catch (err) {
+      return c.json(errorResponse("HEALTH_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/max-withdraw", async (c) => {
+    try {
+      const result = await agent.maxWithdraw();
+      return c.json(envelope(result));
+    } catch (err) {
+      return c.json(errorResponse("MAX_WITHDRAW_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/max-borrow", async (c) => {
+    try {
+      const result = await agent.maxBorrow();
+      return c.json(envelope(result));
+    } catch (err) {
+      return c.json(errorResponse("MAX_BORROW_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/positions", async (c) => {
+    try {
+      const positions = await agent.positions();
+      return c.json(envelope(positions));
+    } catch (err) {
+      return c.json(errorResponse("POSITIONS_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.post("/v1/send", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { to, amount, asset } = body;
+      if (!to || !amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: to, amount"));
+      }
+      const result = await agent.send({ to, amount, asset: asset ?? "USDC" });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.post("/v1/save", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { amount, asset } = body;
+      if (!amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: amount"));
+      }
+      const result = await agent.save({ amount, asset: asset ?? "USDC" });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.post("/v1/supply", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { amount, asset } = body;
+      if (!amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: amount"));
+      }
+      const result = await agent.save({ amount, asset: asset ?? "USDC" });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.post("/v1/withdraw", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { amount, asset } = body;
+      if (!amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: amount"));
+      }
+      const result = await agent.withdraw({ amount, asset: asset ?? "USDC" });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.post("/v1/swap", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { from, to, amount, maxSlippage } = body;
+      if (!from || !to || !amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: from, to, amount"));
+      }
+      const result = await agent.swap({ from, to, amount, maxSlippage });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.post("/v1/borrow", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { amount, asset } = body;
+      if (!amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: amount"));
+      }
+      const result = await agent.borrow({ amount, asset: asset ?? "USDC" });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.post("/v1/repay", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { amount, asset } = body;
+      if (!amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: amount"));
+      }
+      const result = await agent.repay({ amount, asset: asset ?? "USDC" });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.get("/v1/events", async (c) => {
+    const subscribeParam = c.req.query("subscribe") ?? "yield,balanceChange,healthWarning";
+    const subscriptions = new Set(subscribeParam.split(",").map((s) => s.trim()));
+    return streamSSE(c, async (stream) => {
+      const handlers = [];
+      for (const eventName of subscriptions) {
+        const handler = (data) => {
+          stream.writeSSE({ event: eventName, data: JSON.stringify(data) }).catch(() => {
+          });
+        };
+        agent.on(eventName, handler);
+        handlers.push({
+          event: eventName,
+          off: () => agent.off(eventName, handler)
+        });
+      }
+      const keepAlive = setInterval(() => {
+        stream.writeSSE({ event: "ping", data: "{}" }).catch(() => {
+        });
+      }, 3e4);
+      stream.onAbort(() => {
+        clearInterval(keepAlive);
+        for (const h of handlers) h.off();
+      });
+      await new Promise(() => {
+      });
+    });
+  });
+  return app;
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function handleApiError(err) {
+  const t2kErr = err;
+  return errorResponse(
+    t2kErr.code ?? "UNKNOWN",
+    t2kErr.message ?? errMsg(err),
+    t2kErr.data,
+    isRetryable(t2kErr.code)
+  );
+}
+function getStatusCode(err) {
+  const code = err.code;
+  if (!code) return 500;
+  if (code === "INSUFFICIENT_BALANCE") return 400;
+  if (code === "INVALID_ADDRESS") return 400;
+  if (code === "WITHDRAW_WOULD_LIQUIDATE") return 400;
+  if (code === "NO_COLLATERAL") return 400;
+  return 500;
+}
+function isRetryable(code) {
+  if (!code) return false;
+  return ["RPC_ERROR", "RPC_UNREACHABLE", "SPONSOR_UNAVAILABLE", "AUTO_TOPUP_FAILED"].includes(code);
+}
+
+// src/commands/pay.ts
+import pc5 from "picocolors";
+import { T2000 as T200020 } from "@t2000/sdk";
+import { x402Client } from "@t2000/x402";
+function createX402Wallet(agent) {
+  return {
+    client: agent.suiClient,
+    keypair: agent.signer,
+    address: () => agent.address(),
+    signAndExecute: async (tx) => {
+      const result = await agent.suiClient.signAndExecuteTransaction({
+        signer: agent.signer,
+        transaction: tx
+      });
+      return { digest: result.digest };
+    }
+  };
+}
+function registerPay(program2) {
+  program2.command("pay <url>").description("Pay for an x402-protected API resource").option("--key <path>", "Key file path").option("--method <method>", "HTTP method (GET, POST, PUT)", "GET").option("--data <json>", "Request body for POST/PUT").option("--header <key=value>", "Additional HTTP header (repeatable)", collectHeaders, {}).option("--max-price <amount>", "Max USDC price to auto-approve", "1.00").option("--timeout <seconds>", "Request timeout in seconds", "30").option("--dry-run", "Show what would be paid without paying").action(async (url, opts) => {
+    try {
+      const passphrase = getPassphraseFromEnv() ?? await askPassphrase();
+      const agent = await T200020.create({ passphrase, keyPath: opts.key });
+      const wallet = createX402Wallet(agent);
+      const client = new x402Client(wallet);
+      const startTime = Date.now();
+      if (!isJsonMode()) {
+        printBlank();
+        printInfo(`\u2192 ${opts.method} ${url}`);
+      }
+      const response = await client.fetch(url, {
+        method: opts.method,
+        headers: opts.header,
+        body: opts.data,
+        maxPrice: parseFloat(opts.maxPrice),
+        timeout: parseInt(opts.timeout, 10) * 1e3,
+        dryRun: opts.dryRun,
+        onPayment: (details) => {
+          if (!isJsonMode()) {
+            printInfo(`\u2190 402 Payment Required: $${details.amount} USDC (Sui)`);
+            printSuccess(`Paid $${details.amount} USDC (tx: ${details.txHash.slice(0, 10)}...)`);
+          }
+        }
+      });
+      const elapsed = Date.now() - startTime;
+      if (!isJsonMode()) {
+        printInfo(`\u2190 ${response.status} ${response.statusText || "OK"}  ${pc5.dim(`[${elapsed}ms]`)}`);
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      const body = contentType.includes("application/json") ? await response.json() : await response.text();
+      if (isJsonMode()) {
+        printJson({
+          status: response.status,
+          url,
+          elapsed,
+          body
+        });
+      } else {
+        printBlank();
+        if (typeof body === "string") {
+          console.log(body);
+        } else {
+          console.log(JSON.stringify(body, null, 2));
+        }
+        printBlank();
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+function collectHeaders(value, previous) {
+  const [key, ...rest] = value.split("=");
+  if (key && rest.length > 0) {
+    previous[key.trim()] = rest.join("=").trim();
+  }
+  return previous;
+}
+
+// src/program.ts
+function createProgram() {
+  const program2 = new Command();
+  program2.name("t2000").description("The first wallet for AI agents").version("0.1.0").option("--json", "Output in JSON format").option("--yes", "Skip confirmation prompts").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    if (opts.json) setJsonMode(true);
+  });
+  registerInit(program2);
+  registerSend(program2);
+  registerBalance(program2);
+  registerAddress(program2);
+  registerDeposit(program2);
+  registerHistory(program2);
+  registerExport(program2);
+  registerImport(program2);
+  registerSave(program2);
+  registerWithdraw(program2);
+  registerBorrow(program2);
+  registerRepay(program2);
+  registerHealth(program2);
+  registerRates(program2);
+  registerPositions(program2);
+  registerSwap(program2);
+  registerEarnings(program2);
+  registerFundStatus(program2);
+  registerConfig(program2);
+  registerServe(program2);
+  registerPay(program2);
+  return program2;
+}
+
+// src/index.ts
+var program = createProgram();
+program.parse();
+//# sourceMappingURL=index.js.map