@continuumdao/ctm-mpc-defi 0.2.27 → 0.2.29

package/dist/agent/catalog.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var viem = require('viem');
+var api = require('@morpho-org/midnight-sdk/api');
 var zodToJsonSchema = require('zod-to-json-schema');
 var zod = require('zod');
 var module$1 = require('module');
@@ -9,10 +10,62 @@ var fs = require('fs');
 var path = require('path');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 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 });
+};
+
+// src/core/defiProxy.ts
+function getAaveGraphqlProxyUrl() {
+  return aaveGraphqlProxyUrl;
+}
+function getMorphoGraphqlProxyUrl() {
+  return morphoGraphqlProxyUrl;
+}
+async function postJsonViaOptionalProxy(args) {
+  const proxy = args.proxyUrl?.trim();
+  if (proxy) {
+    const r2 = await fetch(proxy, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(args.proxyEnvelope ?? args.body)
+    });
+    if (!r2.ok) {
+      const t = await r2.text().catch(() => "");
+      throw new Error(t ? `Proxy HTTP ${r2.status}: ${t.slice(0, 200)}` : `Proxy HTTP ${r2.status}`);
+    }
+    return await r2.json();
+  }
+  const r = await fetch(args.directUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(args.body)
+  });
+  if (!r.ok) {
+    const t = await r.text().catch(() => "");
+    throw new Error(t ? `HTTP ${r.status}: ${t.slice(0, 200)}` : `HTTP ${r.status}`);
+  }
+  return await r.json();
+}
+async function getJsonViaOptionalProxy(args) {
+  const url = args.directUrl;
+  const r = await fetch(url, { method: "GET", headers: { accept: "application/json" } });
+  if (!r.ok) {
+    const t = await r.text().catch(() => "");
+    throw new Error(t ? `HTTP ${r.status}: ${t.slice(0, 200)}` : `HTTP ${r.status}`);
+  }
+  return await r.json();
+}
+var aaveGraphqlProxyUrl, morphoGraphqlProxyUrl;
+var init_defiProxy = __esm({
+  "src/core/defiProxy.ts"() {
+  }
+});
 
 // src/protocols/evm/arcus/support.ts
 function isArcusChainSupported(chainId) {
@@ -39,6 +92,225 @@ var init_api = __esm({
   }
 });
 
+// src/protocols/evm/morpho/midnightConstants.ts
+var midnightConstants_exports = {};
+__export(midnightConstants_exports, {
+  MORPHO_MIDNIGHT_ADDRESSES: () => MORPHO_MIDNIGHT_ADDRESSES,
+  MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS: () => MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_BASE_CHAIN_ID: () => MORPHO_MIDNIGHT_BASE_CHAIN_ID,
+  MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT: () => MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT,
+  MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS: () => MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS: () => MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS,
+  MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT: () => MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT,
+  MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK: () => MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK,
+  MORPHO_MIDNIGHT_LEND_FALLBACK_GAS: () => MORPHO_MIDNIGHT_LEND_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS: () => MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_REST_BASE: () => MORPHO_MIDNIGHT_REST_BASE,
+  MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK: () => MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK,
+  TOKEN_PERMIT_NONE: () => TOKEN_PERMIT_NONE,
+  morphoMidnightAddressesForChain: () => morphoMidnightAddressesForChain
+});
+function morphoMidnightAddressesForChain(chainId) {
+  return MORPHO_MIDNIGHT_ADDRESSES[chainId] ?? null;
+}
+var MORPHO_MIDNIGHT_REST_BASE, MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT, MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT, MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS, MORPHO_MIDNIGHT_BASE_CHAIN_ID, MORPHO_MIDNIGHT_ADDRESSES, TOKEN_PERMIT_NONE, MORPHO_MIDNIGHT_LEND_FALLBACK_GAS, MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS, MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS, MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS, MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK, MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK;
+var init_midnightConstants = __esm({
+  "src/protocols/evm/morpho/midnightConstants.ts"() {
+    MORPHO_MIDNIGHT_REST_BASE = "https://api.morpho.org/v0/midnight";
+    MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT = 20;
+    MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT = "0.5";
+    MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS = 3600;
+    MORPHO_MIDNIGHT_BASE_CHAIN_ID = 8453;
+    MORPHO_MIDNIGHT_ADDRESSES = {
+      [MORPHO_MIDNIGHT_BASE_CHAIN_ID]: {
+        midnight: "0xadedd8ab6de832766fedf0fac4992e5c4d3ea18a",
+        bundles: "0x6688dEc8878f43905e11B3C6Bc025E098133144f"
+      }
+    };
+    TOKEN_PERMIT_NONE = { kind: 0, data: "0x" };
+    MORPHO_MIDNIGHT_LEND_FALLBACK_GAS = 2500000n;
+    MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS = 3000000n;
+    MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS = 2200000n;
+    MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS = 80000n;
+    MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK = 100000n;
+    MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK = 120000n;
+  }
+});
+
+// src/protocols/evm/morpho/midnightApi.ts
+var midnightApi_exports = {};
+__export(midnightApi_exports, {
+  fetchMorphoMidnightBook: () => fetchMorphoMidnightBook,
+  fetchMorphoMidnightBookQuote: () => fetchMorphoMidnightBookQuote,
+  fetchMorphoMidnightBooks: () => fetchMorphoMidnightBooks,
+  fetchMorphoMidnightMarketById: () => fetchMorphoMidnightMarketById,
+  fetchMorphoMidnightUserMarketPosition: () => fetchMorphoMidnightUserMarketPosition,
+  fetchMorphoMidnightUserPositions: () => fetchMorphoMidnightUserPositions,
+  morphoMidnightApiBaseUrl: () => morphoMidnightApiBaseUrl,
+  morphoMidnightBookToMarketParams: () => morphoMidnightBookToMarketParams,
+  morphoMidnightMarketToParams: () => morphoMidnightMarketToParams
+});
+function morphoMidnightApiBaseUrl() {
+  return MORPHO_MIDNIGHT_REST_BASE;
+}
+function midnightApiConfig() {
+  return { baseUrl: morphoMidnightApiBaseUrl() };
+}
+async function midnightGetJson(pathAndQuery) {
+  const path = pathAndQuery.startsWith("/") ? pathAndQuery : `/${pathAndQuery}`;
+  const directUrl = `${MORPHO_MIDNIGHT_REST_BASE}${path}`;
+  return getJsonViaOptionalProxy({ directUrl});
+}
+async function fetchMorphoMidnightBooks(args) {
+  const limit = args.limit == null ? void 0 : Math.min(Math.max(Math.floor(args.limit), 1), MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT);
+  const result = await api.MidnightApi.fetchBooks({
+    ...midnightApiConfig(),
+    chainIds: [args.chainId],
+    loanTokens: args.loanTokens?.filter((a) => viem.isAddress(a)).map((a) => viem.getAddress(a)),
+    collateralTokens: args.collateralTokens?.filter((a) => viem.isAddress(a)).map((a) => viem.getAddress(a)),
+    sort: args.sort ? [args.sort] : ["maturity"],
+    limit,
+    cursor: args.cursor
+  });
+  return { data: [...result.data], cursor: result.cursor ?? null };
+}
+async function fetchMorphoMidnightBook(marketId) {
+  const id = marketId.trim();
+  if (!id) return null;
+  try {
+    const result = await api.MidnightApi.fetchBook({
+      ...midnightApiConfig(),
+      marketId: id
+    });
+    return result.data;
+  } catch {
+    return null;
+  }
+}
+async function fetchMorphoMidnightBookQuote(args) {
+  const quote = await api.MidnightApi.fetchBookQuote({
+    ...midnightApiConfig(),
+    marketId: args.marketId.trim(),
+    side: args.side,
+    assets: args.assets,
+    slippage: args.slippage?.trim() || "0.5"
+  });
+  return quote.data;
+}
+async function fetchMorphoMidnightMarketById(marketId) {
+  const id = marketId.trim();
+  if (!id) return null;
+  const j = await midnightGetJson(`/markets/${encodeURIComponent(id)}`);
+  const d = j.data;
+  if (!d?.market_id || !d.loan_token || !viem.isAddress(d.loan_token)) return null;
+  const midnight = d.midnight && viem.isAddress(d.midnight) ? viem.getAddress(d.midnight) : "0x0000000000000000000000000000000000000000";
+  const collaterals = (d.collaterals ?? []).filter((c) => c.token && viem.isAddress(c.token) && c.oracle && viem.isAddress(c.oracle)).map((c) => ({
+    token: viem.getAddress(c.token),
+    lltv: String(c.lltv ?? "0"),
+    liquidationCursor: String(c.liquidation_cursor ?? "0"),
+    oracle: viem.getAddress(c.oracle)
+  }));
+  return {
+    chainId: Number(d.chain_id ?? 0),
+    marketId: d.market_id,
+    midnight,
+    loanToken: viem.getAddress(d.loan_token),
+    maturity: Number(d.maturity ?? 0),
+    rcfThreshold: String(d.rcf_threshold ?? "0"),
+    enterGate: d.enter_gate && viem.isAddress(d.enter_gate) ? viem.getAddress(d.enter_gate) : viem.getAddress("0x0000000000000000000000000000000000000000"),
+    liquidatorGate: d.liquidator_gate && viem.isAddress(d.liquidator_gate) ? viem.getAddress(d.liquidator_gate) : viem.getAddress("0x0000000000000000000000000000000000000000"),
+    collaterals
+  };
+}
+function morphoMidnightMarketToParams(row) {
+  return {
+    chainId: BigInt(row.chainId),
+    midnight: row.midnight,
+    loanToken: row.loanToken,
+    collateralParams: row.collaterals.map((c) => ({
+      token: c.token,
+      lltv: BigInt(c.lltv),
+      liquidationCursor: BigInt(c.liquidationCursor),
+      oracle: c.oracle
+    })),
+    maturity: BigInt(row.maturity),
+    rcfThreshold: BigInt(row.rcfThreshold),
+    enterGate: row.enterGate,
+    liquidatorGate: row.liquidatorGate
+  };
+}
+function morphoMidnightBookToMarketParams(book) {
+  return {
+    chainId: BigInt(book.chainId),
+    midnight: viem.getAddress(book.midnight),
+    loanToken: viem.getAddress(book.loanToken),
+    collateralParams: book.collaterals.map((c) => ({
+      token: viem.getAddress(c.token),
+      lltv: BigInt(c.lltv),
+      liquidationCursor: BigInt(c.liquidationCursor),
+      oracle: viem.getAddress(c.oracle)
+    })),
+    maturity: BigInt(book.maturity),
+    rcfThreshold: BigInt(book.rcfThreshold),
+    enterGate: viem.getAddress(book.enterGate),
+    liquidatorGate: viem.getAddress(book.liquidatorGate)
+  };
+}
+async function fetchMorphoMidnightUserPositions(args) {
+  const user = args.user.trim();
+  if (!viem.isAddress(user)) return [];
+  const qs = new URLSearchParams();
+  if (args.types) qs.set("types", args.types);
+  if (args.activeOnly) qs.set("active_only", "true");
+  const q = qs.toString();
+  const path = `/users/${encodeURIComponent(viem.getAddress(user))}/positions${q ? `?${q}` : ""}`;
+  const j = await midnightGetJson(path);
+  const rows = [];
+  for (const p of j.data ?? []) {
+    if (!p.market_id) continue;
+    rows.push({
+      marketId: p.market_id,
+      type: p.type ?? "lend",
+      credit: String(p.credit ?? "0"),
+      debt: String(p.debt ?? "0"),
+      pendingFee: String(p.pending_fee ?? "0"),
+      lossFactor: String(p.loss_factor ?? "0"),
+      costBasis: p.cost_basis ?? null,
+      effectiveRateWad: p.effective_rate_wad ?? null,
+      maturity: p.maturity != null ? Number(p.maturity) : null,
+      loanToken: p.loan_token && viem.isAddress(p.loan_token) ? viem.getAddress(p.loan_token) : null,
+      collaterals: (p.collaterals ?? []).filter((c) => c.token && viem.isAddress(c.token)).map((c) => ({ token: viem.getAddress(c.token), amount: String(c.amount ?? "0") }))
+    });
+  }
+  return rows;
+}
+async function fetchMorphoMidnightUserMarketPosition(args) {
+  const marketId = args.marketId.trim();
+  const user = args.user.trim();
+  if (!marketId || !viem.isAddress(user)) return null;
+  const path = `/markets/${encodeURIComponent(marketId)}/users/${encodeURIComponent(viem.getAddress(user))}/position`;
+  const j = await midnightGetJson(path);
+  const p = j.data;
+  if (!p) return null;
+  return {
+    marketId,
+    type: p.type ?? "borrow",
+    credit: String(p.credit ?? "0"),
+    debt: String(p.debt ?? "0"),
+    pendingFee: String(p.pending_fee ?? "0"),
+    lossFactor: String(p.loss_factor ?? "0"),
+    maturity: p.maturity != null ? Number(p.maturity) : null,
+    loanToken: p.loan_token && viem.isAddress(p.loan_token) ? viem.getAddress(p.loan_token) : null,
+    collaterals: (p.collaterals ?? []).filter((c) => c.token && viem.isAddress(c.token)).map((c) => ({ token: viem.getAddress(c.token), amount: String(c.amount ?? "0") }))
+  };
+}
+var init_midnightApi = __esm({
+  "src/protocols/evm/morpho/midnightApi.ts"() {
+    init_defiProxy();
+    init_midnightConstants();
+  }
+});
+
 // src/core/registry.ts
 var modules = [];
 function registerProtocolModule(mod) {
@@ -121,41 +393,6 @@ function isUniswapV4ChainSupported(chainId) {
   return typeof a === "string" && a.startsWith("0x");
 }
 
-// src/core/defiProxy.ts
-var aaveGraphqlProxyUrl;
-var morphoGraphqlProxyUrl;
-function getAaveGraphqlProxyUrl() {
-  return aaveGraphqlProxyUrl;
-}
-function getMorphoGraphqlProxyUrl() {
-  return morphoGraphqlProxyUrl;
-}
-async function postJsonViaOptionalProxy(args) {
-  const proxy = args.proxyUrl?.trim();
-  if (proxy) {
-    const r2 = await fetch(proxy, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(args.proxyEnvelope ?? args.body)
-    });
-    if (!r2.ok) {
-      const t = await r2.text().catch(() => "");
-      throw new Error(t ? `Proxy HTTP ${r2.status}: ${t.slice(0, 200)}` : `Proxy HTTP ${r2.status}`);
-    }
-    return await r2.json();
-  }
-  const r = await fetch(args.directUrl, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(args.body)
-  });
-  if (!r.ok) {
-    const t = await r.text().catch(() => "");
-    throw new Error(t ? `HTTP ${r.status}: ${t.slice(0, 200)}` : `HTTP ${r.status}`);
-  }
-  return await r.json();
-}
-
 // src/protocols/evm/uniswap-v4/index.ts
 var UNISWAP_V4_PROTOCOL_ID = "uniswap-v4";
 var uniswapV4ProtocolModule = {
@@ -1135,11 +1372,15 @@ var mcpUniswapV4LpCreatePositionInputSchema = zod.z.preprocess(
 );
 var mcpUniswapV4LpListPoolsInputSchema = zod.z.object({
   chainId: agentEvmChainIdSchema,
-  pair: zod.z.string().optional().describe("Optional filter, e.g. eth-usdc or ETH/USDC")
+  pair: zod.z.string().optional().describe("Optional filter, e.g. eth-usdc or ETH/USDC"),
+  permissioned: agentOptionalBooleanSchema().describe(
+    "When true, list Permissioned Position Manager pools (adapter currency + PermissionedHooks)"
+  )
 });
 var mcpUniswapV4LpListPoolsOutputSchema = zod.z.object({
   chainId: zod.z.number().int().positive(),
   chainLabel: zod.z.string(),
+  positionManagerKind: zod.z.enum(["standard", "permissioned"]).optional(),
   pools: zod.z.array(
     zod.z.object({
       presetId: zod.z.string(),
@@ -1155,7 +1396,12 @@ var mcpUniswapV4LpListPoolsOutputSchema = zod.z.object({
       poolReference: zod.z.string(),
       hooks: evmAddressSchema,
       nativeWrapped: evmAddressSchema.optional(),
-      usesNativeEth: zod.z.boolean()
+      usesNativeEth: zod.z.boolean(),
+      positionManagerKind: zod.z.enum(["standard", "permissioned"]).optional(),
+      positionManager: evmAddressSchema.optional(),
+      adapterAddress: evmAddressSchema.optional(),
+      underlyingPermissionedToken: evmAddressSchema.optional(),
+      issuer: zod.z.string().optional()
     })
   ),
   notes: zod.z.string()
@@ -1237,7 +1483,9 @@ var mcpUniswapV4RegisterPositionFromMintTxOutputSchema = zod.z.object({
 var lpBuildCommonSchema = {
   lpResponse: jsonObjectSchema.describe("Full LP API response (create/increase/decrease/claim)"),
   nativeWrapped: evmAddressSchema.optional(),
-  poolReference: zod.z.string().optional()
+  poolReference: zod.z.string().optional(),
+  positionManagerKind: zod.z.enum(["standard", "permissioned"]).optional().describe("permissioned \u2192 Permit2 approve path + Permissioned Position Manager"),
+  usePermit2Approvals: agentOptionalBooleanSchema()
 };
 var mcpUniswapV4BuildMintLiquidityMultisignInputSchema = withMultisignKeySourceRefine(
   zod.z.preprocess(preprocessUniswapBuildLpInput, evmMultisignCommonInputSchema.extend(lpBuildCommonSchema))
@@ -1331,6 +1579,61 @@ var mcpUniswapV4FetchOhlcvOutputSchema = zod.z.object({
   fetchedAtMs: zod.z.number(),
   warnings: zod.z.array(zod.z.string()).optional()
 }).strict();
+var mcpUniswapV4CheckPermissionsInputSchema = zod.z.object({
+  walletAddress: evmAddressSchema.optional(),
+  keyGen: zod.z.string().optional().describe("Resolves wallet via GET /getKeyGenResultById when walletAddress omitted"),
+  managementNodeUrl: zod.z.string().optional(),
+  tokens: zod.z.array(zod.z.string().min(1)).min(1).max(2).describe("Up to two token addresses"),
+  chainId: agentEvmChainIdSchema,
+  uniswapApiKey: zod.z.string().min(1),
+  baseUrl: zod.z.string().optional()
+});
+var mcpUniswapV4CheckPermissionsOutputSchema = zod.z.object({
+  requestId: zod.z.string().optional(),
+  results: zod.z.array(
+    zod.z.object({
+      token: evmAddressSchema,
+      isPermissioned: zod.z.boolean(),
+      isAllowlisted: zod.z.boolean(),
+      adapterTokenAddress: evmAddressSchema.optional(),
+      kycUrl: zod.z.string().optional(),
+      issuer: zod.z.string().optional()
+    })
+  ),
+  anyPermissioned: zod.z.boolean(),
+  allAllowlisted: zod.z.boolean(),
+  requiresUniversalRouterV22: zod.z.boolean()
+});
+var mcpUniswapV4KycApplyLinkInputSchema = zod.z.object({
+  walletAddress: evmAddressSchema,
+  chainId: agentEvmChainIdSchema,
+  kycUrl: zod.z.string().min(1),
+  issuer: zod.z.string().optional(),
+  token: evmAddressSchema.optional(),
+  adapterTokenAddress: evmAddressSchema.optional()
+});
+var mcpUniswapV4KycApplyLinkOutputSchema = zod.z.object({
+  walletAddress: evmAddressSchema,
+  chainId: zod.z.number().int(),
+  issuer: zod.z.string().optional(),
+  kycUrl: zod.z.string(),
+  applyUrl: zod.z.string(),
+  token: evmAddressSchema.optional(),
+  adapterTokenAddress: evmAddressSchema.optional()
+});
+var mcpUniswapV4BuildAllowlistFinalizeMultisignInputSchema = withMultisignKeySourceRefine(
+  zod.z.preprocess(
+    preprocessUniswapBuildSwapInput,
+    evmMultisignCommonInputSchema.extend({
+      to: evmAddressSchema.describe("Allowlist contract from issuer onboard API"),
+      data: zod.z.string().min(1).describe("ABI-encoded calldata (encodedTransaction)"),
+      valueWei: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+      issuer: zod.z.string().optional(),
+      entityId: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+      tokenAddress: evmAddressSchema.optional()
+    })
+  )
+);
 var mcpCurveDaoQuoteInputSchema = zod.z.object({
   chainId: agentEvmChainIdSchema.describe("EVM chain id (rpcUrl resolved from get_chain_registry rpcGateway)"),
   rpcUrl: zod.z.string().min(1).optional().describe("JSON-RPC URL; continuum-mcp-server injects from chain registry \u2014 do not pass a public RPC URL"),
@@ -1501,6 +1804,116 @@ var mcpMorphoFetchBlueMarketsOutputSchema = zod.z.object({
     })
   )
 });
+function preprocessMorphoMidnightLendInput(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const o = { ...raw };
+  const purposeText = String(o.purposeText ?? o.purpose ?? "").trim();
+  if (!purposeText) {
+    const amt = String(o.amountHuman ?? "").trim();
+    if (amt) o.purposeText = `Morpho Midnight lend ${amt}`;
+  }
+  return o;
+}
+function preprocessMorphoMidnightBorrowInput(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const o = { ...raw };
+  if (o.collateralTokenAddress != null && o.collateralToken == null) {
+    o.collateralToken = o.collateralTokenAddress;
+  }
+  if (o.loanTokenAddress != null && o.loanToken == null) {
+    o.loanToken = o.loanTokenAddress;
+  }
+  if (o.borrowAmountHuman == null && o.amountHuman != null) {
+    o.borrowAmountHuman = o.amountHuman;
+  }
+  const purposeText = String(o.purposeText ?? o.purpose ?? "").trim();
+  if (!purposeText) {
+    const amt = String(o.borrowAmountHuman ?? o.amountHuman ?? "").trim();
+    if (amt) o.purposeText = `Morpho Midnight borrow ${amt}`;
+  }
+  return o;
+}
+function preprocessMorphoMidnightRepayInput(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const o = { ...raw };
+  const purposeText = String(o.purposeText ?? o.purpose ?? "").trim();
+  if (!purposeText) o.purposeText = "Morpho Midnight repay";
+  return o;
+}
+var mcpMorphoFetchMidnightBooksInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  loan: zod.z.string().trim().min(1).optional().describe("Loan token address filter."),
+  collateral: zod.z.string().trim().min(1).optional().describe("Collateral token address filter."),
+  query: zod.z.string().trim().min(1).optional().describe("Filter on marketId or addresses."),
+  side: zod.z.enum(["bids", "asks", "either"]).optional().describe("Require bid depth (borrow) or ask depth (lend)."),
+  limit: agentCoercedOptionalIntSchema(zod.z.number().int().min(1).max(200))
+});
+var mcpMorphoFetchMidnightBooksOutputSchema = zod.z.object({
+  books: zod.z.array(
+    zod.z.object({
+      marketId: zod.z.string().describe("Pass to Midnight quote / lend / borrow / repay tools"),
+      chainId: zod.z.number().int(),
+      midnightAddress: zod.z.string(),
+      loanTokenAddress: zod.z.string(),
+      maturity: zod.z.number(),
+      maturityIso: zod.z.string(),
+      collateralTokenAddresses: zod.z.array(zod.z.string()),
+      primaryCollateralTokenAddress: zod.z.string().nullable(),
+      primaryCollateralLltv: zod.z.string().nullable(),
+      bestAskPriceWad: zod.z.string().nullable(),
+      bestBidPriceWad: zod.z.string().nullable(),
+      bestAskAssets: zod.z.string().nullable(),
+      bestBidAssets: zod.z.string().nullable(),
+      lendApr: zod.z.string(),
+      borrowApr: zod.z.string(),
+      lendAprNumeric: zod.z.number().nullable(),
+      borrowAprNumeric: zod.z.number().nullable(),
+      marketLabel: zod.z.string()
+    })
+  )
+});
+var mcpMorphoFetchMidnightQuoteInputSchema = zod.z.object({
+  marketId: zod.z.string().min(1).describe("marketId from ctm_morpho_fetch_midnight_books"),
+  side: zod.z.enum(["asks", "bids"]).describe("asks = lend; bids = borrow"),
+  assets: zod.z.string().min(1).describe("Target loan-token amount in raw units (wei/base units), e.g. 10000000 for 10 USDC."),
+  slippagePct: zod.z.string().optional().describe('Slippage percent string, default "0.5".')
+});
+var mcpMorphoFetchMidnightQuoteOutputSchema = zod.z.object({
+  marketId: zod.z.string(),
+  side: zod.z.enum(["asks", "bids"]),
+  averageBestPriceWad: zod.z.string(),
+  averageWorstPriceWad: zod.z.string(),
+  availableAssets: zod.z.string(),
+  availableUnits: zod.z.string(),
+  impliedApr: zod.z.string(),
+  impliedAprNumeric: zod.z.number().nullable(),
+  maturity: zod.z.number().nullable(),
+  takeableOfferCount: zod.z.number().int()
+});
+var mcpMorphoFetchMidnightPositionsInputSchema = zod.z.object({
+  user: zod.z.string().min(1).describe("User EVM address"),
+  types: zod.z.enum(["lend", "borrow", "collateral_only"]).optional(),
+  activeOnly: zod.z.boolean().optional()
+});
+var mcpMorphoFetchMidnightPositionsOutputSchema = zod.z.object({
+  positions: zod.z.array(
+    zod.z.object({
+      marketId: zod.z.string(),
+      type: zod.z.string(),
+      credit: zod.z.string(),
+      debt: zod.z.string(),
+      pendingFee: zod.z.string(),
+      repayAssets: zod.z.string(),
+      maturity: zod.z.number().nullable(),
+      maturityIso: zod.z.string(),
+      loanTokenAddress: zod.z.string().nullable(),
+      collateralTokenAddresses: zod.z.array(zod.z.string()),
+      collateralAmounts: zod.z.array(zod.z.object({ token: zod.z.string(), amount: zod.z.string() })),
+      effectiveRate: zod.z.string(),
+      costBasis: zod.z.string().nullable()
+    })
+  )
+});
 var mcpServerCommonInputSchema = zod.z.object({
   keyGenId: zod.z.string().min(1).describe("KeyGen id from fetch_key_gen_result / node preferred KeyGen"),
   chainId: zod.z.number().int().positive().describe("EVM chain id; RPC and gas config resolved from chain registry"),
@@ -1524,7 +1937,9 @@ var MCP_NON_SUBMIT_TOOL_NAMES = /* @__PURE__ */ new Set([
   "ctm_uniswap_v4_quote",
   "ctm_uniswap_v4_create_swap",
   "ctm_uniswap_v4_limit_order_quote",
-  "ctm_uniswap_v4_fetch_limit_orders"
+  "ctm_uniswap_v4_fetch_limit_orders",
+  "ctm_uniswap_v4_check_permissions",
+  "ctm_uniswap_v4_kyc_apply_link"
 ]);
 
 // src/agent/schemas/protocols.ts
@@ -1849,6 +2264,47 @@ var mcpMorphoMerklClaimInputSchema = mcpMultisignInput({
   distributor: evmAddressSchema.optional(),
   valueWei: zod.z.string().optional()
 });
+var mcpMorphoMidnightLendInputSchema = withMultisignKeySourceRefine(
+  zod.z.preprocess(
+    preprocessMorphoMidnightLendInput,
+    evmMultisignCommonInputSchema.extend({
+      marketId: zod.z.string().min(1).describe("marketId from ctm_morpho_fetch_midnight_books"),
+      amountHuman: zod.z.string().min(1).describe("Loan-token amount to lend (human units)"),
+      loanToken: evmAddressSchema.optional().describe("loanTokenAddress from fetch row"),
+      slippagePct: zod.z.string().optional().describe("Default 0.5"),
+      marketLabel: zod.z.string().optional(),
+      isNativeIn: agentOptionalBooleanSchema()
+    })
+  )
+);
+var mcpMorphoMidnightBorrowInputSchema = withMultisignKeySourceRefine(
+  zod.z.preprocess(
+    preprocessMorphoMidnightBorrowInput,
+    evmMultisignCommonInputSchema.extend({
+      marketId: zod.z.string().min(1).describe("marketId from ctm_morpho_fetch_midnight_books"),
+      borrowAmountHuman: zod.z.string().min(1).describe("Loan-token amount to borrow"),
+      collateralAmountHuman: zod.z.string().min(1).describe("Collateral to supply in the same tx"),
+      collateralToken: evmAddressSchema.describe("primaryCollateralTokenAddress from fetch row"),
+      loanToken: evmAddressSchema.optional(),
+      collateralIndex: agentCoercedOptionalIntSchema(zod.z.number().int().min(0).max(127)),
+      slippagePct: zod.z.string().optional(),
+      marketLabel: zod.z.string().optional(),
+      isNativeIn: agentOptionalBooleanSchema()
+    })
+  )
+);
+var mcpMorphoMidnightRepayInputSchema = withMultisignKeySourceRefine(
+  zod.z.preprocess(
+    preprocessMorphoMidnightRepayInput,
+    evmMultisignCommonInputSchema.extend({
+      marketId: zod.z.string().min(1).describe("marketId from ctm_morpho_fetch_midnight_positions"),
+      repayAmountHuman: zod.z.string().optional().describe("Optional; default debt+fee+buffer"),
+      loanToken: evmAddressSchema.optional(),
+      withdrawAllCollateral: agentOptionalBooleanSchema(),
+      marketLabel: zod.z.string().optional()
+    })
+  )
+);
 var mcpEulerV2FetchLendVaultsInputSchema = zod.z.object({
   chainId: agentEvmChainIdSchema,
   underlyingAddress: evmAddressSchema.describe(
@@ -3145,6 +3601,43 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoMerklDistributorClaim" },
     inputZod: mcpMorphoMerklClaimInputSchema
   }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_midnight_lend_multisign",
+    actionId: "morpho.midnight-lend",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Build Morpho Midnight fixed-rate lend batch (approve + authorize bundles + take asks via MidnightBundles).",
+    prerequisites: ["keyGenId", "chainId", "marketId from ctm_morpho_fetch_midnight_books", "amountHuman"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoMidnightLendBatch" },
+    inputZod: mcpMorphoMidnightLendInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_midnight_borrow_multisign",
+    actionId: "morpho.midnight-borrow",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Build Morpho Midnight fixed-rate borrow batch (approve collateral + authorize + supply collateral and take bids).",
+    prerequisites: [
+      "keyGenId",
+      "chainId",
+      "marketId",
+      "borrowAmountHuman",
+      "collateralAmountHuman",
+      "collateralToken"
+    ],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoMidnightBorrowBatch" },
+    inputZod: mcpMorphoMidnightBorrowInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_midnight_repay_multisign",
+    actionId: "morpho.midnight-repay",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Build Morpho Midnight repay + withdraw collateral batch (full exit at/after maturity).",
+    prerequisites: ["keyGenId", "chainId", "marketId from ctm_morpho_fetch_midnight_positions"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoMidnightRepayBatch" },
+    inputZod: mcpMorphoMidnightRepayInputSchema
+  }),
   defineProtocolMcpTool({
     name: "ctm_gmx_build_increase_multisign",
     actionId: "gmx.increase",
@@ -3596,15 +4089,60 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     inputZod: mcpUniswapV4FetchLimitOrdersInputSchema,
     outputZod: mcpUniswapV4FetchLimitOrdersOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_uniswap_v4_check_permissions",
+    actionId: "uniswap-v4.check-permissions",
+    protocolId: "uniswap-v4",
+    chainCategory: "evm",
+    description: "Check Uniswap Trade API POST /v1/permissions for up to two tokens. Returns isPermissioned, isAllowlisted, kycUrl, issuer, and whether UR 2.2.0 is required. Call before swap/LP submit on tokenized pools.",
+    prerequisites: ["UNISWAP_API_KEY", "walletAddress or keyGenId", "tokens[]", "chainId"],
+    followUp: [
+      "ctm_uniswap_v4_kyc_apply_link",
+      "ctm_uniswap_v4_quote",
+      "ctm_uniswap_v4_build_allowlist_finalize_multisign"
+    ],
+    handler: { importPath: "protocols/evm/uniswap-v4", exportName: "uniswapV4CheckPermissionsMcp" },
+    inputZod: mcpUniswapV4CheckPermissionsInputSchema,
+    outputZod: mcpUniswapV4CheckPermissionsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_uniswap_v4_kyc_apply_link",
+    actionId: "uniswap-v4.kyc-apply-link",
+    protocolId: "uniswap-v4",
+    chainCategory: "evm",
+    description: "Build an issuer KYC apply URL with KeyGen wallet / chain / token query params (no sign request). Use when check_permissions returns isAllowlisted=false and kycUrl.",
+    prerequisites: ["walletAddress", "chainId", "kycUrl from check_permissions"],
+    followUp: ["ctm_uniswap_v4_check_permissions"],
+    handler: { importPath: "protocols/evm/uniswap-v4", exportName: "uniswapV4KycApplyLinkMcp" },
+    inputZod: mcpUniswapV4KycApplyLinkInputSchema,
+    outputZod: mcpUniswapV4KycApplyLinkOutputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_uniswap_v4_build_allowlist_finalize_multisign",
+    actionId: "uniswap-v4.allowlist-finalize",
+    protocolId: "uniswap-v4",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest to broadcast issuer-prepared allowlist calldata (e.g. Superstate setUserPermissionForInstrument). Requires partner onboard API {to, data}. No PII \u2014 KYC stays at issuer kycUrl.",
+    prerequisites: [
+      "Issuer onboard/add-allowlist response with to + encodedTransaction",
+      "keyGenId + chainId + purposeText"
+    ],
+    followUp: ["ctm_uniswap_v4_check_permissions", ...MCP_MULTISIGN_SUBMIT_FOLLOW_UP],
+    handler: {
+      importPath: "protocols/evm/uniswap-v4",
+      exportName: "buildEvmMultisignBodyUniswapV4PermissionedAllowlistFinalize"
+    },
+    inputZod: mcpUniswapV4BuildAllowlistFinalizeMultisignInputSchema
+  }),
   defineMcpTool({
     name: "ctm_uniswap_v4_list_lp_pools",
     actionId: "uniswap-v4.lp-list-pools",
     protocolId: "uniswap-v4",
     chainCategory: "evm",
-    description: "List standard Uniswap V4 LP pools for a chain (ETH/USDC and other main pairs at common fee tiers). Returns presetId, token addresses, fee, tickSpacing, and computed poolReference (bytes32 pool id). Use presetId as poolPreset on lp_create_position.",
+    description: "List Uniswap V4 LP pools for a chain. Default: standard no-hook ETH/USDC presets. Set permissioned=true for Permissioned Position Manager catalog (adapter currency + PermissionedHooks). Returns presetId, poolReference, hooks.",
     prerequisites: ["chainId"],
-    followUp: ["ctm_uniswap_v4_lp_create_position", "ctm_uniswap_v4_fetch_ohlcv"],
-    handler: { importPath: "protocols/evm/uniswap-v4", exportName: "uniswapV4ListStandardLpPools" },
+    followUp: ["ctm_uniswap_v4_lp_create_position", "ctm_uniswap_v4_fetch_ohlcv", "ctm_uniswap_v4_check_permissions"],
+    handler: { importPath: "protocols/evm/uniswap-v4", exportName: "uniswapV4ListLpPools" },
     inputZod: mcpUniswapV4LpListPoolsInputSchema,
     outputZod: mcpUniswapV4LpListPoolsOutputSchema
   }),
@@ -3645,8 +4183,12 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     actionId: "uniswap-v4.mint-liquidity",
     protocolId: "uniswap-v4",
     chainCategory: "evm",
-    description: "Create and submit mpc-auth multiSignRequest for minting a Uniswap V4 LP position. Batches ERC-20 approve(s) + Position Manager tx from LP create response.",
-    prerequisites: ["ctm_uniswap_v4_lp_create_position output", "keyGenId + chainId + purposeText"],
+    description: "Create and submit mpc-auth multiSignRequest for minting a Uniswap V4 LP position. Standard: ERC-20 approve + Position Manager. Permissioned (positionManagerKind=permissioned): ERC-20\u2192Permit2 + Permit2\u2192PermPosM + mint. Requires LIQUIDITY_ALLOWED.",
+    prerequisites: [
+      "ctm_uniswap_v4_lp_create_position output",
+      "keyGenId + chainId + purposeText",
+      "For permissioned: check_permissions with LIQUIDITY allowlist"
+    ],
     followUp: [
       ...MCP_MULTISIGN_SUBMIT_FOLLOW_UP,
       "After broadcast: ctm_uniswap_v4_register_position_from_mint_tx (mint tx hash)"
@@ -4215,6 +4757,46 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     inputZod: mcpMorphoFetchBlueMarketsInputSchema,
     outputZod: mcpMorphoFetchBlueMarketsOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_morpho_fetch_midnight_books",
+    actionId: "morpho.fetch-midnight-books",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Morpho Midnight fixed-rate books (order books). Filter by loan/collateral; returns marketId, maturity, and implied lend/borrow APR for Midnight multisign tools.",
+    prerequisites: ["chainId"],
+    followUp: [
+      "ctm_morpho_fetch_midnight_quote",
+      "ctm_morpho_build_midnight_lend_multisign",
+      "ctm_morpho_build_midnight_borrow_multisign"
+    ],
+    handler: { importPath: "protocols/evm/morpho", exportName: "morphoFetchMidnightBooksSummary" },
+    inputZod: mcpMorphoFetchMidnightBooksInputSchema,
+    outputZod: mcpMorphoFetchMidnightBooksOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_morpho_fetch_midnight_quote",
+    actionId: "morpho.fetch-midnight-quote",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Quote a Morpho Midnight book fill. side asks = lend, bids = borrow. assets is raw loan-token units.",
+    prerequisites: ["marketId from ctm_morpho_fetch_midnight_books", "assets raw amount"],
+    followUp: ["ctm_morpho_build_midnight_lend_multisign", "ctm_morpho_build_midnight_borrow_multisign"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "morphoFetchMidnightQuoteSummary" },
+    inputZod: mcpMorphoFetchMidnightQuoteInputSchema,
+    outputZod: mcpMorphoFetchMidnightQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_morpho_fetch_midnight_positions",
+    actionId: "morpho.fetch-midnight-positions",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Morpho Midnight positions for a user (lend/borrow). Use marketId for repay.",
+    prerequisites: ["user address"],
+    followUp: ["ctm_morpho_build_midnight_repay_multisign"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "morphoFetchMidnightPositionsSummary" },
+    inputZod: mcpMorphoFetchMidnightPositionsInputSchema,
+    outputZod: mcpMorphoFetchMidnightPositionsOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_euler_v2_fetch_lend_vaults",
     actionId: "euler-v2.fetch-lend-vaults",
@@ -4406,14 +4988,22 @@ function getAgentCatalogForMcp() {
     }
   };
 }
-viem.getAddress(
+var LIDO_STETH_CONTRACT_MAINNET = viem.getAddress(
   "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84"
 );
-viem.getAddress(
+var LIDO_WSTETH_CONTRACT_MAINNET = viem.getAddress(
   "0x7f39C581F595B853cBbF37C12FfeeA971C5a5bEa"
 );
 viem.getAddress("0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1");
 var LIDO_ETHEREUM_MAINNET_CHAIN_ID = 1;
+var LIDO_ROBINHOOD_CHAIN_ID = 4663;
+var LIDO_WSTETH_ROBINHOOD = viem.getAddress("0x2dC99af320BC317c567f24eE95811dcbd5983DfD");
+function listLidoSupportedChainIds() {
+  return [LIDO_ETHEREUM_MAINNET_CHAIN_ID, LIDO_ROBINHOOD_CHAIN_ID];
+}
+function isLidoSupportedChainId(chainId) {
+  return chainId === LIDO_ETHEREUM_MAINNET_CHAIN_ID || chainId === LIDO_ROBINHOOD_CHAIN_ID;
+}
 
 // src/protocols/evm/lido/index.ts
 var LIDO_PROTOCOL_ID = "lido";
@@ -4422,7 +5012,7 @@ var lidoProtocolModule = {
   chainCategory: "evm",
   isChainSupported(ctx) {
     if (ctx.chainCategory !== "evm") return false;
-    return Number(ctx.chainId) === LIDO_ETHEREUM_MAINNET_CHAIN_ID;
+    return isLidoSupportedChainId(Number(ctx.chainId));
   },
   isTokenSupported(token) {
     return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
@@ -4439,7 +5029,9 @@ registerProtocolModule(lidoProtocolModule);
 var USDE_ETHEREUM_MAINNET = "0x4c9edd5852cd905f086c759e8383e09bff1e68b3";
 var SUSDE_ETHEREUM_MAINNET = "0x9d39a5de30e57443bff2a8307a4256c8797a3497";
 var USDE_MOST_L2S = "0x5d3a1Ff2b6BAb83b63cd9AD0787074081a52ef34";
+var SUSDE_MOST_L2S = "0x211Cc4DD073734dA055fbF44a2b4667d5E5fE5d2";
 var USDE_ZKSYNC_ERA = "0x39Fe7a0DACcE31Bd90418e3e659fb0b5f0B3Db0d";
+var SUSDE_ZKSYNC_ERA = "0xAD17Da2f6Ac76746EF261E835C50b2651ce36DA8";
 var L2_SAME_ADDRESS_CHAIN_IDS = /* @__PURE__ */ new Set([
   42161,
   // Arbitrum One
@@ -4475,8 +5067,10 @@ var L2_SAME_ADDRESS_CHAIN_IDS = /* @__PURE__ */ new Set([
   // Morph
   1923,
   // Swell
-  48900
+  48900,
   // Zircuit
+  4663
+  // Robinhood Chain
 ]);
 var FALLBACK_NAME_BY_ID = {
   1: "Ethereum",
@@ -4498,6 +5092,7 @@ var FALLBACK_NAME_BY_ID = {
   2818: "Morph",
   1923: "Swell",
   48900: "Zircuit",
+  4663: "Robinhood Chain",
   324: "ZKSync Era"
 };
 function usdeTokenAddressOnEvmChain(chainId) {
@@ -4508,17 +5103,28 @@ function usdeTokenAddressOnEvmChain(chainId) {
 }
 function listEthenaUsdeEvmNetworkRows() {
   const rows = [
-    { chainId: 1, label: FALLBACK_NAME_BY_ID[1], usde: USDE_ETHEREUM_MAINNET }
+    {
+      chainId: 1,
+      label: FALLBACK_NAME_BY_ID[1],
+      usde: USDE_ETHEREUM_MAINNET,
+      susde: SUSDE_ETHEREUM_MAINNET
+    }
   ];
   const l2 = [...L2_SAME_ADDRESS_CHAIN_IDS].sort((a, b) => a - b);
   for (const id of l2) {
     rows.push({
       chainId: id,
       label: FALLBACK_NAME_BY_ID[id] ?? `Chain ${id}`,
-      usde: USDE_MOST_L2S
+      usde: USDE_MOST_L2S,
+      susde: SUSDE_MOST_L2S
     });
   }
-  rows.push({ chainId: 324, label: FALLBACK_NAME_BY_ID[324], usde: USDE_ZKSYNC_ERA });
+  rows.push({
+    chainId: 324,
+    label: FALLBACK_NAME_BY_ID[324],
+    usde: USDE_ZKSYNC_ERA,
+    susde: SUSDE_ZKSYNC_ERA
+  });
   return rows.sort((a, b) => {
     if (a.chainId === 1) return -1;
     if (b.chainId === 1) return 1;
@@ -4601,6 +5207,9 @@ var skyProtocolModule = {
   ]
 };
 registerProtocolModule(skyProtocolModule);
+
+// src/protocols/evm/aave-v4/api.ts
+init_defiProxy();
 var AAVE_V4_GRAPHQL_URL = "https://api.v4.aave.com/graphql";
 async function aaveV4Gql(query, variables) {
   const body = { query, variables: variables ?? {} };
@@ -5250,6 +5859,9 @@ var arcusProtocolModule = {
   ]
 };
 registerProtocolModule(arcusProtocolModule);
+
+// src/protocols/evm/morpho/api.ts
+init_defiProxy();
 var MORPHO_GRAPHQL_URL = "https://api.morpho.org/graphql";
 async function morphoGql(query, variables) {
   const body = { query, variables: variables ?? {} };
@@ -5390,12 +6002,40 @@ async function ensureMorphoChainAssetCache(chainId) {
       modes.set(k, prev);
     }
   }
+  try {
+    const { fetchMorphoMidnightBooks: fetchMorphoMidnightBooks2 } = await Promise.resolve().then(() => (init_midnightApi(), midnightApi_exports));
+    const { MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT: MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT2 } = await Promise.resolve().then(() => (init_midnightConstants(), midnightConstants_exports));
+    const { data: books } = await fetchMorphoMidnightBooks2({
+      chainId,
+      limit: MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT2
+    });
+    for (const book of books) {
+      const loanAddr = (book.loanToken ?? "").toString().trim();
+      if (viem.isAddress(loanAddr)) {
+        const k = viem.getAddress(loanAddr).toLowerCase();
+        const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+        prev.borrow = true;
+        modes.set(k, prev);
+      }
+      for (const c of book.collaterals ?? []) {
+        const colAddr = (c.token ?? "").toString().trim();
+        if (!viem.isAddress(colAddr)) continue;
+        const k = viem.getAddress(colAddr).toLowerCase();
+        const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+        prev.collateral = true;
+        modes.set(k, prev);
+      }
+    }
+  } catch {
+  }
   const cache = { modesByUnderlying: modes, nativeWrapped: null };
   chainAssetCache.set(chainId, cache);
   return cache;
 }
 
 // src/protocols/evm/morpho/index.ts
+init_midnightConstants();
+init_midnightApi();
 var MORPHO_PROTOCOL_ID = "morpho";
 var morphoProtocolModule = {
   id: MORPHO_PROTOCOL_ID,
@@ -5415,7 +6055,12 @@ var morphoProtocolModule = {
     { id: "morpho.blue-repay", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Repay Morpho Blue borrow", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
     { id: "morpho.blue-collateral-withdraw", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Withdraw Morpho Blue collateral", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
     { id: "morpho.merkl-claim", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Claim Morpho Merkl rewards", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
-    { id: "morpho.midnight-borrow", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight fixed-rate borrow (coming soon)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+    { id: "morpho.fetch-midnight-books", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "List Morpho Midnight fixed-rate books", commonParams: [], params: {} },
+    { id: "morpho.fetch-midnight-quote", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Quote Morpho Midnight lend/borrow fill", commonParams: [], params: {} },
+    { id: "morpho.fetch-midnight-positions", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "List Morpho Midnight user positions", commonParams: [], params: {} },
+    { id: "morpho.midnight-lend", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight fixed-rate lend (take asks)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.midnight-borrow", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight fixed-rate borrow (supply collateral + take bids)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.midnight-repay", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight repay debt and withdraw collateral", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
   ]
 };
 registerProtocolModule(morphoProtocolModule);
@@ -5882,17 +6527,26 @@ var PROTOCOL_SUPPORT_ADVISORS = {
   }),
   lido: advisor("lido", "mainnet_only", {
     async supportedChainIds() {
-      return [LIDO_ETHEREUM_MAINNET_CHAIN_ID];
+      return listLidoSupportedChainIds();
     },
-    async supportedTokens() {
-      return {
-        tokens: [
-          { address: "0x0000000000000000000000000000000000000000", symbol: "ETH", roles: ["native", "stake"] },
-          { address: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84", symbol: "stETH", roles: ["erc20"] },
-          { address: "0x7f39C581F595B853cBbF37C12FfeeA971C5a5bEa", symbol: "wstETH", roles: ["erc20"] }
-        ],
-        notes: "Lido staking and withdrawals are Ethereum mainnet only."
-      };
+    async supportedTokens(chainId) {
+      if (chainId === LIDO_ETHEREUM_MAINNET_CHAIN_ID) {
+        return {
+          tokens: [
+            { address: "0x0000000000000000000000000000000000000000", symbol: "ETH", roles: ["native", "stake"] },
+            { address: LIDO_STETH_CONTRACT_MAINNET, symbol: "stETH", roles: ["erc20"] },
+            { address: LIDO_WSTETH_CONTRACT_MAINNET, symbol: "wstETH", roles: ["erc20"] }
+          ],
+          notes: "Lido staking, withdrawals, and wrap/unwrap are Ethereum mainnet only."
+        };
+      }
+      if (chainId === LIDO_ROBINHOOD_CHAIN_ID) {
+        return {
+          tokens: [{ address: LIDO_WSTETH_ROBINHOOD, symbol: "wstETH", roles: ["erc20"] }],
+          notes: "Bridged wstETH on Robinhood Chain (CCIP). Stake/withdraw/wrap MCP tools remain mainnet-only."
+        };
+      }
+      return { tokens: [] };
     }
   }),
   ethena: advisor("ethena", "minting_contract", {
@@ -5906,14 +6560,17 @@ var PROTOCOL_SUPPORT_ADVISORS = {
             { address: USDE_ETHEREUM_MAINNET, symbol: "USDe", roles: ["stake"] },
             { address: SUSDE_ETHEREUM_MAINNET, symbol: "sUSDe", roles: ["vault"] }
           ],
-          notes: "Ethena stake/redeem UI actions are mainnet-only; USDe exists on other chains for transfers."
+          notes: "Ethena stake/redeem UI actions are mainnet-only; USDe/sUSDe exist on other chains for transfers."
         };
       }
       if (isEvmChainInEthenaUsdeList(chainId)) {
         const row = listEthenaUsdeEvmNetworkRows().find((r) => r.chainId === chainId);
         return {
-          tokens: row ? [{ address: row.usde, symbol: "USDe", roles: ["erc20"] }] : [],
-          notes: "USDe on L2; staking MCP tools target mainnet only."
+          tokens: row ? [
+            { address: row.usde, symbol: "USDe", roles: ["erc20"] },
+            { address: row.susde, symbol: "sUSDe", roles: ["erc20"] }
+          ] : [],
+          notes: "USDe/sUSDe on L2 (incl. Robinhood Chain); staking MCP tools target mainnet only."
         };
       }
       return { tokens: [] };
@@ -5936,7 +6593,7 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       }));
       return {
         tokens,
-        notes: chainId === ROBINHOOD_CHAIN_ID ? 'Morpho vault assets on Robinhood Chain. Robinhood Earn USDG yield uses Steakhouse USDG (steakUSDG) \u2014 query "robinhood earn" or robinhoodEarn: true on deposit multisign; not Arcus collateral.' : "Morpho vault assets and Blue market loan/collateral tokens from api.morpho.org."
+        notes: chainId === ROBINHOOD_CHAIN_ID ? 'Morpho vault assets on Robinhood Chain. Robinhood Earn USDG yield uses Steakhouse USDG (steakUSDG) \u2014 query "robinhood earn" or robinhoodEarn: true on deposit multisign; not Arcus collateral.' : "Morpho vault assets, Blue market loan/collateral tokens, and Midnight book loan/collateral tokens from api.morpho.org."
       };
     },
     async isTokenSupported(chainId, address) {
@@ -6259,7 +6916,16 @@ exports.mcpMorphoFetchBlueMarketsInputSchema = mcpMorphoFetchBlueMarketsInputSch
 exports.mcpMorphoFetchBlueMarketsOutputSchema = mcpMorphoFetchBlueMarketsOutputSchema;
 exports.mcpMorphoFetchEarnVaultsInputSchema = mcpMorphoFetchEarnVaultsInputSchema;
 exports.mcpMorphoFetchEarnVaultsOutputSchema = mcpMorphoFetchEarnVaultsOutputSchema;
+exports.mcpMorphoFetchMidnightBooksInputSchema = mcpMorphoFetchMidnightBooksInputSchema;
+exports.mcpMorphoFetchMidnightBooksOutputSchema = mcpMorphoFetchMidnightBooksOutputSchema;
+exports.mcpMorphoFetchMidnightPositionsInputSchema = mcpMorphoFetchMidnightPositionsInputSchema;
+exports.mcpMorphoFetchMidnightPositionsOutputSchema = mcpMorphoFetchMidnightPositionsOutputSchema;
+exports.mcpMorphoFetchMidnightQuoteInputSchema = mcpMorphoFetchMidnightQuoteInputSchema;
+exports.mcpMorphoFetchMidnightQuoteOutputSchema = mcpMorphoFetchMidnightQuoteOutputSchema;
 exports.mcpMorphoMerklClaimInputSchema = mcpMorphoMerklClaimInputSchema;
+exports.mcpMorphoMidnightBorrowInputSchema = mcpMorphoMidnightBorrowInputSchema;
+exports.mcpMorphoMidnightLendInputSchema = mcpMorphoMidnightLendInputSchema;
+exports.mcpMorphoMidnightRepayInputSchema = mcpMorphoMidnightRepayInputSchema;
 exports.mcpMorphoVaultDepositInputSchema = mcpMorphoVaultDepositInputSchema;
 exports.mcpMorphoVaultWithdrawInputSchema = mcpMorphoVaultWithdrawInputSchema;
 exports.mcpMultisignInput = mcpMultisignInput;
@@ -6275,18 +6941,23 @@ exports.mcpSkyLockstakeStakeInputSchema = mcpSkyLockstakeStakeInputSchema;
 exports.mcpSkyLockstakeWipeInputSchema = mcpSkyLockstakeWipeInputSchema;
 exports.mcpSkySusdsDepositInputSchema = mcpSkySusdsDepositInputSchema;
 exports.mcpSkySusdsRedeemInputSchema = mcpSkySusdsRedeemInputSchema;
+exports.mcpUniswapV4BuildAllowlistFinalizeMultisignInputSchema = mcpUniswapV4BuildAllowlistFinalizeMultisignInputSchema;
 exports.mcpUniswapV4BuildCollectFeesMultisignInputSchema = mcpUniswapV4BuildCollectFeesMultisignInputSchema;
 exports.mcpUniswapV4BuildDecreaseLiquidityMultisignInputSchema = mcpUniswapV4BuildDecreaseLiquidityMultisignInputSchema;
 exports.mcpUniswapV4BuildIncreaseLiquidityMultisignInputSchema = mcpUniswapV4BuildIncreaseLiquidityMultisignInputSchema;
 exports.mcpUniswapV4BuildLimitOrderMultisignInputSchema = mcpUniswapV4BuildLimitOrderMultisignInputSchema;
 exports.mcpUniswapV4BuildMintLiquidityMultisignInputSchema = mcpUniswapV4BuildMintLiquidityMultisignInputSchema;
 exports.mcpUniswapV4BuildSwapMultisignInputSchema = mcpUniswapV4BuildSwapMultisignInputSchema;
+exports.mcpUniswapV4CheckPermissionsInputSchema = mcpUniswapV4CheckPermissionsInputSchema;
+exports.mcpUniswapV4CheckPermissionsOutputSchema = mcpUniswapV4CheckPermissionsOutputSchema;
 exports.mcpUniswapV4CreateSwapInputSchema = mcpUniswapV4CreateSwapInputSchema;
 exports.mcpUniswapV4CreateSwapOutputSchema = mcpUniswapV4CreateSwapOutputSchema;
 exports.mcpUniswapV4FetchLimitOrdersInputSchema = mcpUniswapV4FetchLimitOrdersInputSchema;
 exports.mcpUniswapV4FetchLimitOrdersOutputSchema = mcpUniswapV4FetchLimitOrdersOutputSchema;
 exports.mcpUniswapV4FetchOhlcvInputSchema = mcpUniswapV4FetchOhlcvInputSchema;
 exports.mcpUniswapV4FetchOhlcvOutputSchema = mcpUniswapV4FetchOhlcvOutputSchema;
+exports.mcpUniswapV4KycApplyLinkInputSchema = mcpUniswapV4KycApplyLinkInputSchema;
+exports.mcpUniswapV4KycApplyLinkOutputSchema = mcpUniswapV4KycApplyLinkOutputSchema;
 exports.mcpUniswapV4LimitOrderQuoteInputSchema = mcpUniswapV4LimitOrderQuoteInputSchema;
 exports.mcpUniswapV4LimitOrderQuoteOutputSchema = mcpUniswapV4LimitOrderQuoteOutputSchema;
 exports.mcpUniswapV4LpClaimInputSchema = mcpUniswapV4LpClaimInputSchema;