@lombard.finance/sdk-agent 0.1.0

package/dist/tools.js

@@ -0,0 +1,1641 @@
+import { BTCE_VAULT_CONTRACTS as xe, getLbtcContractAddresses as R, Env as m, ChainId as T, MIN_STAKE_AMOUNT_BTC as re, MIN_REDEEM_AMOUNT_BTC as C, BTC_DECIMALS as pe, makePublicClient as X, Token as _, getExchangeRatio as Ee, getLBTCExchangeRate as Me, fromSatoshi as oe, getDepositsByAddress as he, getDepositStatus as me, getDepositStatusDisplay as fe, getUnstakesByAddress as Re, getEarnApy as Pe, getEarnTVL as De, getDepositBtcAddress as Fe, requiresAutoMintFee as Ue, getNetworkFeeSignature as Ne, getEarnWithdrawals as be, getApy as qe, getEarnPosition as Oe, getTokenContractInfo as Ve } from "@lombard.finance/sdk";
+import { parseUnits as Q, encodeFunctionData as A, erc20Abi as ye, formatUnits as v } from "viem";
+import { baseSepolia as ne, base as ie, sepolia as ce, mainnet as de } from "viem/chains";
+import { z as c } from "zod";
+import { zodToJsonSchema as je } from "zod-to-json-schema";
+function He() {
+  return {
+    ...R(m.testnet),
+    ...R(m.prod)
+  };
+}
+const L = [
+  {
+    symbol: "LBTC",
+    aliases: ["Lombard BTC", "Lombard staked Bitcoin", "lbtc"],
+    name: "Lombard BTC",
+    description: "Yield-bearing receipt token for native BTC staked via Babylon. 1 LBTC is always worth slightly more than 1 BTC and grows over time as Babylon yield accrues. The exchange rate is never 1:1 — always fetch with get_exchange_rate.",
+    isLombardIssued: !0,
+    isYieldBearing: !0,
+    decimals: 8,
+    addresses: He()
+  },
+  {
+    symbol: "BTC.b",
+    aliases: ["BTCb", "BTC dot b", "btc.b", "Lombard cross-chain BTC"],
+    name: "BTC.b",
+    description: "Lombard's cross-chain wrapped Bitcoin token. Bridged BTC, NOT yield-bearing. Use BTC.b when the user wants wrapped BTC on an EVM chain without yield exposure.",
+    isLombardIssued: !0,
+    isYieldBearing: !1,
+    decimals: 8,
+    addresses: {},
+    notes: "Per-chain BTC.b contract addresses are resolved on demand via the SDK's getTokenContractInfo(Token.BTCb, chainId, env). Call get_token_info with chainId+address for verification."
+  },
+  {
+    symbol: "BTCe",
+    aliases: ["Bitcoin Earn token", "Bitcoin Earn vault share", "BTCE", "btce"],
+    name: "Bitcoin Earn vault share (BTCe)",
+    description: "ERC4626 wrapper share token for the Bitcoin Earn vault. Holding BTCe is how users participate in Bitcoin Earn yield; deposits via prepare_deploy_to_vault mint BTCe, withdrawals via prepare_vault_withdrawal burn it.",
+    isLombardIssued: !0,
+    isYieldBearing: !0,
+    decimals: 8,
+    addresses: { ...xe },
+    notes: "BTCe wraps the underlying Veda share (LBTCv) 1:1 today; convertToAssets() is the authoritative conversion if the ratio ever changes."
+  }
+];
+function ze(t) {
+  if (!t) return;
+  const e = t.trim().toLowerCase();
+  for (const a of L)
+    if (a.symbol.toLowerCase() === e || a.aliases.some((s) => s.toLowerCase() === e)) return a;
+}
+function Ye(t, e) {
+  if (!e) return;
+  const a = e.toLowerCase();
+  for (const s of L) {
+    const r = s.addresses[t];
+    if (r && r.toLowerCase() === a) return s;
+  }
+}
+function Ze() {
+  return [
+    "# Lombard asset glossary",
+    "",
+    "These are the canonical Lombard-related assets. Use these names verbatim. If a user asks about an asset not listed here, call get_token_info to look it up before saying you don't know.",
+    "",
+    ...L.map((e) => {
+      const a = [
+        e.isLombardIssued ? "Lombard-issued" : "third-party",
+        e.isYieldBearing ? "yield-bearing" : "not yield-bearing"
+      ].join(", ");
+      return `- **${e.symbol}** (${e.name}; ${a}; ${e.decimals} decimals) — ${e.description}`;
+    })
+  ].join(`
+`);
+}
+const ba = Ze(), le = {
+  [de.id]: { chain: de, chainId: T.ethereum, env: m.prod, name: "Ethereum" },
+  [ce.id]: { chain: ce, chainId: T.sepolia, env: m.testnet, name: "Sepolia" },
+  [ie.id]: { chain: ie, chainId: T.base, env: m.prod, name: "Base" },
+  [ne.id]: { chain: ne, chainId: T.baseSepoliaTestnet, env: m.testnet, name: "Base Sepolia" }
+};
+function u(t) {
+  const e = le[t];
+  if (!e) {
+    const a = Object.keys(le).join(", ");
+    throw new Error(`Unsupported chain ID: ${t}. Supported: ${a}`);
+  }
+  return e;
+}
+const f = c.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid EVM address"), y = c.string().regex(/^\d+(\.\d+)?$/, "Must be a numeric string").refine(
+  (t) => parseFloat(t) > 0 && parseFloat(t) < 1e3,
+  "Amount must be positive and under 1000"
+), We = "Chain ID. Default to the user's connected chain (provided in your wallet context) unless they specify a different one. Supported: 1=Ethereum, 11155111=Sepolia, 8453=Base, 84532=Base Sepolia.", b = c.number().describe(We), p = c.object({
+  address: f.describe("EVM wallet address (0x...)"),
+  chainId: b
+}), P = c.object({
+  chainId: c.number().optional().describe("Chain ID for environment resolution (optional)")
+}), D = c.object({
+  amount: y.describe("Amount of BTC.b to stake (e.g. '0.1')"),
+  chainId: b
+}), F = c.object({
+  amount: y.describe("Amount of LBTC to unstake"),
+  outputAsset: c.enum(["BTC", "BTCb"]).describe("Output: BTC (cross-chain) or BTCb (same chain)"),
+  recipient: c.string().optional().describe("Destination address (required for BTC output)"),
+  chainId: b
+}), U = p, N = c.object({
+  chainId: c.number().optional().describe(
+    "Chain ID to filter strategies (optional, returns all if omitted)"
+  )
+}), q = p, O = c.object({
+  amount: y.describe("Amount of LBTC to deploy"),
+  chainId: b
+}), ge = c.object({}), V = c.object({
+  amount: y.describe("Amount of vault shares to withdraw"),
+  address: f.describe(
+    "EVM wallet address requesting the withdrawal. Used to check for an existing active withdrawal (only one is allowed per user per vault)."
+  ),
+  chainId: b
+}), j = c.object({
+  depositTxHash: c.string().min(1).describe("The BTC deposit transaction hash to claim"),
+  address: f.describe("EVM wallet address that owns the deposit"),
+  chainId: b
+}), H = c.object({
+  amount: y.describe("Amount of BTC.b to redeem for native BTC"),
+  recipient: c.string().describe(
+    "Bitcoin destination address for the redeemed BTC. MUST be a valid Bitcoin address for the network (bc1.../1.../3... mainnet; tb1.../m.../n.../2... testnet). Ask the user for this explicitly — never infer from prior context."
+  ),
+  chainId: b
+}), we = c.object({
+  query: c.string().optional().describe(
+    "Free-text token name or symbol (e.g. 'BTCe', 'LBTC', 'Bitcoin Earn vault share')."
+  ),
+  address: c.string().optional().describe(
+    "Optional contract address (0x...). When provided, chainId is required too."
+  ),
+  chainId: c.number().optional().describe("Chain ID for an address-based lookup.")
+}), z = c.object({
+  address: f.describe(
+    "EVM wallet address that owns the active withdrawal being cancelled."
+  ),
+  chainId: b
+}), Ke = c.object({
+  address: f.describe("EVM wallet address (0x...)")
+}), Y = c.object({
+  category: c.string().optional().describe(
+    "Filter by category: automated-strategy, borrow-stables, looping, dex-lp, other"
+  ),
+  chain: c.string().optional().describe("Filter by chain (e.g. Ethereum, Base, Solana)"),
+  protocol: c.string().optional().describe("Filter by protocol (e.g. Morpho, Aave, Uniswap)")
+}), Z = c.object({
+  tokenAddress: f.describe(
+    "ERC-20 token contract address (0x...). Get this from tool results like get_morpho_lbtc_markets, not from memory."
+  ),
+  address: f.describe("EVM wallet address to check balance for"),
+  chainId: b
+}), Be = c.object({}), $ = c.string().regex(
+  /^0x[a-fA-F0-9]{64}$/,
+  "Invalid Morpho market ID (must be 0x + 64 hex chars)"
+).describe("Morpho Blue market ID (from get_morpho_lbtc_markets)"), W = c.object({
+  marketId: $,
+  amount: y.describe(
+    "Amount of LBTC to supply as collateral (e.g. '0.1')"
+  ),
+  address: f.describe("EVM wallet address supplying the collateral")
+}), K = c.object({
+  marketId: $,
+  amount: y.describe(
+    "Amount of loan asset to borrow (e.g. '100' for 100 USDC)"
+  ),
+  address: f.describe("EVM wallet address borrowing the asset")
+}), G = c.object({
+  marketId: $,
+  amount: y.describe(
+    "Amount of loan asset to repay (e.g. '1' for 1 USDC)"
+  ),
+  address: f.describe("EVM wallet address repaying the debt")
+}), J = c.object({
+  marketId: $,
+  address: f.describe("EVM wallet address to check position for")
+});
+function l(t) {
+  return je(t, { target: "openAi" });
+}
+const Ge = l(z);
+l(Ke);
+const g = l(p), Je = l(P), Xe = l(D), Qe = l(F), et = l(U), tt = l(N), at = l(q), st = l(O), rt = l(ge), ot = l(V), nt = l(j), it = l(Y), ct = l(Z), dt = l(we), lt = l(H), ut = l(Be), pt = l(
+  W
+), ht = l(K), mt = l(G), ft = l(J), bt = /* @__PURE__ */ new Set([
+  11155111,
+  // ethereum sepolia
+  84532
+  // base sepolia
+]), yt = /^(bc1[a-z0-9]{39,87}|[13][a-km-zA-HJ-NP-Z1-9]{25,34})$/, gt = /^(tb1[a-z0-9]{39,87}|[mn2][a-km-zA-HJ-NP-Z1-9]{25,34})$/;
+function ve(t, e) {
+  if (typeof t != "string") return !1;
+  const a = t.trim();
+  return a.length === 0 ? !1 : bt.has(e) ? gt.test(a) : yt.test(a);
+}
+function x(t) {
+  if (typeof t != "string" || !/^\d+(\.\d+)?$/.test(t)) return !1;
+  const e = Number(t);
+  return Number.isFinite(e) && e > 0;
+}
+function wt(t) {
+  const e = [], a = [];
+  if (x(t.amount) ? Number(t.amount) < C && a.push(
+    `amount ${t.amount} is below the protocol minimum of ${C} LBTC. Network fees may push the practical minimum higher; ask the user to confirm a value at or above ${C}.`
+  ) : a.push(
+    "amount must be a positive numeric string (e.g. '0.5')"
+  ), t.outputAsset !== "BTC" && t.outputAsset !== "BTCb" && a.push("outputAsset must be either 'BTC' or 'BTCb'"), t.outputAsset === "BTC" && (typeof t.recipient != "string" || t.recipient.length === 0 ? e.push("recipient") : ve(t.recipient, t.chainId) || a.push(
+    "recipient is not a valid Bitcoin address for this network. Mainnet: bc1.../1.../3...; Sepolia/testnet: tb1.../m.../n.../2..."
+  )), e.length === 0 && a.length === 0)
+    return { valid: !0 };
+  const s = [];
+  return e.length > 0 && s.push(
+    `Ask the user for: ${e.join(", ")}. Do not infer these values from prior context.`
+  ), a.length > 0 && s.push(
+    "Surface the listed errors to the user and re-prompt; do not retry the tool with the same arguments."
+  ), {
+    valid: !1,
+    missing: e,
+    errors: a,
+    note: s.join(" ")
+  };
+}
+function Bt(t) {
+  const e = [];
+  return x(t.amount) ? Number(t.amount) < re && e.push(
+    `amount ${t.amount} is below the protocol minimum of ${re} BTC.`
+  ) : e.push("amount must be a positive numeric string (e.g. '0.5')"), e.length === 0 ? { valid: !0 } : {
+    valid: !1,
+    missing: [],
+    errors: e,
+    note: "Surface the listed errors to the user and re-prompt; do not retry the tool with the same arguments."
+  };
+}
+function vt(t) {
+  const e = [], a = [];
+  if (x(t.amount) ? Number(t.amount) < C && a.push(
+    `amount ${t.amount} is below the protocol minimum of ${C} BTC. Network fees may push the practical minimum higher.`
+  ) : a.push("amount must be a positive numeric string (e.g. '0.001')"), typeof t.recipient != "string" || t.recipient.length === 0 ? e.push("recipient") : ve(t.recipient, t.chainId) || a.push(
+    "recipient is not a valid Bitcoin address for this network. Mainnet: bc1.../1.../3...; Sepolia/testnet: tb1.../m.../n.../2..."
+  ), e.length === 0 && a.length === 0) return { valid: !0 };
+  const s = [];
+  return e.length > 0 && s.push(
+    `Ask the user for: ${e.join(", ")}. Do not infer these values from prior context.`
+  ), a.length > 0 && s.push(
+    "Surface the listed errors to the user and re-prompt; do not retry the tool with the same arguments."
+  ), {
+    valid: !1,
+    missing: e,
+    errors: a,
+    note: s.join(" ")
+  };
+}
+function Te(t) {
+  return x(t.amount) ? { valid: !0 } : {
+    valid: !1,
+    missing: [],
+    errors: ["amount must be a positive numeric string (e.g. '0.5')"],
+    note: "Surface the listed errors to the user and re-prompt; do not retry the tool with the same arguments."
+  };
+}
+function Tt(t, e) {
+  const a = (e == null ? void 0 : e.mainnet) ?? process.env.LOMBARD_PARTNER_ID ?? "lombardtest1", s = (e == null ? void 0 : e.testnet) ?? process.env.LOMBARD_TESTNET_PARTNER_ID ?? "test1";
+  return t === m.testnet ? s : a;
+}
+const w = "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb", I = R(m.prod)[T.ethereum], Ct = "https://api.morpho.org/graphql", At = 1e4, ee = {
+  name: "marketParams",
+  type: "tuple",
+  components: [
+    { name: "loanToken", type: "address" },
+    { name: "collateralToken", type: "address" },
+    { name: "oracle", type: "address" },
+    { name: "irm", type: "address" },
+    { name: "lltv", type: "uint256" }
+  ]
+}, kt = [
+  {
+    name: "supplyCollateral",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      ee,
+      { name: "assets", type: "uint256" },
+      { name: "onBehalf", type: "address" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: []
+  }
+], _t = [
+  {
+    name: "borrow",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      ee,
+      { name: "assets", type: "uint256" },
+      { name: "shares", type: "uint256" },
+      { name: "onBehalf", type: "address" },
+      { name: "receiver", type: "address" }
+    ],
+    outputs: [
+      { name: "assetsBorrowed", type: "uint256" },
+      { name: "sharesBorrowed", type: "uint256" }
+    ]
+  }
+], ue = [
+  {
+    name: "position",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "id", type: "bytes32" },
+      { name: "user", type: "address" }
+    ],
+    outputs: [
+      { name: "supplyShares", type: "uint256" },
+      { name: "borrowShares", type: "uint128" },
+      { name: "collateral", type: "uint128" }
+    ]
+  },
+  {
+    name: "market",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "id", type: "bytes32" }],
+    outputs: [
+      { name: "totalSupplyAssets", type: "uint128" },
+      { name: "totalSupplyShares", type: "uint128" },
+      { name: "totalBorrowAssets", type: "uint128" },
+      { name: "totalBorrowShares", type: "uint128" },
+      { name: "lastUpdate", type: "uint128" },
+      { name: "fee", type: "uint128" }
+    ]
+  }
+], It = [
+  {
+    name: "repay",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      ee,
+      { name: "assets", type: "uint256" },
+      { name: "shares", type: "uint256" },
+      { name: "onBehalf", type: "address" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: [
+      { name: "assetsRepaid", type: "uint256" },
+      { name: "sharesRepaid", type: "uint256" }
+    ]
+  }
+], St = [
+  {
+    name: "price",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+], Lt = 10n ** 36n, $t = 10n ** 18n, xt = 0.8;
+function Et({
+  collateralRaw: t,
+  borrowAssetsRaw: e,
+  oraclePrice: a,
+  lltvRaw: s
+}) {
+  const r = Number(v(s, 18));
+  if (t === 0n)
+    return {
+      currentLtv: 0,
+      lltv: r,
+      healthStatus: e > 0n ? "Bad debt" : "Empty"
+    };
+  if (e === 0n)
+    return {
+      currentLtv: 0,
+      lltv: r,
+      healthStatus: "Collateral only (no borrows)"
+    };
+  if (a === 0n)
+    return {
+      currentLtv: 0,
+      lltv: r,
+      healthStatus: "Unknown (oracle unavailable)"
+    };
+  const o = t * a / Lt, n = e * $t / o, i = Number(v(n, 18)), d = r * xt;
+  let h;
+  return i < d ? h = "Healthy" : i < r ? h = "At risk" : h = "Liquidatable", { currentLtv: i, lltv: r, healthStatus: h };
+}
+const Mt = `{
+  markets(where: {
+    collateralAssetAddress_in: ["${I}"],
+    chainId_in: [1]
+  }) {
+    items {
+      marketId: uniqueKey
+      loanAsset { symbol address decimals }
+      collateralAsset { symbol address decimals }
+      oracleAddress
+      irmAddress
+      lltv
+      state {
+        supplyApy
+        borrowApy
+        supplyAssetsUsd
+        borrowAssetsUsd
+        utilization
+      }
+    }
+  }
+}`;
+function E(t) {
+  return `{
+    marketByUniqueKey(uniqueKey: "${t}", chainId: 1) {
+      marketId: uniqueKey
+      loanAsset { symbol address decimals }
+      collateralAsset { symbol address decimals }
+      oracleAddress
+      irmAddress
+      lltv
+      state {
+        supplyApy
+        borrowApy
+        supplyAssetsUsd
+        borrowAssetsUsd
+        utilization
+      }
+    }
+  }`;
+}
+async function k(t) {
+  var s;
+  const e = await fetch(Ct, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ query: t })
+  });
+  if (!e.ok)
+    throw new Error(`Morpho API returned ${e.status}`);
+  const a = await e.json();
+  if ((s = a.errors) != null && s.length)
+    throw new Error(`Morpho API error: ${a.errors[0].message}`);
+  return a.data;
+}
+function Rt(t) {
+  const e = t.state.supplyAssetsUsd;
+  return {
+    marketId: t.marketId,
+    loanAsset: t.loanAsset.symbol,
+    loanAssetAddress: t.loanAsset.address,
+    collateralAsset: t.collateralAsset.symbol,
+    collateralAssetAddress: t.collateralAsset.address,
+    supplyApy: `${(t.state.supplyApy * 100).toFixed(2)}%`,
+    borrowApy: `${(t.state.borrowApy * 100).toFixed(2)}%`,
+    tvlUsd: `$${e >= 1e6 ? `${(e / 1e6).toFixed(2)}M` : e >= 1e3 ? `${(e / 1e3).toFixed(1)}K` : e.toFixed(0)}`,
+    utilization: `${(t.state.utilization * 100).toFixed(1)}%`,
+    lltv: `${(Number(t.lltv) / 1e18 * 100).toFixed(0)}%`,
+    description: `Borrow ${t.loanAsset.symbol} against LBTC collateral (${(t.state.supplyApy * 100).toFixed(2)}% supply APY, ${(Number(t.lltv) / 1e18 * 100).toFixed(0)}% LLTV)`
+  };
+}
+const Pt = {
+  name: "get_morpho_lbtc_markets",
+  description: "List Morpho Blue lending markets where LBTC is used as collateral. Returns market IDs, loan assets, supply/borrow APYs, TVL, and utilization. Use this to find markets where users can supply LBTC as collateral to borrow other assets.",
+  parameters: ut,
+  schema: Be,
+  execute: async (t) => {
+    try {
+      const a = (await k(Mt)).markets.items.filter((s) => s.state.supplyAssetsUsd >= At).sort((s, r) => r.state.supplyAssetsUsd - s.state.supplyAssetsUsd).map(Rt);
+      return {
+        markets: a,
+        note: a.length > 0 ? `Found ${a.length} active Morpho markets with LBTC collateral on Ethereum mainnet. Supply LBTC as collateral to borrow the loan asset.` : "No active Morpho markets found for LBTC."
+      };
+    } catch (e) {
+      return {
+        markets: [],
+        note: "",
+        error: e instanceof Error ? e.message : "Failed to fetch Morpho markets"
+      };
+    }
+  }
+}, Dt = {
+  name: "prepare_morpho_supply_collateral",
+  description: "Prepare transactions to supply LBTC as collateral to a Morpho Blue market. Returns two unsigned transactions: (1) ERC-20 approve for the Morpho contract, and (2) supplyCollateral call. The user's wallet signs both.",
+  parameters: pt,
+  schema: W,
+  execute: async (t) => {
+    const { marketId: e, amount: a, address: s } = W.parse(t);
+    try {
+      const o = (await k(E(e))).marketByUniqueKey;
+      if (!o)
+        return {
+          action: "error",
+          marketId: e,
+          description: "",
+          error: `Market ${e} not found on Morpho.`
+        };
+      if (o.collateralAsset.address.toLowerCase() !== I.toLowerCase())
+        return {
+          action: "error",
+          marketId: e,
+          description: "",
+          error: `This market uses ${o.collateralAsset.symbol} as collateral, not LBTC.`
+        };
+      const n = Q(a, pe), i = A({
+        abi: ye,
+        functionName: "approve",
+        args: [w, n]
+      }), d = {
+        loanToken: o.loanAsset.address,
+        collateralToken: o.collateralAsset.address,
+        oracle: o.oracleAddress,
+        irm: o.irmAddress,
+        lltv: BigInt(o.lltv)
+      }, h = A({
+        abi: kt,
+        functionName: "supplyCollateral",
+        args: [
+          d,
+          n,
+          s,
+          "0x"
+        ]
+      });
+      return {
+        action: "sdk_execute",
+        method: "morpho.supplyCollateral",
+        params: {
+          chainId: 1,
+          // Morpho Blue is Ethereum mainnet only
+          transactions: [
+            {
+              to: I,
+              data: i,
+              label: `Approve Morpho to spend ${a} LBTC`
+            },
+            {
+              to: w,
+              data: h,
+              label: `Supply ${a} LBTC as collateral to ${o.loanAsset.symbol}/LBTC market`
+            }
+          ]
+        },
+        marketId: e,
+        description: `Supply ${a} LBTC as collateral to the ${o.loanAsset.symbol}/LBTC Morpho market (${(Number(o.lltv) / 1e18 * 100).toFixed(0)}% LLTV, ${(o.state.supplyApy * 100).toFixed(2)}% supply APY). This requires two transactions: approve + supply.`
+      };
+    } catch (r) {
+      return {
+        action: "error",
+        marketId: e,
+        description: "",
+        error: r instanceof Error ? r.message : "Failed to prepare Morpho supply"
+      };
+    }
+  }
+}, Ft = {
+  name: "prepare_morpho_borrow",
+  description: "Prepare a transaction to borrow from a Morpho Blue market where the user has LBTC collateral. The user must have already supplied LBTC as collateral to this market. Returns an unsigned borrow transaction for the user's wallet to sign.",
+  parameters: ht,
+  schema: K,
+  execute: async (t) => {
+    const { marketId: e, amount: a, address: s } = K.parse(t);
+    try {
+      const o = (await k(E(e))).marketByUniqueKey;
+      if (!o)
+        return {
+          action: "error",
+          marketId: e,
+          description: "",
+          error: `Market ${e} not found on Morpho.`
+        };
+      const n = Q(a, o.loanAsset.decimals), i = {
+        loanToken: o.loanAsset.address,
+        collateralToken: o.collateralAsset.address,
+        oracle: o.oracleAddress,
+        irm: o.irmAddress,
+        lltv: BigInt(o.lltv)
+      }, d = A({
+        abi: _t,
+        functionName: "borrow",
+        args: [
+          i,
+          n,
+          0n,
+          // shares = 0 means borrow by asset amount
+          s,
+          // onBehalf
+          s
+          // receiver
+        ]
+      });
+      return {
+        action: "sdk_execute",
+        method: "morpho.borrow",
+        params: {
+          chainId: 1,
+          transactions: [
+            {
+              to: w,
+              data: d,
+              label: `Borrow ${a} ${o.loanAsset.symbol} from ${o.loanAsset.symbol}/LBTC market`
+            }
+          ]
+        },
+        marketId: e,
+        description: `Borrow ${a} ${o.loanAsset.symbol} against your LBTC collateral on the ${o.loanAsset.symbol}/LBTC Morpho market (${(o.state.borrowApy * 100).toFixed(2)}% borrow APY).`
+      };
+    } catch (r) {
+      return {
+        action: "error",
+        marketId: e,
+        description: "",
+        error: r instanceof Error ? r.message : "Failed to prepare Morpho borrow"
+      };
+    }
+  }
+}, Ut = {
+  name: "prepare_morpho_repay",
+  description: "Prepare transactions to repay borrowed assets on a Morpho Blue market. Returns two unsigned transactions: (1) ERC-20 approve for the Morpho contract, and (2) repay call. The user must have the loan asset in their wallet.",
+  parameters: mt,
+  schema: G,
+  execute: async (t) => {
+    const { marketId: e, amount: a, address: s } = G.parse(t);
+    try {
+      const o = (await k(E(e))).marketByUniqueKey;
+      if (!o)
+        return {
+          action: "error",
+          marketId: e,
+          description: "",
+          error: `Market ${e} not found on Morpho.`
+        };
+      const n = Q(a, o.loanAsset.decimals), i = A({
+        abi: ye,
+        functionName: "approve",
+        args: [w, n]
+      }), d = {
+        loanToken: o.loanAsset.address,
+        collateralToken: o.collateralAsset.address,
+        oracle: o.oracleAddress,
+        irm: o.irmAddress,
+        lltv: BigInt(o.lltv)
+      }, h = A({
+        abi: It,
+        functionName: "repay",
+        args: [
+          d,
+          n,
+          0n,
+          // shares = 0 means repay by asset amount
+          s,
+          // onBehalf
+          "0x"
+          // data (no callback)
+        ]
+      });
+      return {
+        action: "sdk_execute",
+        method: "morpho.repay",
+        params: {
+          chainId: 1,
+          transactions: [
+            {
+              to: o.loanAsset.address,
+              data: i,
+              label: `Approve Morpho to spend ${a} ${o.loanAsset.symbol}`
+            },
+            {
+              to: w,
+              data: h,
+              label: `Repay ${a} ${o.loanAsset.symbol} on ${o.loanAsset.symbol}/LBTC market`
+            }
+          ]
+        },
+        marketId: e,
+        description: `Repay ${a} ${o.loanAsset.symbol} on the ${o.loanAsset.symbol}/${o.collateralAsset.symbol} Morpho market. This requires two transactions: approve + repay.`
+      };
+    } catch (r) {
+      return {
+        action: "error",
+        marketId: e,
+        description: "",
+        error: r instanceof Error ? r.message : "Failed to prepare Morpho repay"
+      };
+    }
+  }
+}, Nt = {
+  name: "get_morpho_position",
+  description: "Get the user's position in a Morpho Blue market: collateral deposited, amount borrowed, current LTV, and health status. Returns token addresses for use with get_token_balance.",
+  parameters: ft,
+  schema: J,
+  execute: async (t) => {
+    const { marketId: e, address: a } = J.parse(t), s = {
+      collateral: "0",
+      borrowAssets: "0",
+      loanAsset: "",
+      loanAssetAddress: "",
+      collateralAsset: "LBTC",
+      collateralAssetAddress: I,
+      lltv: "",
+      currentLtv: "0%",
+      healthStatus: "No position"
+    };
+    try {
+      const o = (await k(E(e))).marketByUniqueKey;
+      if (!o)
+        return { ...s, error: `Market ${e} not found.` };
+      const n = u(1), i = X({
+        chainId: n.chainId,
+        env: n.env
+      }), [d, h, Ce] = await Promise.all([
+        i.readContract({
+          address: w,
+          abi: ue,
+          functionName: "position",
+          args: [e, a]
+        }),
+        i.readContract({
+          address: w,
+          abi: ue,
+          functionName: "market",
+          args: [e]
+        }),
+        i.readContract({
+          address: o.oracleAddress,
+          abi: St,
+          functionName: "price"
+        })
+      ]), te = d[2], Ae = d[1], ke = h[2], ae = h[3], se = ae > 0n ? Ae * ke / ae : 0n, _e = v(te, pe), Ie = v(
+        se,
+        o.loanAsset.decimals
+      ), { currentLtv: Se, lltv: Le, healthStatus: $e } = Et({
+        collateralRaw: te,
+        borrowAssetsRaw: se,
+        oraclePrice: Ce,
+        lltvRaw: BigInt(o.lltv)
+      });
+      return {
+        collateral: _e,
+        borrowAssets: Ie,
+        loanAsset: o.loanAsset.symbol,
+        loanAssetAddress: o.loanAsset.address,
+        collateralAsset: o.collateralAsset.symbol,
+        collateralAssetAddress: o.collateralAsset.address,
+        lltv: `${(Le * 100).toFixed(0)}%`,
+        currentLtv: `${(Se * 100).toFixed(1)}%`,
+        healthStatus: $e
+      };
+    } catch (r) {
+      return {
+        ...s,
+        error: r instanceof Error ? r.message : "Failed to fetch Morpho position"
+      };
+    }
+  }
+};
+function B(t, e, a) {
+  return Promise.race([
+    t,
+    new Promise(
+      (s, r) => setTimeout(
+        () => r(new Error(`${a} timed out after ${e}ms`)),
+        e
+      )
+    )
+  ]);
+}
+async function S(t, e, a) {
+  const s = u(a), r = await B(
+    Ve(t, s.chainId, s.env),
+    1e4,
+    "getTokenContractInfo"
+  ), o = X({
+    chainId: s.chainId,
+    env: s.env
+  }), n = await B(
+    o.readContract({
+      address: r.address,
+      abi: [
+        {
+          name: "balanceOf",
+          type: "function",
+          stateMutability: "view",
+          inputs: [{ name: "account", type: "address" }],
+          outputs: [{ name: "", type: "uint256" }]
+        }
+      ],
+      functionName: "balanceOf",
+      args: [e]
+    }),
+    1e4,
+    `${t}.balanceOf on ${s.name}`
+  ), i = "decimals" in r && typeof r.decimals == "number" ? r.decimals : 8;
+  return v(n, i);
+}
+const qt = {
+  name: "get_lbtc_balance",
+  description: "Check the LBTC balance for a wallet address on a given chain.",
+  parameters: g,
+  schema: p,
+  execute: async (t) => {
+    const { address: e, chainId: a } = p.parse(t), { name: s } = u(a);
+    try {
+      return { balance: await S(_.LBTC, e, a), token: "LBTC", chain: s, address: e };
+    } catch (r) {
+      return {
+        balance: "",
+        token: "LBTC",
+        chain: s,
+        address: e,
+        error: r instanceof Error ? r.message : "Failed to fetch LBTC balance"
+      };
+    }
+  }
+}, Ot = {
+  name: "get_btcb_balance",
+  description: "Check the BTC.b (cross-chain Bitcoin) balance for a wallet address on a given chain.",
+  parameters: g,
+  schema: p,
+  execute: async (t) => {
+    const { address: e, chainId: a } = p.parse(t), { name: s } = u(a);
+    try {
+      return { balance: await S(_.BTCb, e, a), token: "BTC.b", chain: s, address: e };
+    } catch (r) {
+      return {
+        balance: "",
+        token: "BTC.b",
+        chain: s,
+        address: e,
+        error: r instanceof Error ? r.message : "Failed to fetch BTC.b balance"
+      };
+    }
+  }
+}, Vt = {
+  name: "get_exchange_rate",
+  description: "Get the current LBTC/BTC exchange rate and minimum stake amount. LBTC accrues staking yield over time, so 1 LBTC is worth slightly more than 1 BTC.",
+  parameters: Je,
+  schema: P,
+  execute: async (t) => {
+    const { chainId: e } = P.parse(t);
+    try {
+      const a = m.prod, [s, r] = await Promise.all([
+        Ee({ env: a }),
+        Me({ env: a })
+      ]), o = s.LBTC;
+      if (!(o != null && o.BTCTokenRatio) || !(o != null && o.tokenBTCRatio))
+        throw new Error("Exchange ratio data unavailable");
+      const n = String(o.BTCTokenRatio), i = String(o.tokenBTCRatio);
+      return {
+        lbtcToBtc: n,
+        btcToLbtc: i,
+        minStakeAmountBtc: oe(r.minAmount).toString(),
+        description: `1 LBTC = ${n} BTC. 1 BTC = ${i} LBTC. Min stake: ${oe(r.minAmount)} BTC.`
+      };
+    } catch (a) {
+      return {
+        lbtcToBtc: "",
+        btcToLbtc: "",
+        minStakeAmountBtc: "",
+        description: "",
+        error: a instanceof Error ? a.message : "Failed to fetch exchange rate"
+      };
+    }
+  }
+}, jt = {
+  name: "get_deposit_status",
+  description: "Check the status of all deposits for an address. Shows pending, claimable, and claimed deposits.",
+  parameters: g,
+  schema: p,
+  execute: async (t) => {
+    const { address: e, chainId: a } = p.parse(t), { env: s } = u(a), r = await he({
+      address: e,
+      env: s
+    });
+    return r.length === 0 ? { deposits: [], message: "No deposits found" } : {
+      totalDeposits: r.length,
+      deposits: r.map((o) => {
+        var d;
+        const n = me(o), i = fe(n);
+        return {
+          txHash: o.txHash,
+          amount: (d = o.amount) == null ? void 0 : d.toString(),
+          status: n,
+          statusLabel: i.label,
+          description: i.description,
+          requiresAction: i.requiresAction,
+          rawPayload: o.rawPayload || null,
+          proofSignature: o.proof || null
+        };
+      })
+    };
+  }
+}, Ht = {
+  name: "get_unstake_status",
+  description: "Check the status of all unstake/redeem operations for an address.",
+  parameters: g,
+  schema: p,
+  execute: async (t) => {
+    const { address: e, chainId: a } = p.parse(t), { env: s } = u(a), r = await Re({
+      address: e,
+      env: s
+    });
+    return r.length === 0 ? { unstakes: [], message: "No unstakes found" } : {
+      totalUnstakes: r.length,
+      unstakes: r.map((o) => {
+        var n;
+        return {
+          txHash: o.txHash,
+          amount: (n = o.amount) == null ? void 0 : n.toString(),
+          payoutStatus: o.payoutTxStatus,
+          payoutTxHash: o.payoutTxHash || null
+        };
+      })
+    };
+  }
+}, zt = {
+  name: "get_balance",
+  description: "Check both LBTC and BTC.b balances for a wallet on a given chain in a single call.",
+  parameters: et,
+  schema: U,
+  execute: async (t) => {
+    const { address: e, chainId: a } = U.parse(t), s = u(a), [r, o] = await Promise.all([
+      S(_.LBTC, e, a).catch(
+        (n) => n instanceof Error ? `error: ${n.message}` : "error"
+      ),
+      S(_.BTCb, e, a).catch(
+        (n) => n instanceof Error ? `error: ${n.message}` : "error"
+      )
+    ]);
+    return { lbtc: r, btcb: o, chain: s.name, address: e };
+  }
+}, M = [
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "decimals",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    name: "symbol",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  }
+], Yt = {
+  name: "get_token_info",
+  description: "Look up a Lombard-related asset by symbol, alias, or contract address. Returns the canonical name, description, decimals, and per-chain contract addresses. Use this whenever the user mentions a token you're not sure about (BTCe, LBTCv, etc.) before telling them you don't recognize it.",
+  parameters: dt,
+  schema: we,
+  execute: async (t) => {
+    const e = L.map((s) => s.symbol), a = (s) => {
+      const r = {};
+      for (const [o, n] of Object.entries(s.addresses))
+        n && (r[o] = n);
+      return {
+        symbol: s.symbol,
+        name: s.name,
+        description: s.description,
+        decimals: s.decimals,
+        isLombardIssued: s.isLombardIssued,
+        isYieldBearing: s.isYieldBearing,
+        addresses: r,
+        ...s.notes ? { notes: s.notes } : {}
+      };
+    };
+    if (t.address && typeof t.chainId == "number") {
+      const s = Ye(t.chainId, t.address);
+      return s ? {
+        found: !0,
+        asset: a(s),
+        note: `Address ${t.address} on chainId ${t.chainId} is ${s.symbol}.`
+      } : {
+        found: !1,
+        suggestions: e,
+        note: `Address ${t.address} on chainId ${t.chainId} is not a Lombard-issued asset.`
+      };
+    }
+    if (t.query) {
+      const s = ze(t.query);
+      return s ? {
+        found: !0,
+        asset: a(s),
+        note: `Resolved "${t.query}" to ${s.symbol}.`
+      } : {
+        found: !1,
+        suggestions: e,
+        note: `"${t.query}" is not a known Lombard asset. Known symbols: ${e.join(", ")}.`
+      };
+    }
+    return {
+      found: !1,
+      suggestions: e,
+      note: "Provide a `query` (symbol/name) or both `address` and `chainId`."
+    };
+  }
+}, Zt = {
+  name: "get_token_balance",
+  description: "Check the balance of any ERC-20 token for a wallet address. Requires the token contract address (0x...). Get addresses from other tool results (e.g. loanAsset.address from get_morpho_lbtc_markets). Reads symbol and decimals directly from the contract. Use this for tokens beyond LBTC and BTC.b.",
+  parameters: ct,
+  schema: Z,
+  execute: async (t) => {
+    const { tokenAddress: e, address: a, chainId: s } = Z.parse(t), r = u(s), o = X({
+      chainId: r.chainId,
+      env: r.env
+    });
+    try {
+      const [n, i, d] = await Promise.all([
+        o.readContract({
+          address: e,
+          abi: M,
+          functionName: "balanceOf",
+          args: [a]
+        }),
+        o.readContract({
+          address: e,
+          abi: M,
+          functionName: "decimals"
+        }),
+        o.readContract({
+          address: e,
+          abi: M,
+          functionName: "symbol"
+        })
+      ]);
+      return {
+        balance: v(n, i),
+        symbol: d,
+        tokenAddress: e,
+        chain: r.name
+      };
+    } catch (n) {
+      return {
+        balance: "",
+        symbol: "",
+        tokenAddress: e,
+        chain: r.name,
+        error: n instanceof Error ? n.message : "Failed to read token balance"
+      };
+    }
+  }
+}, Wt = {
+  name: "get_strategies",
+  description: "List available yield strategies where LBTC can be deployed for additional yield. Currently includes Bitcoin Earn (passive vault yield). Returns name, chain, APY, and TVL.",
+  parameters: tt,
+  schema: N,
+  // Vault data is mainnet-only regardless of chainId
+  execute: async (t) => {
+    const { chainId: e } = N.parse(t), a = m.prod;
+    try {
+      const [s, r] = await Promise.all([
+        Pe({ env: a }),
+        De({ env: a })
+      ]), o = s.length > 0 ? s[s.length - 1] : null;
+      return {
+        strategies: [
+          {
+            vault: "Bitcoin Earn",
+            chain: "Ethereum",
+            apy: o ? `${(parseFloat(String(o.apy)) * 100).toFixed(2)}%` : "N/A",
+            tvlBtc: r.btcBalance.toFixed(4)
+          }
+        ]
+      };
+    } catch {
+      return { strategies: [], error: "Unable to fetch vault data" };
+    }
+  }
+}, Kt = process.env.LOMBARD_BFF_URL || "https://bff.prod.lombard-fi.com", Gt = {
+  name: "get_opportunities",
+  description: "List LBTC and BTC.b DeFi opportunities across protocols and chains. Includes borrow-stables, looping, DEX LP, automated strategies, and more. Filter by category (borrow-stables, looping, dex-lp, automated-strategy, other), chain, or protocol.",
+  parameters: it,
+  schema: Y,
+  execute: async (t) => {
+    const { category: e, chain: a, protocol: s } = Y.parse(t);
+    try {
+      const r = [];
+      e && r.push(`category=${encodeURIComponent(e)}`), a && r.push(`chain=${encodeURIComponent(a)}`), s && r.push(`protocol=${encodeURIComponent(s)}`);
+      const o = r.length > 0 ? `?${r.join("&")}` : "", n = await fetch(`${Kt}/opportunities-api${o}`);
+      if (!n.ok)
+        throw new Error(`BFF returned ${n.status}`);
+      return {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        opportunities: (await n.json()).opportunities
+      };
+    } catch (r) {
+      return {
+        opportunities: [],
+        error: r instanceof Error ? r.message : "Failed to fetch opportunities"
+      };
+    }
+  }
+}, Jt = {
+  name: "get_deposit_btc_address",
+  description: "Get or generate a BTC deposit address for a wallet. Users send native BTC to this address to receive LBTC on the specified EVM chain. If no address exists yet, returns instructions to generate one (requires a wallet signature).",
+  parameters: at,
+  schema: q,
+  execute: async (t) => {
+    const { address: e, chainId: a } = q.parse(t), s = u(a);
+    try {
+      return {
+        btcAddress: await Fe({
+          address: e,
+          chainId: s.chainId,
+          env: s.env,
+          partnerId: Tt(s.env)
+        }),
+        chain: s.name,
+        note: "Send BTC to this address. Once confirmed and notarized, use get_deposit_status to track progress and claim your LBTC."
+      };
+    } catch {
+      return {
+        btcAddress: null,
+        chain: s.name,
+        action: "generate_deposit_address",
+        note: "No deposit address exists yet. To generate one, a wallet signature is required. Click the button below to sign and generate your BTC deposit address."
+      };
+    }
+  }
+}, Xt = {
+  name: "check_fee_authorization",
+  description: "Check if a valid fee authorization signature exists for staking. On Ethereum/Sepolia, fee auth (EIP-712) is required before generating a BTC deposit address. On other chains, an address confirmation is required instead.",
+  parameters: g,
+  schema: p,
+  execute: async (t) => {
+    const { address: e, chainId: a } = p.parse(t), s = u(a);
+    if (Ue(s.chainId))
+      try {
+        const o = await B(
+          Ne({
+            address: e,
+            chainId: s.chainId,
+            env: s.env
+          }),
+          1e4,
+          "getNetworkFeeSignature"
+        ), n = o.hasSignature && new Date(o.expirationDate).getTime() > Date.now();
+        return {
+          chain: s.name,
+          requiresFeeAuth: !0,
+          hasValidSignature: n,
+          expirationDate: o.hasSignature ? o.expirationDate : null,
+          note: n ? "Fee authorization is valid. Ready to generate deposit address." : "Fee authorization is needed before generating a deposit address."
+        };
+      } catch {
+        return {
+          chain: s.name,
+          requiresFeeAuth: !0,
+          hasValidSignature: !1,
+          expirationDate: null,
+          note: "Fee authorization is needed before generating a deposit address."
+        };
+      }
+    return {
+      chain: s.name,
+      requiresFeeAuth: !1,
+      hasValidSignature: !1,
+      expirationDate: null,
+      note: "This chain requires an address confirmation signature (not fee auth). The signing will happen when generating the deposit address."
+    };
+  }
+}, Qt = {
+  name: "prepare_btc_deposit",
+  description: "Prepare a native BTC -> LBTC deposit address. Use this when the user wants LBTC (yield-bearing). The wallet will prompt for fee authorization (Ethereum/Sepolia) or an address confirmation (other chains), then a unique BTC deposit address is generated.",
+  parameters: g,
+  schema: p,
+  execute: async (t) => {
+    const { address: e, chainId: a } = p.parse(t), s = u(a);
+    return {
+      action: "sdk_execute",
+      method: "btc.generateDepositAddress",
+      params: { address: e, chainId: s.chainId },
+      description: `Generate a BTC deposit address for ${e} on ${s.name}. The deposit will mint LBTC. Your wallet will prompt you to sign an authorization.`
+    };
+  }
+}, ea = {
+  name: "prepare_btc_to_btcb_deposit",
+  description: "Prepare a native BTC -> BTC.b deposit address. Use this when the user wants BTC.b (cross-chain wrapped Bitcoin, NOT yield-bearing). Distinct flow from prepare_btc_deposit (which produces LBTC). The wallet will prompt for the required authorization, then a unique BTC deposit address is generated that mints BTC.b on the destination EVM chain.",
+  parameters: g,
+  schema: p,
+  execute: async (t) => {
+    const { address: e, chainId: a } = p.parse(t), s = u(a);
+    return {
+      action: "sdk_execute",
+      method: "btc.generateBtcbDepositAddress",
+      params: { address: e, chainId: s.chainId },
+      description: `Generate a BTC -> BTC.b deposit address for ${e} on ${s.name}. The deposit will mint BTC.b on the destination EVM chain. Your wallet will prompt you to sign an authorization.`
+    };
+  }
+}, ta = {
+  name: "prepare_stake",
+  description: "Prepare a BTC.b → LBTC stake. Returns transaction parameters for the user's wallet to sign, or a validation failure listing what to ask the user for.",
+  parameters: Xe,
+  schema: D,
+  execute: async (t) => {
+    const e = D.safeParse(t);
+    if (!e.success)
+      return {
+        valid: !1,
+        missing: [],
+        errors: e.error.issues.map((n) => n.message),
+        note: "Surface the listed errors to the user and re-prompt with valid input."
+      };
+    const a = Bt(e.data);
+    if (!a.valid) return a;
+    const { amount: s, chainId: r } = e.data, o = u(r);
+    return {
+      valid: !0,
+      action: "sdk_execute",
+      method: "evm.stake",
+      params: {
+        amount: s,
+        chainId: o.chainId,
+        assetIn: "BTCb",
+        assetOut: "LBTC"
+      },
+      description: `Stake ${s} BTC.b to receive LBTC on ${o.name}`
+    };
+  }
+}, aa = {
+  name: "prepare_unstake",
+  description: "Prepare an LBTC unstake. When outputAsset is 'BTC', the user MUST supply a Bitcoin destination address — do not infer or fill it from prior context. Returns either prepared transaction parameters or a validation failure listing what to ask the user for.",
+  parameters: Qe,
+  schema: F,
+  execute: async (t) => {
+    const e = F.safeParse(t);
+    if (!e.success)
+      return {
+        valid: !1,
+        missing: [],
+        errors: e.error.issues.map((d) => d.message),
+        note: "Surface the listed errors to the user and re-prompt with valid input."
+      };
+    const a = wt(e.data);
+    if (!a.valid) return a;
+    const { amount: s, outputAsset: r, recipient: o, chainId: n } = e.data, i = u(n);
+    return {
+      valid: !0,
+      action: "sdk_execute",
+      method: "evm.unstake",
+      params: {
+        amount: s,
+        outputAsset: r,
+        recipient: o,
+        chainId: i.chainId
+      },
+      description: `Unstake ${s} LBTC to ${r} on ${i.name}`
+    };
+  }
+}, sa = {
+  name: "prepare_redeem_btcb",
+  description: "Prepare a redemption of BTC.b for native BTC. Distinct from prepare_unstake (which operates on LBTC). The user MUST supply a Bitcoin destination address — do not infer or fill it from prior context. Returns either prepared transaction parameters or a validation failure listing what to ask the user for.",
+  parameters: lt,
+  schema: H,
+  execute: async (t) => {
+    const e = H.safeParse(t);
+    if (!e.success)
+      return {
+        valid: !1,
+        missing: [],
+        errors: e.error.issues.map((i) => i.message),
+        note: "Surface the listed errors to the user and re-prompt with valid input."
+      };
+    const a = vt(e.data);
+    if (!a.valid) return a;
+    const { amount: s, recipient: r, chainId: o } = e.data, n = u(o);
+    return {
+      valid: !0,
+      action: "sdk_execute",
+      method: "evm.redeemBtcb",
+      params: {
+        amount: s,
+        recipient: r,
+        chainId: n.chainId
+      },
+      description: `Redeem ${s} BTC.b to native BTC on ${n.name}. Destination: ${r}.`
+    };
+  }
+}, ra = {
+  name: "prepare_deploy_to_vault",
+  description: "Prepare a transaction to deploy LBTC into Bitcoin Earn. Returns prepared transaction parameters or a validation failure.",
+  parameters: st,
+  schema: O,
+  execute: async (t) => {
+    const e = O.safeParse(t);
+    if (!e.success)
+      return {
+        valid: !1,
+        missing: [],
+        errors: e.error.issues.map((n) => n.message),
+        note: "Surface the listed errors to the user and re-prompt with valid input."
+      };
+    const a = Te(e.data);
+    if (!a.valid) return a;
+    const { amount: s, chainId: r } = e.data, o = u(r);
+    return {
+      valid: !0,
+      action: "sdk_execute",
+      method: "evm.deploy",
+      params: { amount: s, chainId: o.chainId, token: "LBTC" },
+      description: `Deploy ${s} LBTC to Bitcoin Earn on ${o.name}`
+    };
+  }
+}, oa = {
+  name: "prepare_vault_withdrawal",
+  description: "Prepare a withdrawal from Bitcoin Earn. Only one active withdrawal is allowed per user per vault — this tool checks first and refuses if one is already queued, returning its details so you can offer the user prepare_cancel_withdrawal. On success, returns prepared transaction parameters.",
+  parameters: ot,
+  schema: V,
+  execute: async (t) => {
+    const e = V.safeParse(t);
+    if (!e.success)
+      return {
+        valid: !1,
+        missing: [],
+        errors: e.error.issues.map((i) => i.message),
+        note: "Surface the listed errors to the user and re-prompt with valid input."
+      };
+    const a = Te(e.data);
+    if (!a.valid) return a;
+    const { amount: s, address: r, chainId: o } = e.data, n = u(o);
+    try {
+      const d = (await B(
+        be({
+          account: r,
+          chainId: n.chainId,
+          env: n.env
+        }),
+        15e3,
+        "getEarnWithdrawals"
+      )).open[0];
+      if (d)
+        return {
+          valid: !1,
+          missing: [],
+          errors: [
+            `An active withdrawal already exists for ${r} on ${n.name}: ${d.shareAmount.toString()} shares queued (request tx ${d.txHash}). Only one active withdrawal is allowed per vault.`
+          ],
+          note: `Tell the user about the existing withdrawal (shareAmount=${d.shareAmount.toString()}, txHash=${d.txHash}, deadline=${d.deadline}) and ask whether they want to cancel it via prepare_cancel_withdrawal before queuing a new one. Do not retry prepare_vault_withdrawal until they confirm.`
+        };
+    } catch (i) {
+      return {
+        valid: !1,
+        missing: [],
+        errors: [
+          i instanceof Error ? `Could not verify active withdrawals: ${i.message}` : "Could not verify active withdrawals."
+        ],
+        note: "The active-withdrawal check failed. Tell the user this is a backend issue, suggest they run get_vault_withdrawals manually to confirm no active withdrawal exists, and only proceed with prepare_vault_withdrawal after they confirm."
+      };
+    }
+    return {
+      valid: !0,
+      action: "sdk_execute",
+      method: "evm.withdrawFromVault",
+      params: { amount: s, chainId: n.chainId },
+      description: `Withdraw ${s} shares from Bitcoin Earn on ${n.name}. Withdrawals are queued and may take time to process.`
+    };
+  }
+}, na = {
+  name: "get_lbtc_apy",
+  description: "Get the current LBTC base staking APY (annual percentage yield). Returns both the base and effective APY for LBTC staking.",
+  parameters: rt,
+  schema: ge,
+  execute: async () => {
+    try {
+      const t = await B(
+        qe({ env: m.prod }),
+        1e4,
+        "getApy"
+      ), e = t.baseApy.multipliedBy(100).toFixed(2), a = t.effectiveApy.multipliedBy(100).toFixed(2);
+      return {
+        baseApy: t.baseApy.toString(),
+        effectiveApy: t.effectiveApy.toString(),
+        description: `LBTC base staking APY: ${e}%. Effective APY (with compounding/incentives): ${a}%.`
+      };
+    } catch (t) {
+      return {
+        baseApy: "",
+        effectiveApy: "",
+        description: "",
+        error: t instanceof Error ? t.message : "Failed to fetch LBTC APY"
+      };
+    }
+  }
+}, ia = {
+  name: "get_vault_positions",
+  description: "Get a user's Bitcoin Earn positions including shares held and their estimated LBTC value. Currently supports Bitcoin Earn on Ethereum mainnet.",
+  parameters: g,
+  schema: p,
+  execute: async (t) => {
+    const { address: e, chainId: a } = p.parse(t), s = u(a);
+    try {
+      const r = await B(
+        Oe({ address: e, chainId: s.chainId }),
+        1e4,
+        "getEarnPosition"
+      );
+      return {
+        shares: r.totalShares.toString(),
+        shareValue: r.exchangeRate.toString(),
+        estimatedLbtcValue: r.position.toString(),
+        vault: "Bitcoin Earn",
+        chain: s.name
+      };
+    } catch (r) {
+      return {
+        shares: "",
+        shareValue: "",
+        estimatedLbtcValue: "",
+        vault: "Bitcoin Earn",
+        chain: s.name,
+        error: r instanceof Error ? r.message : "Failed to fetch vault positions"
+      };
+    }
+  }
+}, ca = {
+  name: "prepare_claim_deposit",
+  description: "Prepare a transaction to claim (mint) LBTC from a notarized BTC deposit. Checks if the deposit is claimable and returns the transaction parameters for wallet signing.",
+  parameters: nt,
+  schema: j,
+  execute: async (t) => {
+    const { depositTxHash: e, address: a, chainId: s } = j.parse(t), r = u(s), n = (await he({
+      address: a,
+      env: r.env
+    })).find((d) => d.txHash === e);
+    if (!n)
+      return {
+        action: "error",
+        method: "",
+        params: {
+          depositTxHash: e,
+          rawPayload: "",
+          proofSignature: "",
+          chainId: r.chainId
+        },
+        description: "",
+        error: "Could not find a deposit with this transaction hash for the given address. Use get_deposit_status to verify the transaction hash."
+      };
+    const i = me(n);
+    if (i !== "claimable") {
+      const d = fe(i);
+      return {
+        action: "error",
+        method: "",
+        params: {
+          depositTxHash: e,
+          rawPayload: "",
+          proofSignature: "",
+          chainId: r.chainId
+        },
+        description: "",
+        error: `Deposit is not claimable. Current status: ${d.label}. ${d.description}`
+      };
+    }
+    return {
+      action: "sdk_execute",
+      method: "evm.claimDeposit",
+      params: {
+        depositTxHash: e,
+        rawPayload: n.rawPayload,
+        proofSignature: n.proof,
+        chainId: r.chainId
+      },
+      description: `Claim LBTC from deposit ${e.slice(0, 10)}... on ${r.name}. Your wallet will prompt you to sign the mint transaction.`
+    };
+  }
+}, da = {
+  name: "prepare_cancel_withdrawal",
+  description: "Cancel an active Bitcoin Earn withdrawal that has not yet been processed. Looks up the user's active withdrawal first; refuses if none exists, includes its details in the description if one does, then returns the cancel transaction parameters.",
+  parameters: Ge,
+  schema: z,
+  execute: async (t) => {
+    const e = z.safeParse(t);
+    if (!e.success)
+      return {
+        valid: !1,
+        missing: [],
+        errors: e.error.issues.map((n) => n.message),
+        note: "Surface the listed errors to the user and re-prompt with valid input."
+      };
+    const { address: a, chainId: s } = e.data, r = u(s);
+    let o = "";
+    try {
+      const i = (await B(
+        be({
+          account: a,
+          chainId: r.chainId,
+          env: r.env
+        }),
+        15e3,
+        "getEarnWithdrawals"
+      )).open[0];
+      if (!i)
+        return {
+          valid: !1,
+          missing: [],
+          errors: [
+            `No active withdrawal found for ${a} on ${r.name}. There is nothing to cancel.`
+          ],
+          note: "Tell the user there is no active withdrawal to cancel. If they think there should be, suggest get_vault_withdrawals to inspect their full withdrawal history."
+        };
+      o = ` Active withdrawal: ${i.shareAmount.toString()} shares (request tx ${i.txHash}, deadline ${i.deadline}).`;
+    } catch (n) {
+      return {
+        valid: !1,
+        missing: [],
+        errors: [
+          n instanceof Error ? `Could not verify active withdrawals before cancelling: ${n.message}` : "Could not verify active withdrawals before cancelling."
+        ],
+        note: "Backend issue. Ask the user to retry in a moment, or to verify via get_vault_withdrawals first."
+      };
+    }
+    return {
+      valid: !0,
+      action: "sdk_execute",
+      method: "evm.cancelWithdrawal",
+      params: { chainId: r.chainId },
+      description: `Cancel pending Bitcoin Earn withdrawal on ${r.name}.${o} Your wallet will prompt you to sign the cancellation transaction.`
+    };
+  }
+}, la = [
+  qt,
+  Ot,
+  zt,
+  Zt,
+  Yt,
+  Vt,
+  jt,
+  Ht,
+  Wt,
+  Gt,
+  Jt,
+  Xt,
+  Qt,
+  ea,
+  ta,
+  aa,
+  sa,
+  ra,
+  oa,
+  da,
+  na,
+  ia,
+  ca,
+  Pt,
+  Dt,
+  Ft,
+  Ut,
+  Nt
+], ya = Object.fromEntries(la.map((t) => [t.name, t]));
+export {
+  Jt as $,
+  g as A,
+  et as B,
+  We as C,
+  st as D,
+  Je as E,
+  Z as F,
+  dt as G,
+  we as H,
+  F as I,
+  V as J,
+  la as K,
+  ba as L,
+  ht as M,
+  y as N,
+  it as O,
+  Ze as P,
+  b as Q,
+  lt as R,
+  le as S,
+  ct as T,
+  Qe as U,
+  ot as V,
+  Xt as W,
+  f as X,
+  zt as Y,
+  Ot as Z,
+  u as _,
+  p as a,
+  jt as a0,
+  Vt as a1,
+  na as a2,
+  qt as a3,
+  Pt as a4,
+  Nt as a5,
+  Gt as a6,
+  Wt as a7,
+  Zt as a8,
+  Yt as a9,
+  Ht as aa,
+  ia as ab,
+  Qt as ac,
+  ea as ad,
+  da as ae,
+  ca as af,
+  ra as ag,
+  Ft as ah,
+  Ut as ai,
+  Dt as aj,
+  sa as ak,
+  ta as al,
+  aa as am,
+  oa as an,
+  Ye as ao,
+  ze as ap,
+  ya as aq,
+  U as b,
+  nt as c,
+  j as d,
+  O as e,
+  at as f,
+  q as g,
+  P as h,
+  L as i,
+  rt as j,
+  ge as k,
+  K as l,
+  ut as m,
+  Be as n,
+  ft as o,
+  J as p,
+  mt as q,
+  G as r,
+  pt as s,
+  W as t,
+  Y as u,
+  H as v,
+  Xe as w,
+  D as x,
+  tt as y,
+  N as z
+};