sellbonds-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1181 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// ../sdk/dist/index.js
+import { getAddress, isAddress } from "viem";
+import { base, baseSepolia } from "viem/chains";
+import {
+  createPublicClient,
+  createWalletClient,
+  fallback,
+  http
+} from "viem";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import { parseEther } from "viem";
+import { randomBytes } from "crypto";
+import {
+  encodeAbiParameters,
+  getAddress as getAddress2,
+  parseAbiParameters,
+  zeroAddress
+} from "viem";
+import { BaseError, ContractFunctionRevertedError } from "viem";
+import { formatUnits, parseUnits } from "viem";
+var base_default = {
+  chainId: 8453,
+  chain: "base",
+  label: "Base",
+  rpcUrl: "https://mainnet.base.org",
+  explorer: "https://basescan.org",
+  faucetUrl: "",
+  testnet: false,
+  deployed: true,
+  deployer: "0x223bb3aa4418a99180814b4d4ab614bafaeda2de",
+  contracts: {
+    WildcatArchController: "0x0dbb4426844266add3ab840935cd1a3a67dd4ef6",
+    WildcatSanctionsSentinel: "0x402ead2d9aaeedfb53fda4b39fc668c6545beee9",
+    NullSanctionsOracle: "0x23c8d3ab08e998919d9a1f98a4eb6c5da6c01ae7",
+    HooksFactory: "0x6fe029dfc85924c83a2f7159292f53b3a9a3806f",
+    OpenTermHooksTemplate: "0xf45cd0d37b5fdf4b5e54d40d1c95c43018c4b55a",
+    FixedTermHooksTemplate: "0x2c37ce66c2e9c37789d659e02657faa83ac3d7aa",
+    TestUSDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    WildcatMarketInitCodeStorage: "0x29741d542e1f6a6ad0ee3e7734cf478755630a24",
+    BondNotes: "0xbe5369cfcbe284d42306bc462be796a7c764dbe9"
+  },
+  deployedAt: 1780758919
+};
+var base_sepolia_default = {
+  chainId: 84532,
+  chain: "base-sepolia",
+  label: "Base Sepolia (testnet)",
+  rpcUrl: "https://sepolia.base.org",
+  explorer: "https://sepolia.basescan.org",
+  faucetUrl: "https://sellbonds.now/api/faucet",
+  testnet: true,
+  deployed: true,
+  deployer: "0x223bb3aa4418a99180814b4d4ab614bafaeda2de",
+  contracts: {
+    WildcatArchController: "0x0dbb4426844266add3ab840935cd1a3a67dd4ef6",
+    WildcatSanctionsSentinel: "0x402ead2d9aaeedfb53fda4b39fc668c6545beee9",
+    NullSanctionsOracle: "0x23c8d3ab08e998919d9a1f98a4eb6c5da6c01ae7",
+    HooksFactory: "0x6fe029dfc85924c83a2f7159292f53b3a9a3806f",
+    OpenTermHooksTemplate: "0xf45cd0d37b5fdf4b5e54d40d1c95c43018c4b55a",
+    FixedTermHooksTemplate: "0x2c37ce66c2e9c37789d659e02657faa83ac3d7aa",
+    TestUSDC: "0xbe5369cfcbe284d42306bc462be796a7c764dbe9",
+    WildcatMarketInitCodeStorage: "0x29741d542e1f6a6ad0ee3e7734cf478755630a24"
+  },
+  deployedAt: 1780320142
+};
+var ZERO = "0x0000000000000000000000000000000000000000";
+var DEPLOYMENTS = {
+  base: base_default,
+  "base-sepolia": base_sepolia_default
+};
+var DEFAULT_NETWORK = "base";
+function networkName() {
+  return process.env.SBN_NETWORK?.trim() || DEFAULT_NETWORK;
+}
+function loadDeployment(network = networkName()) {
+  const base2 = DEPLOYMENTS[network];
+  if (!base2) {
+    throw new Error(
+      `Unknown network "${network}". Known networks: ${Object.keys(DEPLOYMENTS).join(", ")}.`
+    );
+  }
+  const d = JSON.parse(JSON.stringify(base2));
+  const env = process.env;
+  if (env.SBN_RPC_URL?.trim()) d.rpcUrl = env.SBN_RPC_URL.trim();
+  if (env.SBN_EXPLORER?.trim()) d.explorer = env.SBN_EXPLORER.trim();
+  if (env.SBN_FAUCET_URL?.trim()) d.faucetUrl = env.SBN_FAUCET_URL.trim();
+  const overrideAddr = (envKey, target) => {
+    const v = env[envKey]?.trim();
+    if (v && isAddress(v)) d.contracts[target] = getAddress(v);
+  };
+  overrideAddr("SBN_ARCH_CONTROLLER", "WildcatArchController");
+  overrideAddr("SBN_HOOKS_FACTORY", "HooksFactory");
+  overrideAddr("SBN_OPEN_TERM_TEMPLATE", "OpenTermHooksTemplate");
+  overrideAddr("SBN_FIXED_TERM_TEMPLATE", "FixedTermHooksTemplate");
+  overrideAddr("SBN_USDC", "TestUSDC");
+  d.deployed = d.contracts.WildcatArchController !== ZERO && d.contracts.HooksFactory !== ZERO && d.contracts.OpenTermHooksTemplate !== ZERO;
+  return d;
+}
+function assertDeployed(d) {
+  if (!d.deployed) {
+    throw new Error(
+      `sellbonds.now is not deployed on ${d.label} yet. If you just deployed, set SBN_ARCH_CONTROLLER / SBN_HOOKS_FACTORY / SBN_OPEN_TERM_TEMPLATE / SBN_FIXED_TERM_TEMPLATE / SBN_USDC, or rebuild sellbonds with the populated deployments file.`
+    );
+  }
+}
+function viemChain(d) {
+  if (d.chainId === base.id) return base;
+  if (d.chainId === baseSepolia.id) return baseSepolia;
+  return {
+    id: d.chainId,
+    name: d.label,
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: [d.rpcUrl] } },
+    blockExplorers: { default: { name: "Explorer", url: d.explorer } }
+  };
+}
+function txUrl(d, hash) {
+  return `${d.explorer}/tx/${hash}`;
+}
+function addressUrl(d, address) {
+  return `${d.explorer}/address/${address}`;
+}
+var SBN_HOME = process.env.SBN_HOME?.trim() || join(homedir(), ".sellbondsnow");
+var WALLET_PATH = join(SBN_HOME, "wallet.json");
+var MARKETS_PATH = join(SBN_HOME, "markets.json");
+var KEYSTORE_NOTE = "sellbonds.now agent wallet. PLAINTEXT testnet key, mode 0600. Do not reuse this key on mainnet with real funds. Back it up if you care about the markets it controls.";
+function ensureHome() {
+  if (!existsSync(SBN_HOME)) mkdirSync(SBN_HOME, { recursive: true, mode: 448 });
+}
+function walletExists() {
+  return existsSync(WALLET_PATH);
+}
+function createWallet() {
+  ensureHome();
+  const privateKey = generatePrivateKey();
+  const account2 = privateKeyToAccount(privateKey);
+  const wallet = {
+    address: account2.address,
+    privateKey,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    note: KEYSTORE_NOTE
+  };
+  writeWallet(wallet);
+  return wallet;
+}
+function writeWallet(wallet) {
+  ensureHome();
+  writeFileSync(WALLET_PATH, JSON.stringify(wallet, null, 2), { mode: 384 });
+  chmodSync(WALLET_PATH, 384);
+}
+function loadWallet() {
+  if (!walletExists()) {
+    throw new Error(
+      `No wallet found at ${WALLET_PATH}. Create one with \`sbn wallet new\` (or it will be created automatically by \`sbn raise\`).`
+    );
+  }
+  return JSON.parse(readFileSync(WALLET_PATH, "utf8"));
+}
+function loadOrCreateWallet() {
+  if (walletExists()) return { wallet: loadWallet(), created: false };
+  return { wallet: createWallet(), created: true };
+}
+function account() {
+  const envKey = process.env.SBN_PRIVATE_KEY?.trim();
+  if (envKey) {
+    const hex = envKey.startsWith("0x") ? envKey : `0x${envKey}`;
+    return privateKeyToAccount(hex);
+  }
+  return privateKeyToAccount(loadWallet().privateKey);
+}
+function recordMarket(record) {
+  ensureHome();
+  const existing = listMarkets();
+  existing.push(record);
+  writeFileSync(MARKETS_PATH, JSON.stringify(existing, null, 2), { mode: 384 });
+}
+function listMarkets() {
+  if (!existsSync(MARKETS_PATH)) return [];
+  try {
+    return JSON.parse(readFileSync(MARKETS_PATH, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function rpcTransport(d) {
+  const candidates = [
+    d.rpcUrl,
+    d.testnet ? void 0 : "https://sellbonds.now/rpc",
+    d.testnet ? "https://sepolia.base.org" : "https://mainnet.base.org"
+  ].filter((u) => !!u);
+  const seen = /* @__PURE__ */ new Set();
+  const urls = candidates.filter((u) => {
+    const k = u.toLowerCase();
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+  return fallback(urls.map((u) => http(u, { retryCount: 1 })));
+}
+function connect(network, acct = account()) {
+  const deployment = loadDeployment(network);
+  const chain = viemChain(deployment);
+  const transport2 = rpcTransport(deployment);
+  const publicClient = createPublicClient({ chain, transport: transport2 });
+  const walletClient = createWalletClient({ account: acct, chain, transport: transport2 });
+  return { deployment, publicClient, walletClient, account: acct };
+}
+function connectReadonly(network) {
+  const deployment = loadDeployment(network);
+  const chain = viemChain(deployment);
+  const publicClient = createPublicClient({ chain, transport: rpcTransport(deployment) });
+  return { deployment, publicClient };
+}
+async function requestEthFromFaucet(faucetUrl, address) {
+  try {
+    const res = await fetch(faucetUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ address })
+    });
+    let body = {};
+    try {
+      body = await res.json();
+    } catch {
+    }
+    if (!res.ok) {
+      return { ok: false, message: body?.error || body?.message || `faucet returned ${res.status}` };
+    }
+    return { ok: true, txHash: body?.txHash, message: body?.message };
+  } catch (err) {
+    return { ok: false, message: err instanceof Error ? err.message : String(err) };
+  }
+}
+var archControllerAbi = [
+  { type: "function", name: "registerSelf", inputs: [], outputs: [], stateMutability: "nonpayable" },
+  {
+    type: "function",
+    name: "isRegisteredBorrower",
+    inputs: [{ name: "borrower", type: "address" }],
+    outputs: [{ type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getRegisteredMarkets",
+    inputs: [],
+    outputs: [{ type: "address[]" }],
+    stateMutability: "view"
+  },
+  { type: "event", name: "BorrowerAdded", inputs: [{ name: "borrower", type: "address", indexed: true }] },
+  { type: "error", name: "BorrowerAlreadyExists", inputs: [] }
+];
+var deployMarketInputs = {
+  name: "parameters",
+  type: "tuple",
+  components: [
+    { name: "asset", type: "address" },
+    { name: "namePrefix", type: "string" },
+    { name: "symbolPrefix", type: "string" },
+    { name: "maxTotalSupply", type: "uint128" },
+    { name: "annualInterestBips", type: "uint16" },
+    { name: "delinquencyFeeBips", type: "uint16" },
+    { name: "withdrawalBatchDuration", type: "uint32" },
+    { name: "reserveRatioBips", type: "uint16" },
+    { name: "delinquencyGracePeriod", type: "uint32" },
+    { name: "hooks", type: "uint256" }
+  ]
+};
+var hooksFactoryAbi = [
+  {
+    type: "function",
+    name: "deployMarketAndHooks",
+    inputs: [
+      { name: "hooksTemplate", type: "address" },
+      { name: "hooksTemplateArgs", type: "bytes" },
+      deployMarketInputs,
+      { name: "hooksData", type: "bytes" },
+      { name: "salt", type: "bytes32" },
+      { name: "originationFeeAsset", type: "address" },
+      { name: "originationFeeAmount", type: "uint256" }
+    ],
+    outputs: [
+      { name: "market", type: "address" },
+      { name: "hooksInstance", type: "address" }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "computeMarketAddress",
+    inputs: [{ name: "salt", type: "bytes32" }],
+    outputs: [{ type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "MarketDeployed",
+    inputs: [
+      { name: "hooksTemplate", type: "address", indexed: true },
+      { name: "market", type: "address", indexed: true },
+      { name: "name", type: "string", indexed: false },
+      { name: "symbol", type: "string", indexed: false },
+      { name: "asset", type: "address", indexed: false },
+      { name: "maxTotalSupply", type: "uint256", indexed: false },
+      { name: "annualInterestBips", type: "uint256", indexed: false },
+      { name: "delinquencyFeeBips", type: "uint256", indexed: false },
+      { name: "withdrawalBatchDuration", type: "uint256", indexed: false },
+      { name: "reserveRatioBips", type: "uint256", indexed: false },
+      { name: "delinquencyGracePeriod", type: "uint256", indexed: false },
+      { name: "hooks", type: "uint256", indexed: false }
+    ]
+  }
+];
+var marketAbi = [
+  // --- writes ---
+  { type: "function", name: "deposit", inputs: [{ name: "amount", type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
+  { type: "function", name: "depositUpTo", inputs: [{ name: "amount", type: "uint256" }], outputs: [{ type: "uint256" }], stateMutability: "nonpayable" },
+  { type: "function", name: "borrow", inputs: [{ name: "amount", type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
+  { type: "function", name: "repay", inputs: [{ name: "amount", type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
+  {
+    type: "function",
+    name: "repayAndProcessUnpaidWithdrawalBatches",
+    inputs: [
+      { name: "repayAmount", type: "uint256" },
+      { name: "maxBatches", type: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  { type: "function", name: "queueWithdrawal", inputs: [{ name: "amount", type: "uint256" }], outputs: [{ name: "expiry", type: "uint32" }], stateMutability: "nonpayable" },
+  { type: "function", name: "queueFullWithdrawal", inputs: [], outputs: [{ name: "expiry", type: "uint32" }], stateMutability: "nonpayable" },
+  {
+    type: "function",
+    name: "executeWithdrawal",
+    inputs: [
+      { name: "accountAddress", type: "address" },
+      { name: "expiry", type: "uint32" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  { type: "function", name: "closeMarket", inputs: [], outputs: [], stateMutability: "nonpayable" },
+  { type: "function", name: "setBackupCloser", inputs: [{ name: "newBackupCloser", type: "address" }], outputs: [], stateMutability: "nonpayable" },
+  { type: "function", name: "updateState", inputs: [], outputs: [], stateMutability: "nonpayable" },
+  // --- reads ---
+  { type: "function", name: "asset", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
+  { type: "function", name: "name", inputs: [], outputs: [{ type: "string" }], stateMutability: "view" },
+  { type: "function", name: "symbol", inputs: [], outputs: [{ type: "string" }], stateMutability: "view" },
+  { type: "function", name: "decimals", inputs: [], outputs: [{ type: "uint8" }], stateMutability: "view" },
+  { type: "function", name: "borrower", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
+  { type: "function", name: "balanceOf", inputs: [{ name: "account", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "scaledBalanceOf", inputs: [{ name: "account", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "totalSupply", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "totalAssets", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "borrowableAssets", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "coverageLiquidity", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "maximumDeposit", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "annualInterestBips", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "reserveRatioBips", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "isClosed", inputs: [], outputs: [{ type: "bool" }], stateMutability: "view" },
+  { type: "function", name: "getUnpaidBatchExpiries", inputs: [], outputs: [{ type: "uint32[]" }], stateMutability: "view" },
+  {
+    type: "function",
+    name: "getAvailableWithdrawalAmount",
+    inputs: [
+      { name: "accountAddress", type: "address" },
+      { name: "expiry", type: "uint32" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  // --- events ---
+  { type: "event", name: "Deposit", inputs: [{ name: "account", type: "address", indexed: true }, { name: "assetAmount", type: "uint256", indexed: false }, { name: "scaledAmount", type: "uint256", indexed: false }] },
+  { type: "event", name: "Borrow", inputs: [{ name: "assetAmount", type: "uint256", indexed: false }] },
+  { type: "event", name: "DebtRepaid", inputs: [{ name: "from", type: "address", indexed: true }, { name: "assetAmount", type: "uint256", indexed: false }] },
+  { type: "event", name: "WithdrawalQueued", inputs: [{ name: "expiry", type: "uint32", indexed: true }, { name: "account", type: "address", indexed: true }, { name: "scaledAmount", type: "uint256", indexed: false }, { name: "normalizedAmount", type: "uint256", indexed: false }] },
+  { type: "event", name: "MarketClosed", inputs: [{ name: "timestamp", type: "uint256", indexed: false }] }
+];
+var erc20Abi = [
+  { type: "function", name: "approve", inputs: [{ name: "spender", type: "address" }, { name: "amount", type: "uint256" }], outputs: [{ type: "bool" }], stateMutability: "nonpayable" },
+  { type: "function", name: "allowance", inputs: [{ name: "owner", type: "address" }, { name: "spender", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "balanceOf", inputs: [{ name: "account", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "decimals", inputs: [], outputs: [{ type: "uint8" }], stateMutability: "view" },
+  { type: "function", name: "symbol", inputs: [], outputs: [{ type: "string" }], stateMutability: "view" },
+  // test-USDC only (permissionless mint on testnet)
+  { type: "function", name: "mint", inputs: [{ name: "to", type: "address" }, { name: "amount", type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
+  { type: "function", name: "drip", inputs: [], outputs: [], stateMutability: "nonpayable" }
+];
+var bondNotesAbi = [
+  { type: "function", name: "describe", inputs: [{ name: "market", type: "address" }, { name: "name", type: "string" }, { name: "description", type: "string" }], outputs: [], stateMutability: "nonpayable" },
+  { type: "function", name: "notes", inputs: [{ name: "market", type: "address" }], outputs: [{ name: "name", type: "string" }, { name: "description", type: "string" }, { name: "author", type: "address" }, { name: "updatedAt", type: "uint40" }], stateMutability: "view" }
+];
+var ERROR_HELP = {
+  BorrowerAlreadyExists: "This wallet is already registered as an issuer. You can skip `register` and deploy markets directly.",
+  NotApprovedBorrower: "This wallet is not registered as an issuer yet. Run `sbn register` first.",
+  HooksTemplateNotFound: "The hooks template address is wrong for this network. Check the deployment addresses.",
+  SaltDoesNotContainSender: "The market salt must start with your address. This is an SDK bug \u2014 please report it.",
+  MarketAlreadyExists: "A market already exists for that salt. Retry \u2014 the SDK will pick a fresh salt.",
+  AssetBlacklisted: "The chosen asset is blacklisted on this deployment.",
+  FeeMismatch: "Origination fee args do not match the template (templates are zero-fee; pass 0).",
+  DepositToClosedMarket: "This market is closed; deposits are no longer accepted.",
+  MaxSupplyExceeded: "Deposit would exceed the market cap (maxTotalSupply). Deposit less or use a market with a higher cap.",
+  NullMintAmount: "Deposit too small \u2014 it scales to zero market tokens. Deposit a larger amount.",
+  AccountBlocked: "This address is flagged by the sanctions sentinel and cannot transact.",
+  BorrowAmountTooHigh: "Borrow exceeds available liquidity (assets minus required reserves and pending withdrawals).",
+  BorrowFromClosedMarket: "This market is closed; borrowing is no longer possible.",
+  BorrowWhileSanctioned: "The borrower address is flagged by the sanctions sentinel.",
+  NullRepayAmount: "Repay amount is zero.",
+  RepayToClosedMarket: "This market is closed; use the closure flow instead of repay.",
+  CloseMarketWithUnpaidWithdrawals: "Cannot close: there are unpaid withdrawal batches. Repay enough to cover them first.",
+  WithdrawalBatchNotExpired: "The withdrawal batch has not expired yet. Wait until the batch expiry before claiming.",
+  NullWithdrawalAmount: "Nothing claimable for this account/batch right now.",
+  NullBurnAmount: "Withdrawal amount scales to zero \u2014 you may have no balance in this market.",
+  CallerNotBorrowerOrBackupCloser: "Only the issuer (borrower) or the configured backup closer can close this market."
+};
+function explainError(err) {
+  if (err instanceof BaseError) {
+    const revert = err.walk((e) => e instanceof ContractFunctionRevertedError);
+    if (revert instanceof ContractFunctionRevertedError) {
+      const name = revert.data?.errorName ?? revert.reason ?? "revert";
+      const help = ERROR_HELP[name];
+      return help ? `${name}: ${help}` : `Reverted: ${name}`;
+    }
+    return err.shortMessage || err.message;
+  }
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+var USDC_DECIMALS = 6;
+function pctToBips(pct) {
+  return Math.round(pct * 100);
+}
+function parseDuration(input) {
+  if (typeof input === "number") return input;
+  const m = input.trim().match(/^(\d+(?:\.\d+)?)\s*([smhdwy]?)$/i);
+  if (!m) throw new Error(`Invalid duration "${input}". Use e.g. 90d, 1y, 12h, or seconds.`);
+  const value = parseFloat(m[1]);
+  const unit = (m[2] || "s").toLowerCase();
+  const mult = {
+    s: 1,
+    m: 60,
+    h: 3600,
+    d: 86400,
+    w: 604800,
+    y: 31536e3
+  };
+  return Math.round(value * mult[unit]);
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function isTransientSendError(err) {
+  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  return msg.includes("nonce") || msg.includes("replacement transaction underpriced") || msg.includes("already known") || msg.includes("rate limit") || msg.includes("429") || msg.includes("fetch failed") || msg.includes("failed to fetch") || msg.includes("connection") || msg.includes("timeout");
+}
+async function send(sbn, params) {
+  let lastErr;
+  for (let attempt = 0; attempt < 4; attempt++) {
+    let hash;
+    let result;
+    try {
+      const sim = await sbn.publicClient.simulateContract({
+        account: sbn.account,
+        address: params.address,
+        abi: params.abi,
+        functionName: params.functionName,
+        args: params.args ?? [],
+        value: params.value
+      });
+      result = sim.result;
+      let gas;
+      try {
+        const est = await sbn.publicClient.estimateContractGas({
+          account: sbn.account,
+          address: params.address,
+          abi: params.abi,
+          functionName: params.functionName,
+          args: params.args ?? [],
+          value: params.value
+        });
+        gas = est * 160n / 100n;
+      } catch {
+        gas = void 0;
+      }
+      hash = await sbn.walletClient.writeContract(
+        gas ? { ...sim.request, gas } : sim.request
+      );
+    } catch (err) {
+      lastErr = err;
+      if (isTransientSendError(err) && attempt < 3) {
+        await sleep(2e3);
+        continue;
+      }
+      throw new Error(explainError(err));
+    }
+    const receipt = await sbn.publicClient.waitForTransactionReceipt({ hash });
+    if (receipt.status !== "success") {
+      throw new Error(
+        `Transaction reverted on-chain (${hash}). This can be an out-of-gas or a state change after simulation \u2014 re-read state with \`sbn status\` and retry.`
+      );
+    }
+    return { hash, result };
+  }
+  throw new Error(explainError(lastErr));
+}
+async function isRegistered(sbn, address) {
+  assertDeployed(sbn.deployment);
+  return sbn.publicClient.readContract({
+    address: sbn.deployment.contracts.WildcatArchController,
+    abi: archControllerAbi,
+    functionName: "isRegisteredBorrower",
+    args: [address ?? sbn.account.address]
+  });
+}
+async function registerSelf(sbn) {
+  assertDeployed(sbn.deployment);
+  if (await isRegistered(sbn)) return { already: true };
+  const { hash } = await send(sbn, {
+    address: sbn.deployment.contracts.WildcatArchController,
+    abi: archControllerAbi,
+    functionName: "registerSelf"
+  });
+  await waitForRegistration(sbn);
+  return { already: false, hash };
+}
+async function waitForRegistration(sbn, timeoutMs = 6e4) {
+  const start = Date.now();
+  let delay = 1e3;
+  while (Date.now() - start < timeoutMs) {
+    if (await isRegistered(sbn)) return;
+    await sleep(delay);
+    delay = Math.min(delay * 1.5, 5e3);
+  }
+  if (await isRegistered(sbn)) return;
+  throw new Error(
+    "Registration did not become visible on the RPC in time. Your wallet is registered on-chain \u2014 wait a few seconds and retry the deploy."
+  );
+}
+function ethBalance(sbn, address) {
+  return sbn.publicClient.getBalance({ address: address ?? sbn.account.address });
+}
+function usdcBalance(sbn, address) {
+  return sbn.publicClient.readContract({
+    address: sbn.deployment.contracts.TestUSDC,
+    abi: erc20Abi,
+    functionName: "balanceOf",
+    args: [address ?? sbn.account.address]
+  });
+}
+async function mintTestUsdc(sbn, amount) {
+  assertDeployed(sbn.deployment);
+  const { hash } = await send(sbn, {
+    address: sbn.deployment.contracts.TestUSDC,
+    abi: erc20Abi,
+    functionName: "mint",
+    args: [sbn.account.address, amount]
+  });
+  return hash;
+}
+async function waitForEth(sbn, target, timeoutMs = 9e4) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await ethBalance(sbn) >= target) return true;
+    await sleep(3e3);
+  }
+  return await ethBalance(sbn) >= target;
+}
+function usdcUnits(amount) {
+  const clean = String(amount).replace(/[_,\s]/g, "");
+  if (!/^\d+(\.\d+)?$/.test(clean)) {
+    throw new Error(`Invalid USDC amount "${amount}". Use a positive number like 10000 or 1.5.`);
+  }
+  const [whole, frac = ""] = clean.split(".");
+  const fracPadded = (frac + "0".repeat(USDC_DECIMALS)).slice(0, USDC_DECIMALS);
+  const value = BigInt(whole || "0") * 10n ** BigInt(USDC_DECIMALS) + BigInt(fracPadded || "0");
+  if (value <= 0n) throw new Error(`USDC amount must be greater than zero (got "${amount}").`);
+  return value;
+}
+function randomNonce() {
+  return BigInt("0x" + randomBytes(12).toString("hex"));
+}
+function resolveFixedTermEndTime(term) {
+  const now = Math.floor(Date.now() / 1e3);
+  let end;
+  if (typeof term === "number") {
+    end = term >= 1e9 ? term : now + term;
+  } else {
+    const s = term.trim();
+    if (/[smhdwy]$/i.test(s)) {
+      end = now + parseDuration(s);
+    } else if (/^\d+$/.test(s)) {
+      const n = Number(s);
+      end = n >= 1e9 ? n : now + n;
+    } else {
+      throw new Error(`Invalid term "${term}". Use a duration like "1y" / "90d", or a unix timestamp.`);
+    }
+  }
+  if (end <= now) throw new Error(`Fixed term must end in the future (resolved to ${end}, now ${now}).`);
+  if (end > 4294967295) {
+    throw new Error(`Fixed term end ${end} exceeds the uint32 limit (\u2248 year 2106). Choose a shorter term.`);
+  }
+  return end;
+}
+function computeSalt(borrower, nonce) {
+  const addr = BigInt(borrower);
+  const salt = addr << 96n | nonce & (1n << 96n) - 1n;
+  return `0x${salt.toString(16).padStart(64, "0")}`;
+}
+async function deployMarket(sbn, terms) {
+  assertDeployed(sbn.deployment);
+  const d = sbn.deployment;
+  const type = terms.type ?? "open";
+  const finitePct = (v, name2) => {
+    if (!Number.isFinite(v) || v < 0) throw new Error(`${name2} must be a non-negative number (got ${v}).`);
+    return v;
+  };
+  const aprPct = finitePct(terms.aprPct ?? 8, "aprPct");
+  if (aprPct > 100) {
+    throw new Error("aprPct must be \u2264 100. The protocol caps base APR at 100%; use penaltyAprPct for higher delinquency rates.");
+  }
+  const annualInterestBips = pctToBips(aprPct);
+  const delinquencyFeeBips = pctToBips(finitePct(terms.penaltyAprPct ?? 20, "penaltyAprPct"));
+  if (delinquencyFeeBips > 65535) throw new Error("penaltyAprPct too high (max ~655%).");
+  const reserveRatioBips = pctToBips(finitePct(terms.reservePct ?? 0, "reservePct"));
+  if (reserveRatioBips > 1e4) throw new Error("reservePct must be \u2264 100.");
+  const withdrawalBatchDuration = parseDuration(terms.withdrawalBatch ?? "1d");
+  const delinquencyGracePeriod = parseDuration(terms.gracePeriod ?? "3d");
+  const asset = terms.asset ?? d.contracts.TestUSDC;
+  const maxTotalSupply = usdcUnits(terms.capUsdc);
+  const minimumDeposit = terms.minDepositUsdc ? usdcUnits(terms.minDepositUsdc) : 0n;
+  const transfersDisabled = terms.transfersDisabled ?? false;
+  const namePrefix = terms.namePrefix ?? "SBN ";
+  const symbolPrefix = terms.symbolPrefix ?? "sbn";
+  let template;
+  let hooksData;
+  if (type === "fixed") {
+    if (terms.term === void 0) throw new Error('Fixed-term bonds require `term` (e.g. "1y" or a unix timestamp).');
+    const fixedTermEndTime = resolveFixedTermEndTime(terms.term);
+    template = d.contracts.FixedTermHooksTemplate;
+    hooksData = encodeAbiParameters(parseAbiParameters("uint32, uint128, bool, bool, bool"), [
+      fixedTermEndTime,
+      minimumDeposit,
+      transfersDisabled,
+      terms.allowClosureBeforeTerm ?? true,
+      terms.allowTermReduction ?? true
+    ]);
+  } else {
+    template = d.contracts.OpenTermHooksTemplate;
+    hooksData = encodeAbiParameters(parseAbiParameters("uint128, bool"), [minimumDeposit, transfersDisabled]);
+  }
+  const params = {
+    asset,
+    namePrefix,
+    symbolPrefix,
+    maxTotalSupply,
+    annualInterestBips,
+    delinquencyFeeBips,
+    withdrawalBatchDuration,
+    reserveRatioBips,
+    delinquencyGracePeriod,
+    hooks: 0n
+    // factory injects the hooks instance address; template sets flags
+  };
+  const salt = computeSalt(sbn.account.address, randomNonce());
+  const deployArgs = [template, "0x", params, hooksData, salt, zeroAddress, 0n];
+  let sent;
+  let lastErr;
+  for (let attempt = 0; attempt < 5; attempt++) {
+    try {
+      sent = await send(sbn, {
+        address: d.contracts.HooksFactory,
+        abi: hooksFactoryAbi,
+        functionName: "deployMarketAndHooks",
+        args: deployArgs
+      });
+      break;
+    } catch (err) {
+      lastErr = err;
+      if (!await isRegistered(sbn)) throw err;
+      await sleep(2500);
+    }
+  }
+  if (!sent) throw new Error(explainError(lastErr));
+  const { hash, result } = sent;
+  const [market, hooksInstance] = result;
+  const readWithRetry = async (fn) => {
+    let lastErr2;
+    for (let i = 0; i < 6; i++) {
+      try {
+        return await sbn.publicClient.readContract({ address: market, abi: marketAbi, functionName: fn });
+      } catch (err) {
+        lastErr2 = err;
+        await sleep(1500);
+      }
+    }
+    throw lastErr2;
+  };
+  const [name, symbol] = await Promise.all([readWithRetry("name"), readWithRetry("symbol")]);
+  const record = {
+    market,
+    hooksInstance,
+    type,
+    asset,
+    name,
+    symbol,
+    network: d.chain,
+    txHash: hash,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  recordMarket(record);
+  return {
+    market,
+    hooksInstance,
+    hash,
+    name,
+    symbol,
+    type,
+    explorerUrl: addressUrl(d, market),
+    txUrl: txUrl(d, hash)
+  };
+}
+async function approveIfNeeded(sbn, token, spender, amount) {
+  const readAllowance = () => sbn.publicClient.readContract({
+    address: token,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [sbn.account.address, spender]
+  });
+  if (await readAllowance() >= amount) return;
+  await send(sbn, {
+    address: token,
+    abi: erc20Abi,
+    functionName: "approve",
+    args: [spender, 2n ** 256n - 1n]
+  });
+  const start = Date.now();
+  let delay = 1500;
+  while (Date.now() - start < 3e4) {
+    if (await readAllowance() >= amount) return;
+    await sleep(delay);
+    delay = Math.min(delay * 1.5, 5e3);
+  }
+}
+async function marketAsset(sbn, market) {
+  return sbn.publicClient.readContract({ address: market, abi: marketAbi, functionName: "asset" });
+}
+async function deposit(sbn, market, amountUsdc) {
+  const amount = usdcUnits(amountUsdc);
+  const asset = await marketAsset(sbn, market);
+  await approveIfNeeded(sbn, asset, market, amount);
+  const { hash } = await send(sbn, { address: market, abi: marketAbi, functionName: "deposit", args: [amount] });
+  return hash;
+}
+async function borrow(sbn, market, amountUsdc) {
+  const { hash } = await send(sbn, { address: market, abi: marketAbi, functionName: "borrow", args: [usdcUnits(amountUsdc)] });
+  return hash;
+}
+async function repay(sbn, market, amountUsdc) {
+  const amount = usdcUnits(amountUsdc);
+  const asset = await marketAsset(sbn, market);
+  await approveIfNeeded(sbn, asset, market, amount);
+  const { hash } = await send(sbn, { address: market, abi: marketAbi, functionName: "repay", args: [amount] });
+  return hash;
+}
+async function queueWithdrawal(sbn, market, amountUsdc) {
+  if (amountUsdc === void 0) {
+    const { hash: hash2, result: result2 } = await send(sbn, { address: market, abi: marketAbi, functionName: "queueFullWithdrawal" });
+    return { hash: hash2, expiry: Number(result2) };
+  }
+  const { hash, result } = await send(sbn, {
+    address: market,
+    abi: marketAbi,
+    functionName: "queueWithdrawal",
+    args: [usdcUnits(amountUsdc)]
+  });
+  return { hash, expiry: Number(result) };
+}
+async function executeWithdrawal(sbn, market, account2, expiry) {
+  const { hash } = await send(sbn, {
+    address: market,
+    abi: marketAbi,
+    functionName: "executeWithdrawal",
+    args: [account2, expiry]
+  });
+  return hash;
+}
+async function closeMarket(sbn, market) {
+  const { hash } = await send(sbn, { address: market, abi: marketAbi, functionName: "closeMarket" });
+  return hash;
+}
+async function describeBond(sbn, market, name, description) {
+  const registry = sbn.deployment.contracts.BondNotes;
+  if (!registry) {
+    throw new Error(
+      `Descriptions aren't available on ${sbn.deployment.label} yet (no BondNotes registry).`
+    );
+  }
+  const { hash } = await send(sbn, {
+    address: registry,
+    abi: bondNotesAbi,
+    functionName: "describe",
+    args: [market, name ?? "", description ?? ""]
+  });
+  return hash;
+}
+async function marketStatus(sbn, market) {
+  const read = (functionName, args = []) => sbn.publicClient.readContract({ address: market, abi: marketAbi, functionName, args });
+  const [
+    name,
+    symbol,
+    asset,
+    borrower,
+    isClosed,
+    apr,
+    reserve,
+    totalSupply,
+    totalAssets,
+    borrowableAssets,
+    maximumDeposit,
+    expiries
+  ] = await Promise.all([
+    read("name"),
+    read("symbol"),
+    read("asset"),
+    read("borrower"),
+    read("isClosed"),
+    read("annualInterestBips"),
+    read("reserveRatioBips"),
+    read("totalSupply"),
+    read("totalAssets"),
+    read("borrowableAssets"),
+    read("maximumDeposit"),
+    read("getUnpaidBatchExpiries")
+  ]);
+  return {
+    market,
+    name,
+    symbol,
+    asset,
+    borrower,
+    isClosed,
+    annualInterestBips: Number(apr),
+    reserveRatioBips: Number(reserve),
+    maxTotalSupply: totalSupply + maximumDeposit,
+    totalSupply,
+    totalAssets,
+    borrowableAssets,
+    maximumDeposit,
+    unpaidBatchExpiries: expiries.map(Number)
+  };
+}
+var noop = () => {
+};
+var DEFAULT_MIN_ETH = parseEther("0.001");
+var DEFAULT_MINT_USDC = 1000000n * 10n ** 6n;
+async function ensureFunded(sbn, opts = {}) {
+  assertDeployed(sbn.deployment);
+  const log = opts.log ?? noop;
+  const minEth = opts.minEthWei ?? DEFAULT_MIN_ETH;
+  const mintTarget = opts.mintUsdc ?? DEFAULT_MINT_USDC;
+  const ethBefore = await ethBalance(sbn);
+  if (!sbn.deployment.testnet) {
+    if (ethBefore < minEth) {
+      throw new Error(
+        `Wallet ${sbn.account.address} has too little ETH for gas on ${sbn.deployment.label}. There is no dispenser on mainnet \u2014 send Base ETH to this address and retry. Issuing a bond needs only gas; lending also needs real USDC.`
+      );
+    }
+    return {
+      ethBefore,
+      ethAfter: ethBefore,
+      usdcAfter: await usdcBalance(sbn),
+      faucetUsed: false
+    };
+  }
+  let faucetUsed = false;
+  let faucetMessage;
+  if (ethBefore < minEth) {
+    log(`Requesting gas from the sellbonds.now dispenser (${sbn.deployment.faucetUrl})\u2026`);
+    const res = await requestEthFromFaucet(sbn.deployment.faucetUrl, sbn.account.address);
+    faucetUsed = true;
+    faucetMessage = res.message;
+    if (!res.ok) {
+      throw new Error(
+        `Dispenser could not fund ${sbn.account.address}: ${res.message ?? "unknown error"}. Fund it manually with Base Sepolia ETH (https://portal.cdp.coinbase.com/products/faucet) and retry.`
+      );
+    }
+    log("Waiting for gas to arrive\u2026");
+    const arrived = await waitForEth(sbn, minEth);
+    if (!arrived) {
+      throw new Error(
+        `Gas did not arrive in time. Check ${sbn.account.address} on the explorer and retry once it has ETH.`
+      );
+    }
+  }
+  const usdcNow = await usdcBalance(sbn);
+  if (usdcNow < mintTarget) {
+    log("Minting test USDC\u2026");
+    await mintTestUsdc(sbn, mintTarget - usdcNow);
+  }
+  return {
+    ethBefore,
+    ethAfter: await ethBalance(sbn),
+    usdcAfter: await usdcBalance(sbn),
+    faucetUsed,
+    faucetMessage
+  };
+}
+
+// src/index.ts
+var SITE = "https://sellbonds.now";
+var server = new McpServer({ name: "sellbonds", version: "0.1.0" });
+var toJson = (v) => JSON.stringify(v, (_k, val) => typeof val === "bigint" ? val.toString() : val, 2);
+var ok = (v) => ({ content: [{ type: "text", text: typeof v === "string" ? v : toJson(v) }] });
+var fail = (msg) => ({ isError: true, content: [{ type: "text", text: msg }] });
+var wrap = (fn) => async (args) => {
+  try {
+    return ok(await fn(args));
+  } catch (e) {
+    return fail(e instanceof Error ? e.message : String(e));
+  }
+};
+var networkParam = z.enum(["base", "base-sepolia"]).optional().describe("Network. Defaults to SBN_NETWORK or base (mainnet, real USDC). base-sepolia is the free testnet.");
+var marketParam = z.string().regex(/^0x[0-9a-fA-F]{40}$/).describe("Bond market contract address (0x\u2026)");
+function isMainnet(network) {
+  return (network ?? networkName()) !== "base-sepolia";
+}
+var RISK_GATE = `This would create a new financial commitment with real USDC on Base mainnet. Before retrying with acknowledge_risks=true, confirm with your human that they understand and accept: (1) bonds are uncollateralized \u2014 a lender can lose 100%; (2) the contracts are an unaudited fork of Wildcat V2; (3) transactions are irreversible; (4) there is no KYC/sanctions layer \u2014 legal/tax/regulatory compliance is their responsibility. Full text: ${SITE}/risk.md`;
+server.registerTool(
+  "list_bonds",
+  {
+    title: "List all bonds",
+    description: "Every bond issued on sellbonds.now (Base mainnet), read live from the on-chain registry: terms, APR, raised/cap, status, issuer, plus network aggregates.",
+    inputSchema: {}
+  },
+  wrap(async () => {
+    const res = await fetch(`${SITE}/api/markets`);
+    if (!res.ok) throw new Error(`markets API ${res.status}`);
+    return res.json();
+  })
+);
+server.registerTool(
+  "get_bond",
+  {
+    title: "Get one bond",
+    description: "Full detail for one bond on Base mainnet: live state, terms, issuer, and its on-chain event history (investments, draws, repayments).",
+    inputSchema: { market: marketParam }
+  },
+  wrap(async ({ market }) => {
+    const res = await fetch(`${SITE}/api/bond?market=${market}`);
+    if (res.status === 404) throw new Error("No sellbonds bond at that address.");
+    if (!res.ok) throw new Error(`bond API ${res.status}`);
+    return res.json();
+  })
+);
+server.registerTool(
+  "bond_status",
+  {
+    title: "Read bond state from chain",
+    description: "Read a bond market directly from the chain via RPC (works on testnet too, unlike get_bond). Returns raw contract state.",
+    inputSchema: { market: marketParam, network: networkParam }
+  },
+  wrap(async ({ market, network }) => {
+    const sbn = connectReadonly(network);
+    const status = await marketStatus(sbn, market);
+    return { network: network ?? networkName(), ...status, explorerUrl: addressUrl(sbn.deployment, market) };
+  })
+);
+server.registerTool(
+  "wallet_status",
+  {
+    title: "Wallet status",
+    description: "The local sellbonds wallet (shared with the sbn CLI at ~/.sellbondsnow/wallet.json): address, balances, issuer registration. Set create=true to create one if it doesn't exist.",
+    inputSchema: {
+      network: networkParam,
+      create: z.boolean().optional().describe("Create the wallet if none exists (default false)")
+    }
+  },
+  wrap(async ({ network, create }) => {
+    if (!walletExists() && !create) {
+      return { exists: false, hint: "No wallet yet. Call wallet_status with create=true to create one (key stays local)." };
+    }
+    const { wallet, created } = create ? loadOrCreateWallet() : { wallet: loadWallet(), created: false };
+    const sbn = connect(network);
+    const [eth, usdc, registered] = await Promise.all([
+      ethBalance(sbn),
+      usdcBalance(sbn),
+      isRegistered(sbn)
+    ]);
+    return {
+      exists: true,
+      created,
+      address: wallet.address,
+      network: network ?? networkName(),
+      ethWei: eth,
+      usdc: Number(usdc) / 1e6,
+      registeredAsIssuer: registered,
+      explorerUrl: addressUrl(sbn.deployment, wallet.address),
+      myBonds: listMarkets()
+    };
+  })
+);
+server.registerTool(
+  "fund_wallet_testnet",
+  {
+    title: "Fund wallet (testnet only)",
+    description: "Top up the local wallet with free Base Sepolia gas (via the sellbonds.now dispenser) and test USDC. Testnet only \u2014 on mainnet the wallet must be funded externally.",
+    inputSchema: {}
+  },
+  wrap(async () => {
+    loadOrCreateWallet();
+    const sbn = connect("base-sepolia");
+    const result = await ensureFunded(sbn);
+    return { address: sbn.account.address, ...result };
+  })
+);
+server.registerTool(
+  "issue_bond",
+  {
+    title: "Issue a bond (raise)",
+    description: "One-shot raise: ensures the wallet is funded (testnet) and registered as an issuer, deploys a bond market with your terms, and sets its on-chain name/description. ALWAYS set an honest name + description \u2014 unnamed bonds get skipped by lenders. On mainnet requires acknowledge_risks=true after the human has confirmed the risks.",
+    inputSchema: {
+      capUsdc: z.number().positive().describe("Max capital to raise, in USDC (e.g. 10000)"),
+      aprPct: z.number().min(0).max(100).optional().describe("Annual coupon for lenders, percent (e.g. 8.5)"),
+      type: z.enum(["open", "fixed"]).optional().describe("'open' (revolving, default) or 'fixed' (matures)"),
+      term: z.string().optional().describe("Fixed-term duration, e.g. '90d' or '1y' (fixed type only)"),
+      name: z.string().max(80).optional().describe('Short honest label, e.g. "GPU cluster Q3"'),
+      description: z.string().max(500).optional().describe("What the money funds \u2014 honest, no invented returns"),
+      network: networkParam,
+      acknowledge_risks: z.boolean().optional().describe("Required true on mainnet, only after human confirmation")
+    }
+  },
+  wrap(
+    async (a) => {
+      if (isMainnet(a.network) && !a.acknowledge_risks) throw new Error(RISK_GATE);
+      loadOrCreateWallet();
+      const sbn = connect(a.network);
+      await ensureFunded(sbn);
+      await registerSelf(sbn);
+      const market = await deployMarket(sbn, {
+        type: a.type ?? "open",
+        capUsdc: a.capUsdc,
+        aprPct: a.aprPct,
+        namePrefix: a.name,
+        term: a.term
+      });
+      let noteSet = false;
+      if (a.name || a.description) {
+        try {
+          await describeBond(sbn, market.market, a.name ?? "", a.description ?? "");
+          noteSet = true;
+        } catch {
+        }
+      }
+      return {
+        market: market.market,
+        name: market.name,
+        symbol: market.symbol,
+        type: market.type,
+        issuer: sbn.account.address,
+        explorerUrl: market.explorerUrl,
+        deployTxUrl: market.txUrl,
+        bondPage: `${SITE}/bond/${String(market.market).toLowerCase()}`,
+        noteSet,
+        next: "Lenders fund it with the deposit tool (or: sbn deposit <market> <usdc>). Draw capital with borrow; repay with repay."
+      };
+    }
+  )
+);
+server.registerTool(
+  "deposit",
+  {
+    title: "Fund a bond (lend)",
+    description: "Lend USDC into a bond and receive its interest-accruing bond token. Uncollateralized \u2014 you can lose everything if the issuer defaults. On mainnet requires acknowledge_risks=true after the human has confirmed the risks.",
+    inputSchema: {
+      market: marketParam,
+      amountUsdc: z.number().positive().describe("USDC to lend (human units)"),
+      network: networkParam,
+      acknowledge_risks: z.boolean().optional().describe("Required true on mainnet, only after human confirmation")
+    }
+  },
+  wrap(async (a) => {
+    if (isMainnet(a.network) && !a.acknowledge_risks) throw new Error(RISK_GATE);
+    const sbn = connect(a.network);
+    const hash = await deposit(sbn, a.market, a.amountUsdc);
+    return { txHash: hash, txUrl: txUrl(sbn.deployment, hash), deposited: a.amountUsdc, market: a.market };
+  })
+);
+server.registerTool(
+  "borrow",
+  {
+    title: "Draw down raised capital (issuer)",
+    description: "Move raised USDC from your bond market to your wallet, leaving the reserve ratio behind.",
+    inputSchema: { market: marketParam, amountUsdc: z.number().positive(), network: networkParam }
+  },
+  wrap(async (a) => {
+    const sbn = connect(a.network);
+    const hash = await borrow(sbn, a.market, a.amountUsdc);
+    return { txHash: hash, txUrl: txUrl(sbn.deployment, hash), borrowed: a.amountUsdc, market: a.market };
+  })
+);
+server.registerTool(
+  "repay",
+  {
+    title: "Repay a bond (issuer)",
+    description: "Return principal + interest to the bond market. On-time repayment builds your on-chain credit record.",
+    inputSchema: { market: marketParam, amountUsdc: z.number().positive(), network: networkParam }
+  },
+  wrap(async (a) => {
+    const sbn = connect(a.network);
+    const hash = await repay(sbn, a.market, a.amountUsdc);
+    return { txHash: hash, txUrl: txUrl(sbn.deployment, hash), repaid: a.amountUsdc, market: a.market };
+  })
+);
+server.registerTool(
+  "withdraw",
+  {
+    title: "Queue a withdrawal (lender)",
+    description: "Queue redemption of your bond tokens (all of them if amountUsdc is omitted). Returns the batch expiry \u2014 claim after it passes with the claim tool.",
+    inputSchema: { market: marketParam, amountUsdc: z.number().positive().optional(), network: networkParam }
+  },
+  wrap(async (a) => {
+    const sbn = connect(a.network);
+    const { hash, expiry } = await queueWithdrawal(sbn, a.market, a.amountUsdc);
+    return { txHash: hash, txUrl: txUrl(sbn.deployment, hash), expiry, next: `After expiry ${expiry}, call claim with this market + expiry.` };
+  })
+);
+server.registerTool(
+  "claim",
+  {
+    title: "Claim a matured withdrawal (lender)",
+    description: "Execute a withdrawal batch after its expiry to receive USDC.",
+    inputSchema: { market: marketParam, expiry: z.number().int().describe("Batch expiry from the withdraw tool"), network: networkParam }
+  },
+  wrap(async (a) => {
+    const sbn = connect(a.network);
+    const hash = await executeWithdrawal(sbn, a.market, sbn.account.address, a.expiry);
+    return { txHash: hash, txUrl: txUrl(sbn.deployment, hash) };
+  })
+);
+server.registerTool(
+  "close_bond",
+  {
+    title: "Close a bond (issuer)",
+    description: "Settle and close a bond market: repays outstanding debt from your wallet and ends the bond.",
+    inputSchema: { market: marketParam, network: networkParam }
+  },
+  wrap(async (a) => {
+    const sbn = connect(a.network);
+    const hash = await closeMarket(sbn, a.market);
+    return { txHash: hash, txUrl: txUrl(sbn.deployment, hash), closed: a.market };
+  })
+);
+server.registerTool(
+  "describe_bond",
+  {
+    title: "Name/describe a bond (issuer)",
+    description: "Set or update the on-chain name + description of a bond you issued. Honest labels matter \u2014 unnamed bonds get skipped by lenders.",
+    inputSchema: {
+      market: marketParam,
+      name: z.string().max(80).describe('Short label, e.g. "GPU cluster Q3"'),
+      description: z.string().max(500).describe("What the money funds"),
+      network: networkParam
+    }
+  },
+  wrap(async (a) => {
+    const sbn = connect(a.network);
+    await describeBond(sbn, a.market, a.name, a.description);
+    return { market: a.market, name: a.name, description: a.description, bondPage: `${SITE}/bond/${a.market.toLowerCase()}` };
+  })
+);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+console.error(`sellbonds-mcp ready (network default: ${networkName()}) \u2014 docs: ${SITE}/llms.txt`);