@peridot-agent/agent-kit 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1806 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/shared/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  ARBITRUM_CHAIN_ID: () => ARBITRUM_CHAIN_ID,
+  ASSET_DECIMALS: () => ASSET_DECIMALS,
+  AVALANCHE_CHAIN_ID: () => AVALANCHE_CHAIN_ID,
+  BASE_CHAIN_ID: () => BASE_CHAIN_ID,
+  BICONOMY_API_URL: () => BICONOMY_API_URL,
+  BSC_MAINNET_CHAIN_ID: () => BSC_MAINNET_CHAIN_ID,
+  BSC_TESTNET_CHAIN_ID: () => BSC_TESTNET_CHAIN_ID,
+  BSC_UNDERLYING_TOKENS: () => BSC_UNDERLYING_TOKENS,
+  CHAIN_NAMES: () => CHAIN_NAMES,
+  DEFAULT_API_BASE_URL: () => DEFAULT_API_BASE_URL,
+  DEFAULT_RPC_URLS: () => DEFAULT_RPC_URLS,
+  ETHEREUM_CHAIN_ID: () => ETHEREUM_CHAIN_ID,
+  HUB_CHAIN_IDS: () => HUB_CHAIN_IDS,
+  HUB_UNDERLYING_TOKENS: () => HUB_UNDERLYING_TOKENS,
+  MONAD_MAINNET_CHAIN_ID: () => MONAD_MAINNET_CHAIN_ID,
+  MONAD_TESTNET_CHAIN_ID: () => MONAD_TESTNET_CHAIN_ID,
+  OPTIMISM_CHAIN_ID: () => OPTIMISM_CHAIN_ID,
+  PERIDOT_CONTROLLER: () => PERIDOT_CONTROLLER,
+  PERIDOT_MARKETS: () => PERIDOT_MARKETS,
+  POLYGON_CHAIN_ID: () => POLYGON_CHAIN_ID,
+  SOMNIA_MAINNET_CHAIN_ID: () => SOMNIA_MAINNET_CHAIN_ID,
+  SOMNIA_TESTNET_CHAIN_ID: () => SOMNIA_TESTNET_CHAIN_ID,
+  SPOKE_TOKENS: () => SPOKE_TOKENS,
+  getAssetDecimals: () => getAssetDecimals,
+  getControllerAddress: () => getControllerAddress,
+  getPTokenAddress: () => getPTokenAddress,
+  getUnderlyingTokenAddress: () => getUnderlyingTokenAddress,
+  isHubChain: () => isHubChain,
+  resolveHubChainId: () => resolveHubChainId
+});
+function isHubChain(chainId) {
+  return HUB_CHAIN_IDS.includes(chainId);
+}
+function resolveHubChainId(chainId, network = "mainnet") {
+  if (isHubChain(chainId)) return chainId;
+  return network === "testnet" ? BSC_TESTNET_CHAIN_ID : BSC_MAINNET_CHAIN_ID;
+}
+function getPTokenAddress(chainId, asset) {
+  const markets = PERIDOT_MARKETS[chainId];
+  if (!markets) {
+    throw new Error(`No pToken markets configured for chain ${chainId} (${CHAIN_NAMES[chainId] ?? "unknown"})`);
+  }
+  const address = markets[asset.toUpperCase()];
+  if (!address) {
+    const available = Object.keys(markets).join(", ");
+    throw new Error(`No pToken market for ${asset.toUpperCase()} on chain ${chainId}. Available: ${available}`);
+  }
+  return address;
+}
+function getUnderlyingTokenAddress(chainId, asset) {
+  const symbol = asset.toUpperCase();
+  const chainName = CHAIN_NAMES[chainId] ?? `chain ${chainId}`;
+  if (isHubChain(chainId)) {
+    const hubTokens = HUB_UNDERLYING_TOKENS[chainId];
+    if (!hubTokens) throw new Error(`No underlying token config for hub chain ${chainName} \u2014 contracts may not be deployed yet`);
+    const address2 = hubTokens[symbol];
+    if (!address2) throw new Error(`No underlying token for ${symbol} on ${chainName}`);
+    return address2;
+  }
+  const spokeTokens = SPOKE_TOKENS[chainId];
+  if (!spokeTokens) throw new Error(`No token config for chain ${chainName}`);
+  const address = spokeTokens[symbol];
+  if (!address) throw new Error(`No token address for ${symbol} on ${chainName}`);
+  return address;
+}
+function getControllerAddress(chainId) {
+  const address = PERIDOT_CONTROLLER[chainId];
+  if (!address) throw new Error(`No Peridot controller for chain ${chainId}`);
+  return address;
+}
+function getAssetDecimals(asset) {
+  const symbol = asset.toUpperCase();
+  const decimals = ASSET_DECIMALS[symbol];
+  if (decimals === void 0) {
+    throw new Error(
+      `Unknown asset "${symbol}": decimal precision not configured. Add it to ASSET_DECIMALS in constants.ts before use.`
+    );
+  }
+  return decimals;
+}
+var DEFAULT_API_BASE_URL, BICONOMY_API_URL, HUB_CHAIN_IDS, BSC_MAINNET_CHAIN_ID, BSC_TESTNET_CHAIN_ID, MONAD_MAINNET_CHAIN_ID, MONAD_TESTNET_CHAIN_ID, SOMNIA_MAINNET_CHAIN_ID, SOMNIA_TESTNET_CHAIN_ID, ARBITRUM_CHAIN_ID, BASE_CHAIN_ID, ETHEREUM_CHAIN_ID, POLYGON_CHAIN_ID, OPTIMISM_CHAIN_ID, AVALANCHE_CHAIN_ID, CHAIN_NAMES, PERIDOT_CONTROLLER, PERIDOT_MARKETS, BSC_UNDERLYING_TOKENS, HUB_UNDERLYING_TOKENS, SPOKE_TOKENS, ASSET_DECIMALS, DEFAULT_RPC_URLS;
+var init_constants = __esm({
+  "src/shared/constants.ts"() {
+    "use strict";
+    DEFAULT_API_BASE_URL = "https://app.peridot.finance";
+    BICONOMY_API_URL = "https://api.biconomy.io";
+    HUB_CHAIN_IDS = [56, 97, 143, 10143, 1868, 50312];
+    BSC_MAINNET_CHAIN_ID = 56;
+    BSC_TESTNET_CHAIN_ID = 97;
+    MONAD_MAINNET_CHAIN_ID = 143;
+    MONAD_TESTNET_CHAIN_ID = 10143;
+    SOMNIA_MAINNET_CHAIN_ID = 1868;
+    SOMNIA_TESTNET_CHAIN_ID = 50312;
+    ARBITRUM_CHAIN_ID = 42161;
+    BASE_CHAIN_ID = 8453;
+    ETHEREUM_CHAIN_ID = 1;
+    POLYGON_CHAIN_ID = 137;
+    OPTIMISM_CHAIN_ID = 10;
+    AVALANCHE_CHAIN_ID = 43114;
+    CHAIN_NAMES = {
+      [BSC_MAINNET_CHAIN_ID]: "BSC Mainnet",
+      [BSC_TESTNET_CHAIN_ID]: "BSC Testnet",
+      [MONAD_MAINNET_CHAIN_ID]: "Monad Mainnet",
+      [MONAD_TESTNET_CHAIN_ID]: "Monad Testnet",
+      [SOMNIA_MAINNET_CHAIN_ID]: "Somnia Mainnet",
+      [SOMNIA_TESTNET_CHAIN_ID]: "Somnia Testnet",
+      [ARBITRUM_CHAIN_ID]: "Arbitrum",
+      [BASE_CHAIN_ID]: "Base",
+      [ETHEREUM_CHAIN_ID]: "Ethereum",
+      [POLYGON_CHAIN_ID]: "Polygon",
+      [OPTIMISM_CHAIN_ID]: "Optimism",
+      [AVALANCHE_CHAIN_ID]: "Avalanche"
+    };
+    PERIDOT_CONTROLLER = {
+      [BSC_MAINNET_CHAIN_ID]: "0x6fC0c15531CB5901ac72aB3CFCd9dF6E99552e14"
+      // [MONAD_MAINNET_CHAIN_ID]: '0x...',  // TODO: add when deployed
+      // [SOMNIA_MAINNET_CHAIN_ID]: '0x...',  // TODO: add when deployed
+    };
+    PERIDOT_MARKETS = {
+      [BSC_MAINNET_CHAIN_ID]: {
+        WETH: "0x28E4F2Bb64ac79500ec3CAa074A3C30721B6bC84",
+        USDC: "0x1A726369Bfc60198A0ce19C66726C8046c0eC17e",
+        WBNB: "0xD9fDF5E2c7a2e7916E7f10Da276D95d4daC5a3c3",
+        USDT: "0xc37f3869720B672addFE5F9E22a9459e0E851372",
+        WBTC: "0xdCAbDc1F0B5e603b9191be044a912A8A2949e212",
+        AUSD: "0x7A9940B77c0B6DFCcA2028b9F3CCa88E5DC36ebb"
+      }
+      // [MONAD_MAINNET_CHAIN_ID]: { ... },  // TODO: add when deployed
+      // [SOMNIA_MAINNET_CHAIN_ID]: { ... },  // TODO: add when deployed
+    };
+    BSC_UNDERLYING_TOKENS = {
+      WETH: "0x2170Ed0880ac9A755fd29B2688956BD959F933F8",
+      WBTC: "0x0555E30da8f98308EdB960aa94C0Db47230d2B9c",
+      USDC: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+      AUSD: "0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a",
+      WBNB: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+      USDT: "0x55d398326f99059fF775485246999027B3197955"
+    };
+    HUB_UNDERLYING_TOKENS = {
+      [BSC_MAINNET_CHAIN_ID]: BSC_UNDERLYING_TOKENS
+      // [MONAD_MAINNET_CHAIN_ID]: { USDC: '0x...', WETH: '0x...', ... },  // TODO
+      // [SOMNIA_MAINNET_CHAIN_ID]: { USDC: '0x...', WETH: '0x...', ... },  // TODO
+    };
+    SPOKE_TOKENS = {
+      [ARBITRUM_CHAIN_ID]: {
+        USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+        USDT: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+        WETH: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+        AUSD: "0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a",
+        WBTC: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f"
+      },
+      [BASE_CHAIN_ID]: {
+        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        WETH: "0x4200000000000000000000000000000000000006",
+        USDT: "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2",
+        WBTC: "0x0555E30da8f98308EdB960aa94C0Db47230d2B9c"
+      },
+      [ETHEREUM_CHAIN_ID]: {
+        USDC: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        USDT: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        WBTC: "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599"
+      },
+      [POLYGON_CHAIN_ID]: {
+        USDC: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+        USDT: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+        WETH: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
+        WBTC: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6"
+      },
+      [OPTIMISM_CHAIN_ID]: {
+        USDC: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
+        USDT: "0x94b008aA00579c1307B0eF2c499aD98a8ce58e58",
+        WETH: "0x4200000000000000000000000000000000000006"
+      },
+      [AVALANCHE_CHAIN_ID]: {
+        USDC: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+        USDT: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+        WETH: "0x49D5c2BdFfac6CE2BFdB6640F4F80f226bc10bAB",
+        WBTC: "0x0555E30da8f98308EdB960aa94C0Db47230d2B9c"
+      }
+    };
+    ASSET_DECIMALS = {
+      USDC: 6,
+      USDT: 6,
+      WBTC: 8,
+      WETH: 18,
+      WBNB: 18,
+      AUSD: 18
+    };
+    DEFAULT_RPC_URLS = {
+      [BSC_MAINNET_CHAIN_ID]: "https://bsc-dataseed.binance.org",
+      [BSC_TESTNET_CHAIN_ID]: "https://data-seed-prebsc-1-s1.binance.org:8545",
+      [MONAD_MAINNET_CHAIN_ID]: "https://rpc.monad.xyz",
+      [MONAD_TESTNET_CHAIN_ID]: "https://testnet-rpc.monad.xyz",
+      [SOMNIA_MAINNET_CHAIN_ID]: "https://dream-rpc.somnia.network",
+      [SOMNIA_TESTNET_CHAIN_ID]: "https://testnet.rpc.somnia.network",
+      [ARBITRUM_CHAIN_ID]: "https://arb1.arbitrum.io/rpc",
+      [BASE_CHAIN_ID]: "https://mainnet.base.org",
+      [ETHEREUM_CHAIN_ID]: "https://eth.llamarpc.com"
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ARBITRUM_CHAIN_ID: () => ARBITRUM_CHAIN_ID,
+  ASSET_DECIMALS: () => ASSET_DECIMALS,
+  BASE_CHAIN_ID: () => BASE_CHAIN_ID,
+  BSC_MAINNET_CHAIN_ID: () => BSC_MAINNET_CHAIN_ID,
+  BSC_TESTNET_CHAIN_ID: () => BSC_TESTNET_CHAIN_ID,
+  BSC_UNDERLYING_TOKENS: () => BSC_UNDERLYING_TOKENS,
+  COMPTROLLER_ABI: () => COMPTROLLER_ABI,
+  ERC20_ABI: () => ERC20_ABI,
+  ETHEREUM_CHAIN_ID: () => ETHEREUM_CHAIN_ID,
+  MONAD_MAINNET_CHAIN_ID: () => MONAD_MAINNET_CHAIN_ID,
+  PERIDOT_CONTROLLER: () => PERIDOT_CONTROLLER,
+  PERIDOT_MARKETS: () => PERIDOT_MARKETS,
+  PTOKEN_ABI: () => PTOKEN_ABI,
+  PeridotApiClient: () => PeridotApiClient,
+  SOMNIA_MAINNET_CHAIN_ID: () => SOMNIA_MAINNET_CHAIN_ID,
+  SPOKE_TOKENS: () => SPOKE_TOKENS,
+  buildCrossChainBorrowIntent: () => buildCrossChainBorrowIntent,
+  buildCrossChainRepayIntent: () => buildCrossChainRepayIntent,
+  buildCrossChainSupplyIntent: () => buildCrossChainSupplyIntent,
+  buildCrossChainWithdrawIntent: () => buildCrossChainWithdrawIntent,
+  buildHubBorrowIntent: () => buildHubBorrowIntent,
+  buildHubDisableCollateralIntent: () => buildHubDisableCollateralIntent,
+  buildHubEnableCollateralIntent: () => buildHubEnableCollateralIntent,
+  buildHubRepayIntent: () => buildHubRepayIntent,
+  buildHubSupplyIntent: () => buildHubSupplyIntent,
+  buildHubWithdrawIntent: () => buildHubWithdrawIntent,
+  checkTransactionStatus: () => checkTransactionStatus,
+  getAccountLiquidity: () => getAccountLiquidity,
+  getAssetDecimals: () => getAssetDecimals,
+  getControllerAddress: () => getControllerAddress,
+  getLeaderboard: () => getLeaderboard,
+  getMarketRates: () => getMarketRates,
+  getPTokenAddress: () => getPTokenAddress,
+  getUnderlyingTokenAddress: () => getUnderlyingTokenAddress,
+  getUserPosition: () => getUserPosition,
+  isHubChain: () => isHubChain,
+  lendingTools: () => lendingTools,
+  listMarkets: () => listMarkets,
+  resolveHubChainId: () => resolveHubChainId,
+  simulateBorrow: () => simulateBorrow
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/features/lending/read/list-markets.ts
+var import_zod = require("zod");
+
+// src/shared/api-client.ts
+init_constants();
+var PLATFORM_TIMEOUT_MS = 1e4;
+var BICONOMY_COMPOSE_TIMEOUT_MS = 3e4;
+var RETRY_DELAY_MS = 200;
+async function fetchWithRetry(url, init) {
+  const attempt = () => fetch(url, init);
+  let res;
+  try {
+    res = await attempt();
+  } catch (err) {
+    await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+    return attempt();
+  }
+  if (res.status >= 500) {
+    await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+    return attempt();
+  }
+  return res;
+}
+var PeridotApiClient = class {
+  baseUrl;
+  biconomyApiKey;
+  constructor(config) {
+    this.baseUrl = config.apiBaseUrl ?? DEFAULT_API_BASE_URL;
+    this.biconomyApiKey = config.biconomyApiKey;
+  }
+  /**
+   * Fetches all market metrics. Returns a record keyed by `${ASSET}:${chainId}`.
+   * Example key: `USDC:56`
+   */
+  async getMarketMetrics() {
+    const res = await fetchWithRetry(`${this.baseUrl}/api/markets/metrics`, { signal: AbortSignal.timeout(PLATFORM_TIMEOUT_MS) });
+    if (!res.ok) throw new Error(`Failed to fetch market metrics: ${res.status} ${res.statusText}`);
+    const json = await res.json();
+    if (!json.ok) throw new Error(`Market metrics API error: ${json.error ?? "unknown"}`);
+    return json.data;
+  }
+  /**
+   * Fetches the portfolio overview for a wallet address.
+   * Uses the platform's portfolio-data endpoint which aggregates DB snapshots.
+   */
+  async getUserPortfolio(address) {
+    if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+      throw new Error(`Invalid address format: "${address}". Expected 0x followed by 40 hex characters.`);
+    }
+    const res = await fetchWithRetry(`${this.baseUrl}/api/user/portfolio-data?address=${address}`, { signal: AbortSignal.timeout(PLATFORM_TIMEOUT_MS) });
+    if (!res.ok) throw new Error(`Failed to fetch portfolio: ${res.status} ${res.statusText}`);
+    const json = await res.json();
+    if (!json.ok) throw new Error(`Portfolio API error: ${json.error ?? "unknown"}`);
+    return json.data;
+  }
+  /**
+   * Fetches the latest APY snapshot for all markets (or a specific chain).
+   * Calls `/api/apy` — backed by the `apy_latest_mainnet` DB table.
+   *
+   * Returns a record keyed by lowercase asset ID, then by chainId.
+   * Example: `data["usdc"][56].totalSupplyApy`
+   */
+  async getMarketApy(chainId) {
+    const url = chainId ? `${this.baseUrl}/api/apy?chainId=${chainId}` : `${this.baseUrl}/api/apy`;
+    const res = await fetchWithRetry(url, { signal: AbortSignal.timeout(PLATFORM_TIMEOUT_MS) });
+    if (!res.ok) throw new Error(`Failed to fetch APY data: ${res.status} ${res.statusText}`);
+    const json = await res.json();
+    if (!json.ok) throw new Error(`APY API error: ${json.error ?? "unknown"}`);
+    return json.data;
+  }
+  /**
+   * Fetches the Peridot leaderboard (top users by points).
+   * Optionally filters by chainId and limits the result set.
+   */
+  async getLeaderboard(options) {
+    const params = new URLSearchParams();
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    if (options?.chainId !== void 0) params.set("chainId", String(options.chainId));
+    const query = params.toString() ? `?${params.toString()}` : "";
+    const res = await fetchWithRetry(`${this.baseUrl}/api/leaderboard${query}`, { signal: AbortSignal.timeout(PLATFORM_TIMEOUT_MS) });
+    if (!res.ok) throw new Error(`Failed to fetch leaderboard: ${res.status} ${res.statusText}`);
+    const json = await res.json();
+    if (!json.ok) throw new Error(`Leaderboard API error: ${json.error ?? "unknown"}`);
+    return json.data;
+  }
+  /**
+   * Fetches accounts that are currently underwater (shortfall_usd > 0) and
+   * eligible for liquidation. Data is sourced from the account health scanner.
+   */
+  async getLiquidatablePositions(options) {
+    const params = new URLSearchParams();
+    if (options?.chainId !== void 0) params.set("chainId", String(options.chainId));
+    if (options?.minShortfall !== void 0) params.set("minShortfall", String(options.minShortfall));
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    const query = params.toString() ? `?${params.toString()}` : "";
+    const res = await fetchWithRetry(`${this.baseUrl}/api/liquidations/at-risk${query}`, { signal: AbortSignal.timeout(PLATFORM_TIMEOUT_MS) });
+    if (!res.ok) throw new Error(`Failed to fetch liquidatable positions: ${res.status} ${res.statusText}`);
+    const json = await res.json();
+    if (!json.ok) throw new Error(`Liquidations API error: ${json.error ?? "unknown"}`);
+    return json.data;
+  }
+  /**
+   * Fetches verified transaction history for a wallet address.
+   * Optionally filters by chainId and/or actionType.
+   */
+  async getUserTransactions(address, options) {
+    if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+      throw new Error(`Invalid address format: "${address}". Expected 0x followed by 40 hex characters.`);
+    }
+    const params = new URLSearchParams({ address });
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    if (options?.chainId !== void 0) params.set("chainId", String(options.chainId));
+    if (options?.actionType !== void 0) params.set("actionType", options.actionType);
+    const res = await fetchWithRetry(`${this.baseUrl}/api/user/transactions?${params.toString()}`, { signal: AbortSignal.timeout(PLATFORM_TIMEOUT_MS) });
+    if (!res.ok) throw new Error(`Failed to fetch transactions: ${res.status} ${res.statusText}`);
+    const json = await res.json();
+    if (!json.ok) throw new Error(`Transactions API error: ${json.error ?? "unknown"}`);
+    return json.data;
+  }
+  /**
+   * Calls Biconomy MEE /compose to build a cross-chain transaction payload.
+   * Does NOT execute — the returned instructions must be signed by the user.
+   */
+  async biconomyCompose(request) {
+    if (!this.biconomyApiKey) {
+      throw new Error("biconomyApiKey is required in PeridotConfig for cross-chain operations");
+    }
+    const res = await fetch(`${BICONOMY_API_URL}/v1/instructions/compose`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.biconomyApiKey
+      },
+      body: JSON.stringify(request),
+      signal: AbortSignal.timeout(BICONOMY_COMPOSE_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      const error = await res.json().catch(() => ({}));
+      throw new Error(`Biconomy compose error: ${JSON.stringify(error)}`);
+    }
+    return res.json();
+  }
+  /** Polls Biconomy for the status of a submitted super-transaction. */
+  async biconomyGetStatus(superTxHash) {
+    const res = await fetchWithRetry(`${BICONOMY_API_URL}/v1/explorer/transaction/${superTxHash}`, { signal: AbortSignal.timeout(PLATFORM_TIMEOUT_MS) });
+    if (res.status === 404) return { superTxHash, status: "not_found" };
+    if (!res.ok) throw new Error(`Biconomy status error: ${res.status}`);
+    const data = await res.json();
+    return parseBiconomyStatus(superTxHash, data);
+  }
+};
+function parseBiconomyStatus(superTxHash, data) {
+  const status = String(data["status"] ?? "").toLowerCase();
+  const txHashes = data["txHashes"] ?? [];
+  if (status.includes("success") || status.includes("completed")) {
+    return { superTxHash, status: "success", chainTxHashes: txHashes };
+  }
+  if (status.includes("fail") || status.includes("error")) {
+    return { superTxHash, status: "failed", error: String(data["message"] ?? "Unknown error") };
+  }
+  if (status.includes("process")) {
+    return { superTxHash, status: "processing", chainTxHashes: txHashes };
+  }
+  return { superTxHash, status: "pending" };
+}
+
+// src/features/lending/read/list-markets.ts
+var listMarketsSchema = import_zod.z.object({
+  chainId: import_zod.z.number().optional().describe(
+    "Filter by hub chain ID. 56=BSC, 143=Monad, 1868=Somnia. Omit to list all markets across all chains."
+  )
+});
+async function listMarkets(input, config) {
+  const client = new PeridotApiClient(config);
+  const metrics = await client.getMarketMetrics();
+  const markets = Object.entries(metrics).filter(([, m]) => input.chainId === void 0 || m.chainId === input.chainId).map(([key, m]) => {
+    const [asset] = key.split(":");
+    const dataAgeSeconds = m.updatedAt ? Math.round((Date.now() - new Date(m.updatedAt).getTime()) / 1e3) : 0;
+    return {
+      asset: asset ?? key,
+      chainId: m.chainId,
+      priceUsd: m.priceUsd,
+      tvlUsd: m.tvlUsd,
+      utilizationPct: m.utilizationPct,
+      liquidityUsd: m.liquidityUsd,
+      collateralFactorPct: m.collateral_factor_pct,
+      updatedAt: m.updatedAt,
+      dataAgeSeconds
+    };
+  }).sort((a, b) => b.tvlUsd - a.tvlUsd);
+  return { markets, count: markets.length };
+}
+
+// src/features/lending/read/get-portfolio.ts
+var import_zod3 = require("zod");
+
+// src/shared/zod-utils.ts
+var import_zod2 = require("zod");
+var evmAddress = import_zod2.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "Must be a valid Ethereum address (0x followed by 40 hex chars)");
+var tokenAmount = import_zod2.z.string().regex(/^\d+(\.\d+)?$/, 'Amount must be a positive decimal number (e.g. "100" or "0.5")');
+
+// src/shared/cache.ts
+var Cache = class {
+  constructor(ttlMs) {
+    this.ttlMs = ttlMs;
+  }
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (entry.inflight) return void 0;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return void 0;
+    }
+    return entry.data;
+  }
+  set(key, data) {
+    this.store.set(key, { data, expiresAt: Date.now() + this.ttlMs });
+  }
+  clear() {
+    this.store.clear();
+  }
+  /**
+   * Return the cached value if fresh, otherwise call `fetcher` once — even
+   * when multiple callers arrive simultaneously while the fetch is in-flight.
+   * If the fetch throws, the entry is deleted so subsequent callers retry.
+   */
+  async getOrFetch(key, fetcher) {
+    const cached = this.get(key);
+    if (cached !== void 0) return cached;
+    const existing = this.store.get(key);
+    if (existing?.inflight) return existing.inflight;
+    const promise = fetcher().then((data) => {
+      this.set(key, data);
+      const entry = this.store.get(key);
+      if (entry) delete entry.inflight;
+      return data;
+    }).catch((err) => {
+      this.store.delete(key);
+      throw err;
+    });
+    this.store.set(key, { data: void 0, expiresAt: 0, inflight: promise });
+    return promise;
+  }
+};
+
+// src/features/lending/read/get-portfolio.ts
+var portfolioCache = new Cache(3e4);
+var getPortfolioSchema = import_zod3.z.object({
+  address: evmAddress.describe("The wallet address (0x...) to look up")
+});
+async function getPortfolio(input, config) {
+  const key = input.address.toLowerCase();
+  return portfolioCache.getOrFetch(key, async () => {
+    const client = new PeridotApiClient(config);
+    const data = await client.getUserPortfolio(input.address);
+    return {
+      address: input.address,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      portfolio: {
+        currentValue: data.portfolio.currentValue,
+        totalSupplied: data.portfolio.totalSupplied,
+        totalBorrowed: data.portfolio.totalBorrowed,
+        netApy: data.portfolio.netApy,
+        healthFactor: data.portfolio.totalBorrowed > 0 ? data.portfolio.totalSupplied / data.portfolio.totalBorrowed : null
+      },
+      assets: data.assets,
+      transactions: data.transactions,
+      earnings: data.earnings
+    };
+  });
+}
+
+// src/features/lending/read/get-leaderboard.ts
+var import_zod4 = require("zod");
+var getLeaderboardSchema = import_zod4.z.object({
+  limit: import_zod4.z.number().int().min(1).max(100).optional().describe("Number of entries to return (1\u2013100, default 50)."),
+  chainId: import_zod4.z.number().optional().describe("Filter by hub chain ID. 56=BSC, 143=Monad, 1868=Somnia. Omit to show all chains.")
+});
+async function getLeaderboard(input, config) {
+  const client = new PeridotApiClient(config);
+  const opts = {};
+  if (input.limit !== void 0) opts.limit = input.limit;
+  if (input.chainId !== void 0) opts.chainId = input.chainId;
+  const data = await client.getLeaderboard(opts);
+  return {
+    entries: data.entries,
+    total: data.total
+  };
+}
+
+// src/features/lending/read/get-market-rates.ts
+var import_zod5 = require("zod");
+init_constants();
+var getMarketRatesSchema = import_zod5.z.object({
+  asset: import_zod5.z.string().describe('Asset symbol, e.g. "USDC", "WETH", "WBTC", "WBNB", "USDT", "AUSD"'),
+  chainId: import_zod5.z.number().default(BSC_MAINNET_CHAIN_ID).describe("Hub chain ID where the market lives. 56=BSC (default), 143=Monad, 1868=Somnia")
+});
+async function getMarketRates(input, config) {
+  const client = new PeridotApiClient(config);
+  const assetUpper = input.asset.toUpperCase();
+  const [metrics, apyData] = await Promise.all([
+    client.getMarketMetrics(),
+    client.getMarketApy(input.chainId)
+  ]);
+  const key = `${assetUpper}:${input.chainId}`;
+  const metric = metrics[key];
+  if (!metric) {
+    const available = Object.keys(metrics).filter((k) => k.endsWith(`:${input.chainId}`)).map((k) => k.split(":")[0]);
+    throw new Error(
+      `No market data found for "${assetUpper}" on chain ${input.chainId}. Available assets on this chain: ${available.join(", ")}`
+    );
+  }
+  const apy = apyData[assetUpper.toLowerCase()]?.[input.chainId];
+  const apyDataAvailable = apy !== void 0;
+  const dataAgeSeconds = metric.updatedAt ? Math.round((Date.now() - new Date(metric.updatedAt).getTime()) / 1e3) : 0;
+  const warnings = [];
+  if (!apyDataAvailable) {
+    warnings.push(
+      `APY data is not yet available for ${assetUpper} on chain ${input.chainId}. All yield figures (supplyApyPct, borrowApyPct, totalSupplyApyPct, etc.) are showing 0 as a placeholder \u2014 do NOT present them as real rates. The APY indexer may still be catching up.`
+    );
+  }
+  if (dataAgeSeconds > 300) {
+    warnings.push(`Market data is ${Math.round(dataAgeSeconds / 60)} minutes old \u2014 figures may not reflect current conditions.`);
+  }
+  return {
+    asset: assetUpper,
+    chainId: input.chainId,
+    supplyApyPct: apy?.supplyApy ?? 0,
+    borrowApyPct: apy?.borrowApy ?? 0,
+    peridotSupplyApyPct: apy?.peridotSupplyApy ?? 0,
+    peridotBorrowApyPct: apy?.peridotBorrowApy ?? 0,
+    boostSourceSupplyApyPct: apy?.boostSourceSupplyApy ?? 0,
+    boostRewardsSupplyApyPct: apy?.boostRewardsSupplyApy ?? 0,
+    totalSupplyApyPct: apy?.totalSupplyApy ?? 0,
+    netBorrowApyPct: apy?.netBorrowApy ?? 0,
+    tvlUsd: metric.tvlUsd,
+    utilizationPct: metric.utilizationPct,
+    liquidityUsd: metric.liquidityUsd,
+    priceUsd: metric.priceUsd,
+    collateralFactorPct: metric.collateral_factor_pct ?? 0,
+    updatedAt: metric.updatedAt,
+    dataAgeSeconds,
+    apyDataAvailable,
+    warning: warnings.length > 0 ? warnings.join(" ") : void 0
+  };
+}
+
+// src/features/lending/read/get-user-position.ts
+var import_zod6 = require("zod");
+var getUserPositionSchema = import_zod6.z.object({
+  address: evmAddress.describe("The wallet address (0x...) to look up")
+});
+async function getUserPosition(input, config) {
+  const client = new PeridotApiClient(config);
+  const data = await client.getUserPortfolio(input.address);
+  const { portfolio, assets, transactions } = data;
+  const healthFactor = portfolio.totalBorrowed > 0 ? portfolio.totalSupplied / portfolio.totalBorrowed : null;
+  return {
+    address: input.address,
+    totalSuppliedUsd: portfolio.totalSupplied,
+    totalBorrowedUsd: portfolio.totalBorrowed,
+    netWorthUsd: portfolio.currentValue,
+    netApyPct: portfolio.netApy,
+    healthFactor,
+    assets: assets.map((a) => ({
+      assetId: a.assetId,
+      suppliedUsd: a.supplied,
+      borrowedUsd: a.borrowed,
+      netUsd: a.net
+    })),
+    transactions: {
+      supplyCount: transactions.supplyCount,
+      borrowCount: transactions.borrowCount,
+      repayCount: transactions.repayCount,
+      redeemCount: transactions.redeemCount
+    },
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/features/lending/read/simulate-borrow.ts
+var import_decimal = __toESM(require("decimal.js"), 1);
+var import_zod7 = require("zod");
+init_constants();
+var simulateBorrowSchema = import_zod7.z.object({
+  address: evmAddress.describe("The wallet address planning to borrow"),
+  asset: import_zod7.z.string().describe('The asset to borrow, e.g. "USDC", "WETH"'),
+  amount: tokenAmount.describe('Human-readable borrow amount, e.g. "500" for 500 USDC'),
+  chainId: import_zod7.z.number().int().default(BSC_MAINNET_CHAIN_ID).refine(isHubChain, { message: "chainId must be a hub chain (56=BSC, 143=Monad, 1868=Somnia)." }).describe("Hub chain ID. Defaults to BSC (56).")
+});
+var RISK_THRESHOLDS = {
+  safe: 2,
+  moderate: 1.5,
+  high: 1.2,
+  critical: 1
+};
+function classifyRisk(hf) {
+  if (hf >= RISK_THRESHOLDS.safe) return "safe";
+  if (hf >= RISK_THRESHOLDS.moderate) return "moderate";
+  if (hf >= RISK_THRESHOLDS.high) return "high";
+  if (hf >= RISK_THRESHOLDS.critical) return "critical";
+  return "liquidatable";
+}
+async function simulateBorrow(input, config) {
+  const client = new PeridotApiClient(config);
+  const [portfolioData, metricsData] = await Promise.all([
+    client.getUserPortfolio(input.address),
+    client.getMarketMetrics()
+  ]);
+  const assetUpper = input.asset.toUpperCase();
+  const metricKey = `${assetUpper}:${input.chainId}`;
+  const metric = metricsData[metricKey];
+  if (!metric) {
+    throw new Error(`No market data for ${assetUpper} on chain ${input.chainId}`);
+  }
+  const borrowAmountRaw = parseFloat(input.amount);
+  if (isNaN(borrowAmountRaw) || borrowAmountRaw <= 0) {
+    throw new Error(`Invalid borrow amount: "${input.amount}"`);
+  }
+  const borrowAmount = new import_decimal.default(input.amount);
+  const borrowAmountUsd = borrowAmount.mul(metric.priceUsd).toNumber();
+  const { totalSupplied, totalBorrowed } = portfolioData.portfolio;
+  const currentHF = totalBorrowed > 0 ? new import_decimal.default(totalSupplied).div(totalBorrowed).toNumber() : null;
+  const projectedBorrowedUsd = new import_decimal.default(totalBorrowed).add(borrowAmountUsd);
+  if (totalSupplied === 0) {
+    return {
+      currentHealthFactor: null,
+      projectedHealthFactor: null,
+      borrowAmountUsd,
+      isSafe: false,
+      riskLevel: "liquidatable",
+      maxSafeBorrowUsd: 0,
+      warning: "Portfolio shows no supplied collateral (data is sourced from indexed DB snapshots and may not reflect activity from the last few minutes). If you recently supplied assets, wait for the next snapshot update. Otherwise, supply assets and enable them as collateral before borrowing."
+    };
+  }
+  const projectedHF = new import_decimal.default(totalSupplied).div(projectedBorrowedUsd).toNumber();
+  const maxSafeBorrowUsd = import_decimal.default.max(
+    0,
+    new import_decimal.default(totalSupplied).div(RISK_THRESHOLDS.safe).sub(totalBorrowed)
+  ).toNumber();
+  const riskLevel = classifyRisk(projectedHF);
+  const isSafe = projectedHF >= RISK_THRESHOLDS.high;
+  const warnings = [];
+  if (riskLevel === "liquidatable") {
+    warnings.push("This borrow would immediately make you eligible for liquidation.");
+  } else if (riskLevel === "critical") {
+    warnings.push("Health factor would drop critically low. Any price movement risks liquidation.");
+  } else if (riskLevel === "high") {
+    warnings.push("Health factor would be dangerously low. Consider borrowing less.");
+  }
+  return {
+    currentHealthFactor: currentHF,
+    projectedHealthFactor: projectedHF,
+    borrowAmountUsd,
+    isSafe,
+    riskLevel,
+    maxSafeBorrowUsd,
+    warning: warnings[0]
+  };
+}
+
+// src/features/lending/read/get-account-liquidity.ts
+var import_decimal2 = __toESM(require("decimal.js"), 1);
+var import_zod8 = require("zod");
+var import_viem2 = require("viem");
+
+// src/shared/abis.ts
+var import_viem = require("viem");
+var PTOKEN_ABI = (0, import_viem.parseAbi)([
+  "function mint(uint256 mintAmount) returns (uint256)",
+  "function redeem(uint256 redeemTokens) returns (uint256)",
+  "function redeemUnderlying(uint256 redeemAmount) returns (uint256)",
+  "function borrow(uint256 borrowAmount) returns (uint256)",
+  "function repayBorrow(uint256 repayAmount) returns (uint256)",
+  "function repayBorrowBehalf(address borrower, uint256 repayAmount) returns (uint256)",
+  "function liquidateBorrow(address borrower, uint256 repayAmount, address pTokenCollateral) returns (uint256)",
+  "function balanceOf(address owner) view returns (uint256)",
+  "function borrowBalanceStored(address account) view returns (uint256)",
+  "function supplyRatePerBlock() view returns (uint256)",
+  "function borrowRatePerBlock() view returns (uint256)",
+  "function exchangeRateStored() view returns (uint256)",
+  "function underlying() view returns (address)"
+]);
+var COMPTROLLER_ABI = (0, import_viem.parseAbi)([
+  "function enterMarkets(address[] calldata pTokens) returns (uint256[] memory)",
+  "function exitMarket(address pTokenAddress) returns (uint256)",
+  "function getAccountLiquidity(address account) view returns (uint256 errorCode, uint256 liquidity, uint256 shortfall)",
+  "function getAllMarkets() view returns (address[] memory)",
+  "function markets(address pToken) view returns (bool isListed, uint256 collateralFactorMantissa, bool isComped)",
+  "function checkMembership(address account, address pToken) view returns (bool)"
+]);
+var ERC20_ABI = (0, import_viem.parseAbi)([
+  "function approve(address spender, uint256 amount) returns (bool)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function balanceOf(address owner) view returns (uint256)",
+  "function transfer(address to, uint256 amount) returns (bool)"
+]);
+
+// src/features/lending/read/get-account-liquidity.ts
+init_constants();
+var getAccountLiquiditySchema = import_zod8.z.object({
+  address: evmAddress.describe("The wallet address to check"),
+  chainId: import_zod8.z.number().int().default(BSC_MAINNET_CHAIN_ID).refine(isHubChain, { message: "chainId must be a hub chain (56=BSC, 143=Monad, 1868=Somnia)." }).describe("Hub chain ID to query (must be a hub chain). Defaults to BSC (56).")
+});
+async function getAccountLiquidity(input, config) {
+  const rpcUrl = config.rpcUrls?.[input.chainId] ?? DEFAULT_RPC_URLS[input.chainId];
+  if (!rpcUrl) {
+    throw new Error(
+      `No RPC URL available for chain ${input.chainId}. Provide one via config.rpcUrls[${input.chainId}].`
+    );
+  }
+  const controllerAddress = getControllerAddress(input.chainId);
+  const client = (0, import_viem2.createPublicClient)({ transport: (0, import_viem2.http)(rpcUrl) });
+  const [error, liquidity, shortfall] = await client.readContract({
+    address: controllerAddress,
+    abi: COMPTROLLER_ABI,
+    functionName: "getAccountLiquidity",
+    args: [input.address]
+  });
+  if (error !== 0n) {
+    throw new Error(`Comptroller getAccountLiquidity returned error code ${error.toString()}`);
+  }
+  const liquidityUsd = new import_decimal2.default(liquidity.toString()).div("1e18").toNumber();
+  const shortfallUsd = new import_decimal2.default(shortfall.toString()).div("1e18").toNumber();
+  return {
+    address: input.address,
+    chainId: input.chainId,
+    liquidityUsd,
+    shortfallUsd,
+    isHealthy: shortfallUsd === 0
+  };
+}
+
+// src/features/lending/intents/hub/supply.ts
+var import_zod9 = require("zod");
+var import_viem3 = require("viem");
+init_constants();
+var hubSupplySchema = import_zod9.z.object({
+  userAddress: evmAddress.describe("The wallet address supplying assets"),
+  asset: import_zod9.z.string().describe('Asset to supply, e.g. "USDC", "WETH"'),
+  amount: tokenAmount.describe('Human-readable amount to supply, e.g. "100" for 100 USDC'),
+  chainId: import_zod9.z.number().int().default(BSC_MAINNET_CHAIN_ID).refine(isHubChain, { message: "chainId must be a hub chain (56=BSC, 143=Monad, 1868=Somnia). Use build_cross_chain_supply_intent for spoke chains." }).describe("Hub chain ID. Must be a chain with native Peridot markets. Defaults to BSC (56)."),
+  enableAsCollateral: import_zod9.z.boolean().default(true).describe("Whether to enable the supplied asset as collateral. Defaults to true.")
+});
+function buildHubSupplyIntent(input, _config) {
+  const chainId = input.chainId ?? BSC_MAINNET_CHAIN_ID;
+  const enableAsCollateral = input.enableAsCollateral ?? true;
+  const assetUpper = input.asset.toUpperCase();
+  const decimals = getAssetDecimals(assetUpper);
+  const amount = (0, import_viem3.parseUnits)(input.amount, decimals);
+  const pToken = getPTokenAddress(chainId, assetUpper);
+  const underlying = getUnderlyingTokenAddress(chainId, assetUpper);
+  const controller = getControllerAddress(chainId);
+  const calls = [
+    {
+      to: underlying,
+      data: (0, import_viem3.encodeFunctionData)({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [pToken, amount]
+      }),
+      value: 0n,
+      description: `Approve p${assetUpper} contract to spend ${input.amount} ${assetUpper}`
+    },
+    {
+      to: pToken,
+      data: (0, import_viem3.encodeFunctionData)({
+        abi: PTOKEN_ABI,
+        functionName: "mint",
+        args: [amount]
+      }),
+      value: 0n,
+      description: `Supply ${input.amount} ${assetUpper} to Peridot and receive p${assetUpper} tokens`
+    }
+  ];
+  if (enableAsCollateral) {
+    calls.push({
+      to: controller,
+      data: (0, import_viem3.encodeFunctionData)({
+        abi: COMPTROLLER_ABI,
+        functionName: "enterMarkets",
+        args: [[pToken]]
+      }),
+      value: 0n,
+      description: `Enable ${assetUpper} position as collateral for borrowing`
+    });
+  }
+  const collateralNote = enableAsCollateral ? " and enable as collateral" : "";
+  return {
+    type: "hub",
+    chainId,
+    calls,
+    summary: `Supply ${input.amount} ${assetUpper} to Peridot on chain ${input.chainId}${collateralNote}`
+  };
+}
+
+// src/features/lending/intents/hub/borrow.ts
+var import_zod10 = require("zod");
+var import_viem4 = require("viem");
+init_constants();
+var hubBorrowSchema = import_zod10.z.object({
+  userAddress: evmAddress.describe("The wallet address that will borrow"),
+  borrowAsset: import_zod10.z.string().describe('Asset to borrow, e.g. "USDC", "WETH"'),
+  borrowAmount: tokenAmount.describe('Human-readable amount to borrow, e.g. "500" for 500 USDC'),
+  collateralAssets: import_zod10.z.array(import_zod10.z.string()).min(1).describe(
+    'Assets already supplied that will act as collateral, e.g. ["WETH"]. These will have enterMarkets called to ensure they are active collateral.'
+  ),
+  chainId: import_zod10.z.number().int().default(BSC_MAINNET_CHAIN_ID).refine(isHubChain, { message: "chainId must be a hub chain (56=BSC, 143=Monad, 1868=Somnia). Use build_cross_chain_borrow_intent for spoke chains." }).describe("Hub chain ID. Defaults to BSC (56).")
+});
+function buildHubBorrowIntent(input, _config) {
+  const borrowAssetUpper = input.borrowAsset.toUpperCase();
+  const decimals = getAssetDecimals(borrowAssetUpper);
+  const amount = (0, import_viem4.parseUnits)(input.borrowAmount, decimals);
+  const borrowPToken = getPTokenAddress(input.chainId, borrowAssetUpper);
+  const controller = getControllerAddress(input.chainId);
+  const collateralPTokens = input.collateralAssets.map(
+    (a) => getPTokenAddress(input.chainId, a.toUpperCase())
+  );
+  return {
+    type: "hub",
+    chainId: input.chainId,
+    calls: [
+      {
+        to: controller,
+        data: (0, import_viem4.encodeFunctionData)({
+          abi: COMPTROLLER_ABI,
+          functionName: "enterMarkets",
+          args: [collateralPTokens]
+        }),
+        value: 0n,
+        description: `Enable ${input.collateralAssets.join(", ")} as active collateral`
+      },
+      {
+        to: borrowPToken,
+        data: (0, import_viem4.encodeFunctionData)({
+          abi: PTOKEN_ABI,
+          functionName: "borrow",
+          args: [amount]
+        }),
+        value: 0n,
+        description: `Borrow ${input.borrowAmount} ${borrowAssetUpper} from Peridot`
+      }
+    ],
+    summary: `Borrow ${input.borrowAmount} ${borrowAssetUpper} using ${input.collateralAssets.join(", ")} as collateral`,
+    warning: "Ensure your health factor stays above 1.2 after borrowing. Use simulate_borrow to verify."
+  };
+}
+
+// src/features/lending/intents/hub/repay.ts
+var import_zod11 = require("zod");
+var import_viem5 = require("viem");
+init_constants();
+var hubRepaySchema = import_zod11.z.object({
+  userAddress: evmAddress.describe("The wallet address repaying the debt"),
+  asset: import_zod11.z.string().describe('Asset to repay, e.g. "USDC", "WETH"'),
+  amount: import_zod11.z.string().refine((v) => v.toLowerCase() === "max" || /^\d+(\.\d+)?$/.test(v), {
+    message: 'Amount must be a positive decimal number (e.g. "500") or "max" to repay all.'
+  }).describe(
+    'Human-readable amount to repay, e.g. "500" for 500 USDC. Use "max" to repay the full outstanding balance (sets uint256 max).'
+  ),
+  chainId: import_zod11.z.number().int().default(BSC_MAINNET_CHAIN_ID).refine(isHubChain, { message: "chainId must be a hub chain (56=BSC, 143=Monad, 1868=Somnia)." }).describe("Hub chain ID. Defaults to BSC (56).")
+});
+function buildHubRepayIntent(input, _config) {
+  const assetUpper = input.asset.toUpperCase();
+  const decimals = getAssetDecimals(assetUpper);
+  const isMax = input.amount.toLowerCase() === "max";
+  const amount = isMax ? import_viem5.maxUint256 : (0, import_viem5.parseUnits)(input.amount, decimals);
+  const pToken = getPTokenAddress(input.chainId, assetUpper);
+  const underlying = getUnderlyingTokenAddress(input.chainId, assetUpper);
+  const displayAmount = isMax ? "full balance" : `${input.amount} ${assetUpper}`;
+  return {
+    type: "hub",
+    chainId: input.chainId,
+    calls: [
+      {
+        to: underlying,
+        data: (0, import_viem5.encodeFunctionData)({
+          abi: ERC20_ABI,
+          functionName: "approve",
+          args: [pToken, amount]
+        }),
+        value: 0n,
+        description: `Approve p${assetUpper} to pull repayment tokens`
+      },
+      {
+        to: pToken,
+        data: (0, import_viem5.encodeFunctionData)({
+          abi: PTOKEN_ABI,
+          functionName: "repayBorrow",
+          args: [amount]
+        }),
+        value: 0n,
+        description: `Repay ${displayAmount} of ${assetUpper} debt`
+      }
+    ],
+    summary: `Repay ${displayAmount} of ${assetUpper} on Peridot (chain ${input.chainId})`
+  };
+}
+
+// src/features/lending/intents/hub/withdraw.ts
+var import_zod12 = require("zod");
+var import_viem6 = require("viem");
+init_constants();
+var hubWithdrawSchema = import_zod12.z.object({
+  userAddress: evmAddress.describe("The wallet address withdrawing"),
+  asset: import_zod12.z.string().describe('Asset to withdraw, e.g. "USDC", "WETH"'),
+  amount: tokenAmount.describe('Human-readable underlying amount to withdraw, e.g. "100" for 100 USDC'),
+  chainId: import_zod12.z.number().int().default(BSC_MAINNET_CHAIN_ID).refine(isHubChain, { message: "chainId must be a hub chain (56=BSC, 143=Monad, 1868=Somnia)." }).describe("Hub chain ID. Defaults to BSC (56).")
+});
+function buildHubWithdrawIntent(input, _config) {
+  const assetUpper = input.asset.toUpperCase();
+  const decimals = getAssetDecimals(assetUpper);
+  const amount = (0, import_viem6.parseUnits)(input.amount, decimals);
+  const pToken = getPTokenAddress(input.chainId, assetUpper);
+  return {
+    type: "hub",
+    chainId: input.chainId,
+    calls: [
+      {
+        to: pToken,
+        data: (0, import_viem6.encodeFunctionData)({
+          abi: PTOKEN_ABI,
+          functionName: "redeemUnderlying",
+          args: [amount]
+        }),
+        value: 0n,
+        description: `Withdraw ${input.amount} ${assetUpper} from Peridot`
+      }
+    ],
+    summary: `Withdraw ${input.amount} ${assetUpper} from Peridot (chain ${input.chainId})`,
+    warning: "This will revert if withdrawing would make your outstanding borrows undercollateralized."
+  };
+}
+
+// src/features/lending/intents/hub/enable-collateral.ts
+var import_zod13 = require("zod");
+var import_viem7 = require("viem");
+init_constants();
+var hubEnableCollateralSchema = import_zod13.z.object({
+  userAddress: evmAddress.describe("The wallet address enabling collateral"),
+  assets: import_zod13.z.array(import_zod13.z.string()).min(1).describe('Assets to enable as collateral, e.g. ["WETH", "USDC"]'),
+  chainId: import_zod13.z.number().int().default(BSC_MAINNET_CHAIN_ID).refine(isHubChain, { message: "chainId must be a hub chain (56=BSC, 143=Monad, 1868=Somnia)." }).describe("Hub chain ID. Defaults to BSC (56).")
+});
+function buildHubEnableCollateralIntent(input, _config) {
+  const controller = getControllerAddress(input.chainId);
+  const pTokens = input.assets.map((a) => getPTokenAddress(input.chainId, a.toUpperCase()));
+  const assetsDisplay = input.assets.map((a) => a.toUpperCase()).join(", ");
+  return {
+    type: "hub",
+    chainId: input.chainId,
+    calls: [
+      {
+        to: controller,
+        data: (0, import_viem7.encodeFunctionData)({
+          abi: COMPTROLLER_ABI,
+          functionName: "enterMarkets",
+          args: [pTokens]
+        }),
+        value: 0n,
+        description: `Enable ${assetsDisplay} as collateral on Peridot`
+      }
+    ],
+    summary: `Enable ${assetsDisplay} as collateral on chain ${input.chainId}`
+  };
+}
+
+// src/features/lending/intents/hub/disable-collateral.ts
+var import_zod14 = require("zod");
+var import_viem8 = require("viem");
+init_constants();
+var hubDisableCollateralSchema = import_zod14.z.object({
+  userAddress: evmAddress.describe("The wallet address disabling collateral"),
+  asset: import_zod14.z.string().describe('Asset to disable as collateral, e.g. "USDC"'),
+  chainId: import_zod14.z.number().int().default(BSC_MAINNET_CHAIN_ID).refine(isHubChain, { message: "chainId must be a hub chain (56=BSC, 143=Monad, 1868=Somnia)." }).describe("Hub chain ID. Defaults to BSC (56).")
+});
+function buildHubDisableCollateralIntent(input, _config) {
+  const assetUpper = input.asset.toUpperCase();
+  const controller = getControllerAddress(input.chainId);
+  const pToken = getPTokenAddress(input.chainId, assetUpper);
+  return {
+    type: "hub",
+    chainId: input.chainId,
+    calls: [
+      {
+        to: controller,
+        data: (0, import_viem8.encodeFunctionData)({
+          abi: COMPTROLLER_ABI,
+          functionName: "exitMarket",
+          args: [pToken]
+        }),
+        value: 0n,
+        description: `Disable ${assetUpper} as collateral on Peridot`
+      }
+    ],
+    summary: `Disable ${assetUpper} as collateral on chain ${input.chainId}`,
+    warning: "This will revert if you have outstanding borrows that rely on this collateral."
+  };
+}
+
+// src/features/lending/intents/cross-chain/supply.ts
+var import_zod15 = require("zod");
+var import_viem9 = require("viem");
+init_constants();
+var crossChainSupplySchema = import_zod15.z.object({
+  userAddress: evmAddress.describe("The wallet address on the source chain"),
+  sourceChainId: import_zod15.z.number().int().default(ARBITRUM_CHAIN_ID).refine((id) => !isHubChain(id), { message: "sourceChainId must be a spoke chain (e.g. 42161=Arbitrum, 8453=Base). Use build_hub_supply_intent for hub chains (56, 143, 1868)." }).describe(
+    "The spoke chain the user is on, e.g. 42161=Arbitrum, 8453=Base, 1=Ethereum. This is where the user holds the tokens they want to supply."
+  ),
+  asset: import_zod15.z.string().describe('Asset to supply, e.g. "USDC", "WETH"'),
+  amount: tokenAmount.describe('Human-readable amount to supply, e.g. "100" for 100 USDC'),
+  enableAsCollateral: import_zod15.z.boolean().default(true).describe("Whether to enable the supplied asset as collateral. Defaults to true."),
+  slippage: import_zod15.z.number().default(0.01).describe("Bridge slippage tolerance as a decimal (0.01 = 1%). Defaults to 1%.")
+});
+async function buildCrossChainSupplyIntent(input, config) {
+  const client = new PeridotApiClient(config);
+  const assetUpper = input.asset.toUpperCase();
+  const decimals = getAssetDecimals(assetUpper);
+  const amount = (0, import_viem9.parseUnits)(input.amount, decimals);
+  const sourceChainId = input.sourceChainId ?? ARBITRUM_CHAIN_ID;
+  const enableAsCollateral = input.enableAsCollateral ?? true;
+  const hubChainId = resolveHubChainId(sourceChainId, config.network ?? "mainnet");
+  const sourceToken = getUnderlyingTokenAddress(sourceChainId, assetUpper);
+  const hubUnderlying = getUnderlyingTokenAddress(hubChainId, assetUpper);
+  const pToken = getPTokenAddress(hubChainId, assetUpper);
+  const runtimeBalance = {
+    type: "runtimeErc20Balance",
+    tokenAddress: hubUnderlying
+  };
+  const composeFlows = [
+    // Step 1: Bridge from spoke → hub
+    {
+      type: "/instructions/intent-simple",
+      data: {
+        srcToken: sourceToken,
+        dstToken: hubUnderlying,
+        srcChainId: sourceChainId,
+        dstChainId: hubChainId,
+        amount: amount.toString(),
+        slippage: input.slippage ?? 0.01
+      },
+      batch: false
+    },
+    // Step 2: Approve pToken to spend underlying
+    {
+      type: "/instructions/build",
+      data: {
+        functionSignature: "function approve(address,uint256)",
+        args: [pToken, runtimeBalance],
+        to: hubUnderlying,
+        chainId: hubChainId,
+        value: "0"
+      },
+      batch: true
+    },
+    // Step 3: Mint pTokens
+    {
+      type: "/instructions/build",
+      data: {
+        functionSignature: "function mint(uint256)",
+        args: [runtimeBalance],
+        to: pToken,
+        chainId: hubChainId,
+        value: "0"
+      },
+      batch: true
+    }
+  ];
+  if (enableAsCollateral) {
+    const { getControllerAddress: getControllerAddress2 } = await Promise.resolve().then(() => (init_constants(), constants_exports));
+    const controller = getControllerAddress2(hubChainId);
+    composeFlows.push({
+      type: "/instructions/build",
+      data: {
+        functionSignature: "function enterMarkets(address[] memory)",
+        args: [[pToken]],
+        to: controller,
+        chainId: hubChainId,
+        value: "0"
+      },
+      batch: true
+    });
+  }
+  const pTokenRuntime = {
+    type: "runtimeErc20Balance",
+    tokenAddress: pToken,
+    constraints: { gte: "1" }
+  };
+  composeFlows.push({
+    type: "/instructions/build",
+    data: {
+      functionSignature: "function transfer(address,uint256)",
+      args: [input.userAddress, pTokenRuntime],
+      to: pToken,
+      chainId: hubChainId,
+      value: "0"
+    },
+    batch: true
+  });
+  const biconomyResponse = await client.biconomyCompose({
+    ownerAddress: input.userAddress,
+    mode: "eoa",
+    composeFlows
+  });
+  const collateralNote = enableAsCollateral ? " and enable as collateral" : "";
+  const userSteps = [
+    `Bridge ${input.amount} ${assetUpper} from chain ${sourceChainId} \u2192 hub (chain ${hubChainId})`,
+    `Approve Peridot p${assetUpper} market to spend ${assetUpper}`,
+    `Supply ${input.amount} ${assetUpper} to Peridot, receiving p${assetUpper}`,
+    ...enableAsCollateral ? [`Enable ${assetUpper} as collateral`] : [],
+    `Return p${assetUpper} tokens to your wallet`
+  ];
+  return {
+    type: "cross-chain",
+    sourceChainId,
+    destinationChainId: hubChainId,
+    summary: `Cross-chain supply ${input.amount} ${assetUpper} from chain ${sourceChainId} to Peridot${collateralNote}`,
+    userSteps,
+    biconomyInstructions: biconomyResponse,
+    estimatedGas: biconomyResponse.estimatedGas ?? "unknown"
+  };
+}
+
+// src/features/lending/intents/cross-chain/borrow.ts
+var import_zod16 = require("zod");
+var import_viem10 = require("viem");
+init_constants();
+var crossChainBorrowSchema = import_zod16.z.object({
+  userAddress: evmAddress.describe("The wallet address borrowing"),
+  collateralAssets: import_zod16.z.array(import_zod16.z.string()).min(1).describe('Assets already supplied as collateral, e.g. ["WETH"]'),
+  borrowAsset: import_zod16.z.string().describe('Asset to borrow, e.g. "USDC"'),
+  borrowAmount: tokenAmount.describe('Human-readable amount, e.g. "500" for 500 USDC'),
+  targetChainId: import_zod16.z.number().int().optional().refine((id) => id === void 0 || !isHubChain(id), {
+    message: "targetChainId must be a spoke chain (e.g. 42161=Arbitrum, 8453=Base) or omitted to keep funds on the hub."
+  }).describe(
+    "Spoke chain to receive borrowed funds, e.g. 42161=Arbitrum. If omitted, borrowed funds remain on the hub chain (BSC)."
+  ),
+  slippage: import_zod16.z.number().default(0.01).describe("Bridge slippage tolerance. Defaults to 1%.")
+});
+async function buildCrossChainBorrowIntent(input, config) {
+  const client = new PeridotApiClient(config);
+  const borrowAssetUpper = input.borrowAsset.toUpperCase();
+  const decimals = getAssetDecimals(borrowAssetUpper);
+  const amount = (0, import_viem10.parseUnits)(input.borrowAmount, decimals);
+  const actualHubChainId = BSC_MAINNET_CHAIN_ID;
+  const borrowPToken = getPTokenAddress(actualHubChainId, borrowAssetUpper);
+  const controller = getControllerAddress(actualHubChainId);
+  const hubUnderlying = getUnderlyingTokenAddress(actualHubChainId, borrowAssetUpper);
+  const collateralPTokens = input.collateralAssets.map(
+    (a) => getPTokenAddress(actualHubChainId, a.toUpperCase())
+  );
+  const composeFlows = [
+    // Step 1: Enable collateral
+    {
+      type: "/instructions/build",
+      data: {
+        functionSignature: "function enterMarkets(address[] memory)",
+        args: [collateralPTokens],
+        to: controller,
+        chainId: actualHubChainId,
+        value: "0"
+      },
+      batch: true
+    },
+    // Step 2: Borrow
+    {
+      type: "/instructions/build",
+      data: {
+        functionSignature: "function borrow(uint256)",
+        args: [amount.toString()],
+        to: borrowPToken,
+        chainId: actualHubChainId,
+        value: "0"
+      },
+      batch: true
+    }
+  ];
+  const runtimeBalance = {
+    type: "runtimeErc20Balance",
+    tokenAddress: hubUnderlying,
+    constraints: { gte: "1" }
+  };
+  const userSteps = [
+    `Enable ${input.collateralAssets.join(", ")} as active collateral`,
+    `Borrow ${input.borrowAmount} ${borrowAssetUpper} from Peridot`
+  ];
+  if (input.targetChainId && input.targetChainId !== actualHubChainId) {
+    const targetToken = getUnderlyingTokenAddress(input.targetChainId, borrowAssetUpper);
+    composeFlows.push({
+      type: "/instructions/intent-simple",
+      data: {
+        srcToken: hubUnderlying,
+        dstToken: targetToken,
+        srcChainId: actualHubChainId,
+        dstChainId: input.targetChainId,
+        amount: runtimeBalance,
+        slippage: input.slippage ?? 0.01
+      },
+      batch: false
+    });
+    userSteps.push(`Bridge ${borrowAssetUpper} from hub \u2192 chain ${input.targetChainId}`);
+  } else {
+    composeFlows.push({
+      type: "/instructions/build",
+      data: {
+        functionSignature: "function transfer(address,uint256)",
+        args: [input.userAddress, runtimeBalance],
+        to: hubUnderlying,
+        chainId: actualHubChainId,
+        value: "0"
+      },
+      batch: true
+    });
+    userSteps.push(`Receive ${borrowAssetUpper} in your wallet on chain ${actualHubChainId}`);
+  }
+  const biconomyResponse = await client.biconomyCompose({
+    ownerAddress: input.userAddress,
+    mode: "eoa",
+    composeFlows
+  });
+  const destination = input.targetChainId ?? actualHubChainId;
+  return {
+    type: "cross-chain",
+    sourceChainId: actualHubChainId,
+    destinationChainId: destination,
+    summary: `Borrow ${input.borrowAmount} ${borrowAssetUpper} from Peridot, receive on chain ${destination}`,
+    userSteps,
+    biconomyInstructions: biconomyResponse,
+    estimatedGas: biconomyResponse.estimatedGas ?? "unknown"
+  };
+}
+
+// src/features/lending/intents/cross-chain/repay.ts
+var import_zod17 = require("zod");
+var import_viem11 = require("viem");
+init_constants();
+var crossChainRepaySchema = import_zod17.z.object({
+  userAddress: evmAddress.describe("The wallet address repaying the debt"),
+  sourceChainId: import_zod17.z.number().int().default(ARBITRUM_CHAIN_ID).refine((id) => !isHubChain(id), {
+    message: "sourceChainId must be a spoke chain (e.g. 42161=Arbitrum, 8453=Base). Use build_hub_repay_intent for hub chains (56, 143, 1868)."
+  }).describe("Spoke chain the user holds repayment tokens on, e.g. 42161=Arbitrum, 8453=Base"),
+  asset: import_zod17.z.string().describe('Asset to repay, e.g. "USDC", "USDT"'),
+  amount: tokenAmount.describe('Human-readable amount to repay, e.g. "500" for 500 USDC'),
+  repayForAddress: evmAddress.optional().describe("Repay on behalf of another address. Defaults to userAddress."),
+  slippage: import_zod17.z.number().default(0.01).describe("Bridge slippage tolerance. Defaults to 1%.")
+});
+async function buildCrossChainRepayIntent(input, config) {
+  const client = new PeridotApiClient(config);
+  const assetUpper = input.asset.toUpperCase();
+  const decimals = getAssetDecimals(assetUpper);
+  const amount = (0, import_viem11.parseUnits)(input.amount, decimals);
+  const hubChainId = BSC_MAINNET_CHAIN_ID;
+  const sourceChainId = input.sourceChainId ?? ARBITRUM_CHAIN_ID;
+  const sourceToken = getUnderlyingTokenAddress(sourceChainId, assetUpper);
+  const hubUnderlying = getUnderlyingTokenAddress(hubChainId, assetUpper);
+  const pToken = getPTokenAddress(hubChainId, assetUpper);
+  const runtimeBalance = {
+    type: "runtimeErc20Balance",
+    tokenAddress: hubUnderlying
+  };
+  const repayForAddress = input.repayForAddress ?? input.userAddress;
+  const isBehalf = input.repayForAddress !== void 0 && input.repayForAddress !== input.userAddress;
+  const composeFlows = [
+    // Step 1: Bridge from spoke → hub
+    {
+      type: "/instructions/intent-simple",
+      data: {
+        srcToken: sourceToken,
+        dstToken: hubUnderlying,
+        srcChainId: sourceChainId,
+        dstChainId: hubChainId,
+        amount: amount.toString(),
+        slippage: input.slippage ?? 0.01
+      },
+      batch: false
+    },
+    // Step 2: Approve pToken to pull repayment
+    {
+      type: "/instructions/build",
+      data: {
+        functionSignature: "function approve(address,uint256)",
+        args: [pToken, runtimeBalance],
+        to: hubUnderlying,
+        chainId: hubChainId,
+        value: "0"
+      },
+      batch: true
+    },
+    // Step 3: Repay borrow
+    {
+      type: "/instructions/build",
+      data: {
+        functionSignature: isBehalf ? "function repayBorrowBehalf(address,uint256)" : "function repayBorrow(uint256)",
+        args: isBehalf ? [repayForAddress, runtimeBalance] : [runtimeBalance],
+        to: pToken,
+        chainId: hubChainId,
+        value: "0"
+      },
+      batch: true
+    },
+    // Step 4: Return excess to EOA
+    {
+      type: "/instructions/build",
+      data: {
+        functionSignature: "function transfer(address,uint256)",
+        args: [
+          input.userAddress,
+          { type: "runtimeErc20Balance", tokenAddress: hubUnderlying, constraints: { gte: "0" } }
+        ],
+        to: hubUnderlying,
+        chainId: hubChainId,
+        value: "0"
+      },
+      batch: true
+    }
+  ];
+  const biconomyResponse = await client.biconomyCompose({
+    ownerAddress: input.userAddress,
+    mode: "eoa",
+    composeFlows
+  });
+  const behalfNote = isBehalf ? ` on behalf of ${repayForAddress}` : "";
+  return {
+    type: "cross-chain",
+    sourceChainId,
+    destinationChainId: hubChainId,
+    summary: `Repay ${input.amount} ${assetUpper}${behalfNote} from chain ${sourceChainId} to Peridot`,
+    userSteps: [
+      `Bridge ${input.amount} ${assetUpper} from chain ${sourceChainId} \u2192 BSC`,
+      `Approve Peridot p${assetUpper} to pull repayment tokens`,
+      `Repay ${input.amount} ${assetUpper} debt${behalfNote}`,
+      `Return any excess ${assetUpper} to your BSC wallet`
+    ],
+    biconomyInstructions: biconomyResponse,
+    estimatedGas: biconomyResponse.estimatedGas ?? "unknown"
+  };
+}
+
+// src/features/lending/intents/cross-chain/withdraw.ts
+var import_zod18 = require("zod");
+var import_viem12 = require("viem");
+init_constants();
+var crossChainWithdrawSchema = import_zod18.z.object({
+  userAddress: evmAddress.describe("The wallet address withdrawing"),
+  asset: import_zod18.z.string().describe('Asset to withdraw, e.g. "USDC", "WETH"'),
+  amount: tokenAmount.describe('Human-readable underlying amount to withdraw, e.g. "100"'),
+  targetChainId: import_zod18.z.number().int().optional().refine((id) => id === void 0 || !isHubChain(id), {
+    message: "targetChainId must be a spoke chain (e.g. 42161=Arbitrum, 8453=Base) or omitted to keep funds on the hub."
+  }).describe(
+    "Spoke chain to receive the withdrawn funds, e.g. 42161=Arbitrum. If omitted, funds remain on the hub chain (BSC)."
+  ),
+  slippage: import_zod18.z.number().default(0.01).describe("Bridge slippage tolerance. Defaults to 1%.")
+});
+async function buildCrossChainWithdrawIntent(input, config) {
+  const client = new PeridotApiClient(config);
+  const assetUpper = input.asset.toUpperCase();
+  const decimals = getAssetDecimals(assetUpper);
+  const amount = (0, import_viem12.parseUnits)(input.amount, decimals);
+  const hubChainId = BSC_MAINNET_CHAIN_ID;
+  const pToken = getPTokenAddress(hubChainId, assetUpper);
+  const hubUnderlying = getUnderlyingTokenAddress(hubChainId, assetUpper);
+  const runtimeBalance = {
+    type: "runtimeErc20Balance",
+    tokenAddress: hubUnderlying,
+    constraints: { gte: "1" }
+  };
+  const composeFlows = [
+    // Step 1: Redeem from Peridot
+    {
+      type: "/instructions/build",
+      data: {
+        functionSignature: "function redeemUnderlying(uint256)",
+        args: [amount.toString()],
+        to: pToken,
+        chainId: hubChainId,
+        value: "0"
+      },
+      batch: true
+    }
+  ];
+  const userSteps = [`Redeem ${input.amount} ${assetUpper} from Peridot (p${assetUpper} \u2192 ${assetUpper})`];
+  if (input.targetChainId && input.targetChainId !== hubChainId) {
+    const targetToken = getUnderlyingTokenAddress(input.targetChainId, assetUpper);
+    composeFlows.push({
+      type: "/instructions/intent-simple",
+      data: {
+        srcToken: hubUnderlying,
+        dstToken: targetToken,
+        srcChainId: hubChainId,
+        dstChainId: input.targetChainId,
+        amount: runtimeBalance,
+        slippage: input.slippage ?? 0.01
+      },
+      batch: false
+    });
+    userSteps.push(`Bridge ${assetUpper} from hub \u2192 chain ${input.targetChainId}`);
+  } else {
+    composeFlows.push({
+      type: "/instructions/build",
+      data: {
+        functionSignature: "function transfer(address,uint256)",
+        args: [input.userAddress, runtimeBalance],
+        to: hubUnderlying,
+        chainId: hubChainId,
+        value: "0"
+      },
+      batch: true
+    });
+    userSteps.push(`Receive ${assetUpper} in your wallet on BSC`);
+  }
+  const biconomyResponse = await client.biconomyCompose({
+    ownerAddress: input.userAddress,
+    mode: "eoa",
+    composeFlows
+  });
+  const destination = input.targetChainId ?? hubChainId;
+  return {
+    type: "cross-chain",
+    sourceChainId: hubChainId,
+    destinationChainId: destination,
+    summary: `Withdraw ${input.amount} ${assetUpper} from Peridot, receive on chain ${destination}`,
+    userSteps,
+    biconomyInstructions: biconomyResponse,
+    estimatedGas: biconomyResponse.estimatedGas ?? "unknown"
+  };
+}
+
+// src/features/lending/status/check-transaction.ts
+var import_zod19 = require("zod");
+var checkTransactionStatusSchema = import_zod19.z.object({
+  superTxHash: import_zod19.z.string().describe(
+    "The Biconomy super-transaction hash returned after executing a cross-chain intent. Looks like a regular tx hash (0x...)."
+  )
+});
+async function checkTransactionStatus(input, config) {
+  const client = new PeridotApiClient(config);
+  return client.biconomyGetStatus(input.superTxHash);
+}
+
+// src/features/lending/read/get-liquidatable-positions.ts
+var import_zod20 = require("zod");
+var getLiquidatablePositionsSchema = import_zod20.z.object({
+  chainId: import_zod20.z.number().int().optional().describe(
+    "Filter to a single hub chain (56=BSC, 143=Monad, 1868=Somnia). Omit to return at-risk accounts across all chains."
+  ),
+  minShortfall: import_zod20.z.number().min(0).optional().describe(
+    "Minimum shortfall_usd threshold in USD (default: 0 \u2014 returns all underwater accounts). Use e.g. 100 to focus only on meaningfully undercollateralised positions."
+  ),
+  limit: import_zod20.z.number().int().min(1).max(200).optional().describe("Maximum number of results (default: 50, max: 200). Results are ordered by shortfall descending.")
+});
+async function getLiquidatablePositions(input, config) {
+  const client = new PeridotApiClient(config);
+  const opts = {};
+  if (input.chainId !== void 0) opts.chainId = input.chainId;
+  if (input.minShortfall !== void 0) opts.minShortfall = input.minShortfall;
+  if (input.limit !== void 0) opts.limit = input.limit;
+  return client.getLiquidatablePositions(opts);
+}
+
+// src/features/lending/intents/hub/liquidate.ts
+var import_zod21 = require("zod");
+var import_viem13 = require("viem");
+init_constants();
+var hubLiquidateSchema = import_zod21.z.object({
+  liquidatorAddress: evmAddress.describe("The wallet address executing the liquidation (your address)"),
+  borrowerAddress: evmAddress.describe("The underwater borrower address to liquidate"),
+  repayAsset: import_zod21.z.string().describe(
+    'The asset you will repay on behalf of the borrower, e.g. "USDC". This must be an asset the borrower has borrowed.'
+  ),
+  repayAmount: import_zod21.z.string().refine((v) => v.toLowerCase() === "max" || /^\d+(\.\d+)?$/.test(v), {
+    message: 'Amount must be a positive decimal number (e.g. "500") or "max" for uint256 max.'
+  }).describe(
+    `Amount of repayAsset to repay (human-readable, e.g. "500" for 500 USDC). A liquidator may repay at most 50% of the borrower's outstanding debt per call (close factor). Use "max" to pass uint256 max \u2014 the protocol will cap it at the close factor automatically.`
+  ),
+  collateralAsset: import_zod21.z.string().describe(
+    'The collateral asset you want to seize in return, e.g. "WETH". This must be an asset the borrower has supplied as collateral. You receive the equivalent value in pTokens (+ liquidation incentive bonus).'
+  ),
+  chainId: import_zod21.z.number().int().default(BSC_MAINNET_CHAIN_ID).refine(isHubChain, { message: "chainId must be a hub chain (56=BSC, 143=Monad, 1868=Somnia)." }).describe("Hub chain where the underwater position exists. Defaults to BSC (56).")
+});
+function buildHubLiquidateIntent(input, _config) {
+  const repayAsset = input.repayAsset.toUpperCase();
+  const collateralAsset = input.collateralAsset.toUpperCase();
+  const repayDecimals = getAssetDecimals(repayAsset);
+  const isMax = input.repayAmount.toLowerCase() === "max";
+  const repayAmount = isMax ? import_viem13.maxUint256 : (0, import_viem13.parseUnits)(input.repayAmount, repayDecimals);
+  const pRepayToken = getPTokenAddress(input.chainId, repayAsset);
+  const pCollateralToken = getPTokenAddress(input.chainId, collateralAsset);
+  const underlyingRepay = getUnderlyingTokenAddress(input.chainId, repayAsset);
+  const displayAmount = isMax ? "max (capped at close factor)" : `${input.repayAmount} ${repayAsset}`;
+  return {
+    type: "hub",
+    chainId: input.chainId,
+    calls: [
+      {
+        to: underlyingRepay,
+        data: (0, import_viem13.encodeFunctionData)({
+          abi: ERC20_ABI,
+          functionName: "approve",
+          args: [pRepayToken, repayAmount]
+        }),
+        value: 0n,
+        description: `Approve p${repayAsset} to pull ${displayAmount} for liquidation`
+      },
+      {
+        to: pRepayToken,
+        data: (0, import_viem13.encodeFunctionData)({
+          abi: PTOKEN_ABI,
+          functionName: "liquidateBorrow",
+          args: [input.borrowerAddress, repayAmount, pCollateralToken]
+        }),
+        value: 0n,
+        description: `Liquidate ${input.borrowerAddress}: repay ${displayAmount} of ${repayAsset}, seize p${collateralAsset} collateral`
+      }
+    ],
+    summary: `Liquidate ${input.borrowerAddress} on chain ${input.chainId}: repay ${displayAmount} of ${repayAsset}, receive p${collateralAsset}`,
+    warning: "Verify the borrower is still underwater (shortfallUsd > 0) immediately before submitting. The transaction will revert if the position has been partially repaid between blocks."
+  };
+}
+
+// src/features/lending/tools.ts
+var lendingTools = [
+  // ── Read / Simulate ──────────────────────────────────────────────────────
+  {
+    name: "list_markets",
+    description: 'List all Peridot lending markets across all chains with key metrics: asset symbol, chainId, price (USD), TVL (USD), utilization %, available liquidity (USD), and collateral factor %. Results are sorted by TVL descending \u2014 the deepest, most liquid markets appear first. Call this when the user asks "what can I lend or borrow?", "which assets are available?", or before recommending a specific market when you do not already know what is available. Optionally pass chainId (56=BSC, 143=Monad, 1868=Somnia) to restrict results to one chain.',
+    inputSchema: listMarketsSchema,
+    execute: listMarkets,
+    category: "lending"
+  },
+  {
+    name: "get_leaderboard",
+    description: 'Fetch the Peridot points leaderboard: ranked list of top users by total protocol points earned. Each entry contains: rank, wallet address, totalPoints, supplyCount, borrowCount, repayCount, redeemCount, and last-updated timestamp. Points reflect on-chain DeFi activity and daily logins. Call this when the user asks "who are the top users?", "show me the leaderboard", "how many points does address X have?", or "where do I rank?". Use limit (default 50, max 100) to control result size.',
+    inputSchema: getLeaderboardSchema,
+    execute: getLeaderboard,
+    category: "lending"
+  },
+  {
+    name: "get_market_rates",
+    description: "Fetch the full rate breakdown for a specific Peridot market (asset + chainId). Returns: base supply APY, base borrow APY, PERIDOT token reward APY (supply and borrow), boost source APY (Morpho vault / PancakeSwap LP / Magma staking), boost reward APY, total supply APY (= base + peridot + boost_source + boost_rewards), net borrow APY (= base borrow \u2212 peridot borrow reward), TVL (USD), utilization %, available liquidity (USD), asset price (USD), collateral factor %. Call this when the user asks about APY, yields, borrow rates, or liquidity for a specific asset. If you do not know which chainId the asset is on, call list_markets first.",
+    inputSchema: getMarketRatesSchema,
+    execute: getMarketRates,
+    category: "lending"
+  },
+  {
+    name: "get_portfolio",
+    description: `Fetch a wallet's full Peridot portfolio overview: portfolio summary (currentValue, totalSupplied, totalBorrowed, netApy, simplified healthFactor), per-asset breakdown with allocation percentages (supplied, borrowed, net, % of portfolio), all transaction counts (totalCount, supply/borrow/repay/redeem), and lifetime earnings (effectiveApy, totalLifetimeEarnings in USD). Call this when the user asks "how is my portfolio performing?", "what are my earnings?", "show me my full breakdown", "what percentage of my portfolio is in X?", or any question about lifetime yield or activity history. Results are cached for 30 s \u2014 concurrent calls for the same address share one request. For a quick pre-action exposure check before borrowing or withdrawing, use get_user_position instead (lighter, returns simplified health factor).`,
+    inputSchema: getPortfolioSchema,
+    execute: getPortfolio,
+    category: "lending"
+  },
+  {
+    name: "get_user_position",
+    description: "Fetch a user's current Peridot portfolio snapshot: totalSuppliedUsd, totalBorrowedUsd, netWorthUsd, netApyPct, per-asset breakdown, and transaction counts (supply/borrow/repay/redeem). Also returns a simplified healthFactor estimate (totalSupplied / totalBorrowed). IMPORTANT: this estimate ignores per-asset collateral factors and will OVERSTATE the real on-chain health \u2014 treat it as a quick indicator only. Rule of thumb: above 2.0 = low near-term risk; below 2.0 = call get_account_liquidity before recommending further borrows or large withdrawals. ALWAYS call this before building any borrow, withdraw, or repay intent so you know the user's current exposure and can explain the risk to them.",
+    inputSchema: getUserPositionSchema,
+    execute: getUserPosition,
+    category: "lending"
+  },
+  {
+    name: "simulate_borrow",
+    description: 'Simulate the health factor impact of a proposed borrow before submitting any transaction. Returns: currentHealthFactor, projectedHealthFactor, borrowAmountUsd, isSafe (bool), riskLevel (safe | moderate | high | critical | liquidatable), and maxSafeBorrowUsd. ALWAYS call this before build_hub_borrow_intent or build_cross_chain_borrow_intent. Rules: if isSafe=false \u2192 explain the risk and do NOT build the intent. If riskLevel is "high" or worse \u2192 warn the user and confirm before proceeding. If riskLevel is "moderate" \u2192 note the risk, suggest a smaller amount or adding more collateral. Never skip this step even if the user sounds confident \u2014 you cannot predict the liquidation threshold without it.',
+    inputSchema: simulateBorrowSchema,
+    execute: simulateBorrow,
+    category: "lending"
+  },
+  {
+    name: "get_account_liquidity",
+    description: "Read the authoritative on-chain borrow capacity and health directly from Peridot's Comptroller contract. Returns: liquidityUsd (how much more the user can safely borrow), shortfallUsd (how much underwater \u2014 non-zero means they are at risk of liquidation), and isHealthy (true when shortfall = 0). Use this instead of get_user_position when precision matters: before large withdrawals, when the simplified health factor is near 1.5, or when the user asks whether they are at risk of liquidation. This is the same value the protocol uses on-chain.",
+    inputSchema: getAccountLiquiditySchema,
+    execute: getAccountLiquidity,
+    category: "lending"
+  },
+  {
+    name: "get_liquidatable_positions",
+    description: "Fetch a list of borrowers currently underwater (shortfallUsd > 0) and eligible for liquidation on Peridot hub chains. Data is sourced from the on-chain health scanner that indexes borrow events and recomputes account health periodically. IMPORTANT: if this returns an empty list, the scanner pipeline (scan_borrow_events + scan_account_health) may not have run yet \u2014 the data table could be empty rather than meaning no positions are underwater. In that case, inform the user that liquidation data is not yet available and suggest checking back later. Each result contains: address, chainId, shortfallUsd (how far underwater in USD), liquidityUsd (0 when underwater), and checkedAt (when last scanned). Results are ordered by shortfallUsd descending \u2014 the most undercollateralised positions first. Use minShortfall to filter out dust positions (e.g. minShortfall=100 for $100+ shortfall). Always call get_account_liquidity to re-confirm a position is still underwater immediately before building a liquidation intent \u2014 health can change between scanner runs.",
+    inputSchema: getLiquidatablePositionsSchema,
+    execute: getLiquidatablePositions,
+    category: "liquidations"
+  },
+  // ── Hub-chain intents (user on BSC / Monad / Somnia) ─────────────────────
+  // Hub chains host Peridot lending pools natively.
+  // Hub chainIds: BSC (56), Monad (143), Somnia (1868).
+  // If the user is on any other chain, use the cross-chain tools instead.
+  {
+    name: "build_hub_supply_intent",
+    description: "Build signed-ready calldata to supply an asset to Peridot on a hub chain. USE THIS TOOL ONLY when the user is already on a hub chain: BSC (56), Monad (143), or Somnia (1868). If the user is on Arbitrum (42161), Base (8453), Ethereum (1), Polygon (137), Optimism (10), or Avalanche (43114), use build_cross_chain_supply_intent instead. Returns an ordered `calls` array: approve ERC-20 \u2192 mint pToken \u2192 enterMarkets (enable collateral). Tell the user to sign and submit each call in sequence using their wallet.",
+    inputSchema: hubSupplySchema,
+    execute: buildHubSupplyIntent,
+    category: "lending"
+  },
+  {
+    name: "build_hub_borrow_intent",
+    description: "Build calldata to borrow from Peridot on a hub chain (BSC 56, Monad 143, or Somnia 1868). Returns ordered calls: enterMarkets (activate collateral if needed) \u2192 borrow. REQUIRED BEFORE CALLING THIS: run simulate_borrow and confirm isSafe=true. If the user is on a spoke chain (Arbitrum, Base, Ethereum, etc.), use build_cross_chain_borrow_intent instead. Tell the user to sign and submit each call in order.",
+    inputSchema: hubBorrowSchema,
+    execute: buildHubBorrowIntent,
+    category: "lending"
+  },
+  {
+    name: "build_hub_repay_intent",
+    description: 'Build calldata to repay an outstanding Peridot borrow on a hub chain (BSC 56, Monad 143, Somnia 1868). Returns ordered calls: approve ERC-20 \u2192 repayBorrow. Pass amount="max" to repay the entire outstanding debt (recommended to avoid dust). If the user is on a spoke chain, use build_cross_chain_repay_intent instead. Tell the user to sign and submit each call in order.',
+    inputSchema: hubRepaySchema,
+    execute: buildHubRepayIntent,
+    category: "lending"
+  },
+  {
+    name: "build_hub_withdraw_intent",
+    description: "Build calldata to withdraw (redeem) supplied assets from Peridot on a hub chain. ALWAYS call get_user_position first to check for active borrows. If the user has outstanding debt, also call get_account_liquidity to verify the withdrawal will not cause a shortfall \u2014 the contract will revert on-chain if it does. If the user is on a spoke chain, use build_cross_chain_withdraw_intent instead.",
+    inputSchema: hubWithdrawSchema,
+    execute: buildHubWithdrawIntent,
+    category: "lending"
+  },
+  {
+    name: "build_enable_collateral_intent",
+    description: "Build the transaction call to enable a supplied asset as collateral in Peridot (enterMarkets). This is required before you can borrow against a supplied asset. NOTE: build_hub_supply_intent already calls enterMarkets by default \u2014 only call this separately if the user supplied an asset previously without enabling collateral, or if they disabled it and want to re-enable it.",
+    inputSchema: hubEnableCollateralSchema,
+    execute: buildHubEnableCollateralIntent,
+    category: "lending"
+  },
+  {
+    name: "build_disable_collateral_intent",
+    description: "Build the transaction call to stop using a supplied asset as collateral (exitMarket). ALWAYS call get_account_liquidity first and confirm shortfallUsd=0 after the removal \u2014 the contract will revert if any active borrow relies on this asset as collateral. Explain to the user that disabling collateral reduces their borrow capacity.",
+    inputSchema: hubDisableCollateralSchema,
+    execute: buildHubDisableCollateralIntent,
+    category: "lending"
+  },
+  {
+    name: "build_liquidation_intent",
+    description: "Build calldata to liquidate an underwater Peridot borrower on a hub chain. The liquidator repays part of the borrower's debt (up to 50% per call \u2014 the protocol close factor) and in return seizes an equivalent value of the borrower's collateral plus the liquidation bonus. Seized collateral is received as pToken shares \u2014 call redeem on the collateral pToken afterward to convert pTokens back to the underlying asset. REQUIRED BEFORE CALLING THIS: 1. Call get_liquidatable_positions or get_account_liquidity to confirm shortfallUsd > 0. 2. Verify the borrower has borrowed repayAsset and supplied collateralAsset as collateral. 3. Never build a liquidation intent without confirming the position is still underwater. Returns ordered calls: approve underlying \u2192 liquidateBorrow. Only works on hub chains (BSC 56, Monad 143, Somnia 1868).",
+    inputSchema: hubLiquidateSchema,
+    execute: buildHubLiquidateIntent,
+    category: "liquidations"
+  },
+  // ── Cross-chain intents (user on a spoke chain) ───────────────────────────
+  // Spoke chains: Arbitrum (42161), Base (8453), Ethereum (1),
+  // Polygon (137), Optimism (10), Avalanche (43114).
+  // These call Biconomy MEE /compose to produce a single cross-chain payload.
+  // The user signs ONE transaction in their dApp; Biconomy executes the bridge + action.
+  // Use check_transaction_status to track completion.
+  {
+    name: "build_cross_chain_supply_intent",
+    description: "Build a cross-chain supply intent for a user whose tokens are on a spoke chain. USE THIS when the user is on Arbitrum (42161), Base (8453), Ethereum (1), Polygon (137), Optimism (10), or Avalanche (43114). Do NOT use this for BSC (56), Monad (143), or Somnia (1868) \u2014 those are hub chains, use build_hub_supply_intent instead. REQUIRES: biconomyApiKey must be set in config (BICONOMY_API_KEY env var on the MCP server). If it is not set, this tool will fail \u2014 inform the user that cross-chain operations are not available in this deployment. Bridges tokens from the spoke chain to BSC and deposits into Peridot atomically. Returns biconomyInstructions \u2014 the user signs one transaction in their dApp, which submits the payload to Biconomy /execute. After the user submits, call check_transaction_status with the returned superTxHash to track it.",
+    inputSchema: crossChainSupplySchema,
+    execute: buildCrossChainSupplyIntent,
+    category: "lending"
+  },
+  {
+    name: "build_cross_chain_borrow_intent",
+    description: "Borrow from Peridot on BSC and optionally bridge the borrowed amount back to a spoke chain, all in a single atomic cross-chain operation via Biconomy MEE. REQUIRED BEFORE CALLING THIS: run simulate_borrow and confirm isSafe=true. REQUIRES: biconomyApiKey must be set in config (BICONOMY_API_KEY env var on the MCP server). If it is not set, this tool will fail \u2014 inform the user that cross-chain operations are not available in this deployment. Returns biconomyInstructions for a single user signature in their dApp. Use check_transaction_status to track the cross-chain execution.",
+    inputSchema: crossChainBorrowSchema,
+    execute: buildCrossChainBorrowIntent,
+    category: "lending"
+  },
+  {
+    name: "build_cross_chain_repay_intent",
+    description: "Repay a Peridot borrow using tokens held on a spoke chain \u2014 for example, repay a BSC USDC debt by spending USDC on Arbitrum. Bridges and repays in one atomic operation. Useful when the user wants to repay but their tokens are not on BSC. REQUIRES: biconomyApiKey must be set in config (BICONOMY_API_KEY env var on the MCP server). If it is not set, this tool will fail \u2014 inform the user that cross-chain operations are not available in this deployment. Returns biconomyInstructions for a single user signature in their dApp.",
+    inputSchema: crossChainRepaySchema,
+    execute: buildCrossChainRepayIntent,
+    category: "lending"
+  },
+  {
+    name: "build_cross_chain_withdraw_intent",
+    description: "Withdraw supplied assets from Peridot on BSC and optionally bridge them to a spoke chain, all in one atomic cross-chain operation. ALWAYS call get_user_position first to check for active borrows; if present, also call get_account_liquidity to verify the withdrawal will not cause a shortfall. REQUIRES: biconomyApiKey must be set in config (BICONOMY_API_KEY env var on the MCP server). If it is not set, this tool will fail \u2014 inform the user that cross-chain operations are not available in this deployment. Returns biconomyInstructions for a single user signature in their dApp.",
+    inputSchema: crossChainWithdrawSchema,
+    execute: buildCrossChainWithdrawIntent,
+    category: "lending"
+  },
+  // ── Status ───────────────────────────────────────────────────────────────
+  {
+    name: "check_transaction_status",
+    description: 'Check the execution status of a submitted cross-chain Biconomy transaction by its superTxHash. Returns one of: pending (not yet picked up), processing (bridge/relay in progress), success (all cross-chain steps completed), failed (reverted or timed out), not_found (hash unknown \u2014 may not have been submitted yet). Call this after the user submits a cross-chain intent and poll every ~10s until status is "success" or "failed". Only cross-chain intents produce a superTxHash \u2014 hub-chain intents give standard on-chain tx hashes that can be checked on a block explorer.',
+    inputSchema: checkTransactionStatusSchema,
+    execute: checkTransactionStatus,
+    category: "status"
+  }
+];
+
+// src/index.ts
+init_constants();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ARBITRUM_CHAIN_ID,
+  ASSET_DECIMALS,
+  BASE_CHAIN_ID,
+  BSC_MAINNET_CHAIN_ID,
+  BSC_TESTNET_CHAIN_ID,
+  BSC_UNDERLYING_TOKENS,
+  COMPTROLLER_ABI,
+  ERC20_ABI,
+  ETHEREUM_CHAIN_ID,
+  MONAD_MAINNET_CHAIN_ID,
+  PERIDOT_CONTROLLER,
+  PERIDOT_MARKETS,
+  PTOKEN_ABI,
+  PeridotApiClient,
+  SOMNIA_MAINNET_CHAIN_ID,
+  SPOKE_TOKENS,
+  buildCrossChainBorrowIntent,
+  buildCrossChainRepayIntent,
+  buildCrossChainSupplyIntent,
+  buildCrossChainWithdrawIntent,
+  buildHubBorrowIntent,
+  buildHubDisableCollateralIntent,
+  buildHubEnableCollateralIntent,
+  buildHubRepayIntent,
+  buildHubSupplyIntent,
+  buildHubWithdrawIntent,
+  checkTransactionStatus,
+  getAccountLiquidity,
+  getAssetDecimals,
+  getControllerAddress,
+  getLeaderboard,
+  getMarketRates,
+  getPTokenAddress,
+  getUnderlyingTokenAddress,
+  getUserPosition,
+  isHubChain,
+  lendingTools,
+  listMarkets,
+  resolveHubChainId,
+  simulateBorrow
+});
+//# sourceMappingURL=index.cjs.map