@continuumdao/ctm-mpc-defi 0.1.4 → 0.2.1

package/dist/protocols/evm/aave-v4/index.cjs

@@ -0,0 +1,1710 @@
+'use strict';
+
+var viem = require('viem');
+var continuumNodeSdk = require('@continuumdao/continuum-node-sdk');
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+var AAVE_V4_GRAPHQL_URL = "https://api.v4.aave.com/graphql";
+async function aaveV4Gql(query, variables) {
+  const r = await fetch(AAVE_V4_GRAPHQL_URL, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ query, variables: variables ?? {} })
+  });
+  if (!r.ok) {
+    const t = await r.text().catch(() => "");
+    throw new Error(t ? `Aave V4 API HTTP ${r.status}: ${t.slice(0, 200)}` : `Aave V4 API HTTP ${r.status}`);
+  }
+  const j = await r.json();
+  if (j.errors?.length) {
+    const msg = j.errors.map((e) => e.message ?? "Unknown").join("; ");
+    throw new Error(msg);
+  }
+  if (j.data == null) {
+    throw new Error("Aave V4 API: empty response");
+  }
+  return j.data;
+}
+async function fetchAaveV4Chains() {
+  const d = await aaveV4Gql(`
+    query C($c: ChainsRequest!) { chains(request: $c) { chainId name nativeWrappedToken } }
+  `, { c: { query: { filter: "ALL" } } });
+  return d.chains ?? [];
+}
+async function loadAaveV4SupportedChainIdsFromV4Api() {
+  const rows = await fetchAaveV4Chains();
+  const s = /* @__PURE__ */ new Set();
+  for (const c of rows) s.add(c.chainId);
+  return s;
+}
+var RESERVES_ADDRESS_FRAGMENT = `
+  asset { underlying { address } }
+`;
+function aggregateV4SupplyDisplay(symbolForDisplay, rows) {
+  const sym = (symbolForDisplay ?? "").trim();
+  const withSuffix = (n) => n === "\u2014" ? "\u2014" : sym ? `${n} ${sym}` : n;
+  if (!rows.length) {
+    return { depositedAmount: "\u2014", apy: "\u2014", totalDeposits: "\u2014", availableLiquidity: "\u2014" };
+  }
+  const apy = formatV4SupplyApy(rows);
+  const sumKey = (key) => sumNumberValues(
+    rows.map((r) => {
+      const v = key === "supplied" ? r.summary?.supplied?.amount : r.summary?.borrowed?.amount;
+      return (v?.value ?? "").trim();
+    })
+  );
+  const totalSupN = sumKey("supplied");
+  const totalBorN = sumKey("borrowed");
+  const totalDeposits = totalSupN == null ? "\u2014" : withSuffix(formatAaveV4TokenAmount(totalSupN));
+  const availableLiquidity = (() => {
+    if (totalSupN == null || totalBorN == null) return "\u2014";
+    const a = totalSupN - totalBorN;
+    if (!Number.isFinite(a)) return "\u2014";
+    return withSuffix(formatAaveV4TokenAmount(a < 0 ? 0 : a));
+  })();
+  const userN = userSupplyBalanceNumber(rows);
+  const depositedAmount = userN == null ? "\u2014" : withSuffix(formatAaveV4TokenAmount(userN));
+  return { depositedAmount, apy, totalDeposits, availableLiquidity };
+}
+function sumNumberValues(values) {
+  if (!values.length) return null;
+  let s = 0;
+  for (const v of values) {
+    const n = parseFloat(v);
+    if (Number.isFinite(n)) s += n;
+  }
+  return s;
+}
+function formatAaveV4TokenAmount(n) {
+  if (!Number.isFinite(n)) return "\u2014";
+  if (n === 0) return "0";
+  const sign = n < 0 ? "-" : "";
+  const a = Math.abs(n);
+  const strip = (s) => s.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
+  if (a >= 1e6) {
+    return sign + strip((a / 1e6).toFixed(2)) + "M";
+  }
+  if (a >= 1e3) {
+    const k = a / 1e3;
+    const d = k >= 100 ? 1 : 2;
+    return sign + strip(k.toFixed(d)) + "k";
+  }
+  if (a >= 1) {
+    return sign + strip(a.toFixed(2));
+  }
+  if (a >= 1e-4) {
+    return sign + strip(a.toFixed(4));
+  }
+  return sign + a.toExponential(2);
+}
+function formatAaveV4AmountHumanFromApiString(raw) {
+  const s = (raw ?? "").trim();
+  if (!s) return "\u2014";
+  const n = parseFloat(s);
+  if (!Number.isFinite(n)) return "\u2014";
+  return formatAaveV4TokenAmount(n);
+}
+function formatAaveV4ReserveLiquidityFromSummary(args) {
+  const a = parseFloat(String(args.suppliedValue ?? "").trim());
+  const b = parseFloat(String(args.borrowedValue ?? "").trim());
+  if (!Number.isFinite(a) || !Number.isFinite(b)) return "\u2014";
+  return formatAaveV4TokenAmount(Math.max(0, a - b));
+}
+function userSupplyBalanceNumber(rows) {
+  const vals = rows.map((r) => (r.userState?.balance?.amount?.value ?? "").trim()).filter((v) => v.length > 0);
+  if (!vals.length) return null;
+  const u = new Set(vals);
+  if (u.size === 1) {
+    const n = parseFloat(vals[0]);
+    return Number.isFinite(n) ? n : null;
+  }
+  const sum = vals.reduce((acc, b) => acc + (parseFloat(b) || 0), 0);
+  return Number.isFinite(sum) ? sum : null;
+}
+function formatV4SupplyApy(rows) {
+  if (!rows.length) return "\u2014";
+  const weighted = [];
+  for (const r of rows) {
+    const sup = parseFloat((r.summary?.supplied?.amount?.value ?? "").trim());
+    const norm = (r.summary?.supplyApy?.normalized ?? "").trim();
+    const n2 = parseFloat(norm);
+    if (Number.isFinite(n2) && Number.isFinite(sup) && sup > 0) {
+      weighted.push({ w: sup, apy: n2 });
+    }
+  }
+  if (weighted.length) {
+    const tw = weighted.reduce((a, x) => a + x.w, 0);
+    if (tw > 0) {
+      const x = weighted.reduce((a, x2) => a + x2.w * x2.apy, 0) / tw;
+      if (x >= 0.01) return `${x.toFixed(2)}%`;
+      if (x > 0) return `${x.toFixed(4)}%`;
+      return "0%";
+    }
+  }
+  const any = (rows[0]?.summary?.supplyApy?.normalized ?? "").trim();
+  const n = parseFloat(any);
+  if (!Number.isFinite(n)) return "\u2014";
+  if (n >= 0.01) return `${n.toFixed(2)}%`;
+  if (n > 0) return `${n.toFixed(4)}%`;
+  return "0%";
+}
+async function fetchAaveV4NativeWrappedToken(chainId) {
+  const all = await fetchAaveV4Chains();
+  const c = all.find((x) => x.chainId === chainId);
+  const t = (c?.nativeWrappedToken ?? "").trim();
+  if (t && viem.isAddress(t)) return viem.getAddress(t);
+  return null;
+}
+async function fetchAaveV4SupportedUnderlyingAddressSet(chainId) {
+  const d = await aaveV4Gql(
+    `
+    query A($r: ReservesRequest!) { reserves(request: $r) { ${RESERVES_ADDRESS_FRAGMENT} } }
+  `,
+    {
+      r: {
+        query: { chainIds: [chainId] },
+        filter: "ALL",
+        orderBy: { supplyApy: "DESC" }
+      }
+    }
+  );
+  const s = /* @__PURE__ */ new Set();
+  for (const r of d.reserves ?? []) {
+    const a = (r.asset?.underlying?.address ?? "").trim();
+    if (a && viem.isAddress(a)) s.add(a.toLowerCase());
+  }
+  return s;
+}
+function erc20Input(address, chainId) {
+  return { address, chainId };
+}
+async function fetchAaveV4ReservesForUnderlying(args) {
+  const d = await aaveV4Gql(
+    `
+    query S($r: ReservesRequest!) {
+      reserves(request: $r) {
+        id
+        onChainId
+        spoke { address name liquidationConfig { targetHealthFactor healthFactorForMaxBonus } }
+        summary {
+          supplied { amount { value decimals } }
+          borrowed { amount { value decimals } }
+          suppliable { amount { value decimals } }
+          supplyApy { normalized value }
+        }
+        userState {
+          balance { amount { value decimals } }
+          borrowable { amount { value decimals } }
+        }
+      }
+    }
+  `,
+    {
+      r: {
+        query: { tokens: [erc20Input(args.underlying, args.chainId)] },
+        filter: "ALL",
+        orderBy: { supplyApy: "DESC" },
+        ...args.user ? { user: args.user } : {}
+      }
+    }
+  );
+  return d.reserves ?? [];
+}
+function pickAaveV4ReserveRowForSpoke(rows, spokeAddress) {
+  const want = viem.getAddress(spokeAddress).toLowerCase();
+  for (const r of rows) {
+    const a = (r.spoke?.address ?? "").trim();
+    if (!a) continue;
+    try {
+      if (viem.getAddress(a).toLowerCase() === want) return r;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function aaveV4KeyForNodeAssetRow(args) {
+  const raw = (args.contractAddress ?? "").trim();
+  try {
+    const a = viem.getAddress(raw);
+    if (a.toLowerCase() === "0x0000000000000000000000000000000000000000" && args.nativeWrapped) {
+      return viem.getAddress(args.nativeWrapped.trim()).toLowerCase();
+    }
+    return a.toLowerCase();
+  } catch {
+    return null;
+  }
+}
+var aaveV4ChainTokenCache = /* @__PURE__ */ new Map();
+function ensureAaveV4ChainTokenCache(chainId) {
+  const hit = aaveV4ChainTokenCache.get(chainId);
+  if (hit) return hit;
+  const p = (async () => {
+    const [nativeWrapped, supportedUnderlying] = await Promise.all([
+      fetchAaveV4NativeWrappedToken(chainId),
+      fetchAaveV4SupportedUnderlyingAddressSet(chainId)
+    ]);
+    return { supportedUnderlying, nativeWrapped };
+  })();
+  aaveV4ChainTokenCache.set(chainId, p);
+  return p;
+}
+var aaveV4HubsByChain = /* @__PURE__ */ new Map();
+var aaveV4HubReserves = /* @__PURE__ */ new Map();
+function hubReservesKey(chainId, hub) {
+  return `v3spoke+summary:${chainId}:${hub.toLowerCase()}`;
+}
+async function fetchAaveV4HubsForChain(chainId) {
+  const hit = aaveV4HubsByChain.get(chainId);
+  if (hit) return hit;
+  const p = (async () => {
+    const d = await aaveV4Gql(
+      `query F($h: HubsRequest!) { hubs(request: $h) { name address chain { chainId name } } }`,
+      { h: { query: { chainIds: [chainId] } } }
+    );
+    const out = (d.hubs ?? []).map((h) => ({
+      name: h.name,
+      address: viem.getAddress((h.address ?? "").trim()),
+      chain: h.chain
+    }));
+    return out;
+  })();
+  aaveV4HubsByChain.set(chainId, p);
+  return p;
+}
+function resolveAaveV4HubForUiMarket(hubs, market, chainId) {
+  const on = hubs.filter((h) => h.chain.chainId === chainId);
+  if (!on.length) return null;
+  const find = (names) => {
+    const set = new Set(names.map((n) => n.toLowerCase()));
+    return on.find((h) => set.has((h.name ?? "").trim().toLowerCase())) ?? null;
+  };
+  if (market === "core") return find(["core"]);
+  if (market === "bluechip") return find(["prime", "bluechip", "institutional"]);
+  return find(["plus", "main", "default"]) ?? on[0] ?? null;
+}
+function aaveV4UiMarketIdForHubName(hubName) {
+  const n = (hubName ?? "").trim().toLowerCase();
+  if (n === "core") return "core";
+  if (n === "plus" || n === "main" || n === "default") return "main";
+  if (n === "prime" || n === "bluechip" || n === "institutional") return "bluechip";
+  return "main";
+}
+function aaveV4HubAutoPickTiebreakOrder(a, b) {
+  const rank = (name) => {
+    const n = (name ?? "").trim().toLowerCase();
+    if (n === "core") return 0;
+    if (n === "plus" || n === "main" || n === "default") return 1;
+    if (n === "prime" || n === "bluechip" || n === "institutional") return 2;
+    return 3;
+  };
+  const ra = rank(a.name);
+  const rb = rank(b.name);
+  if (ra !== rb) return ra - rb;
+  return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+}
+function aaveV4HubReserveBorrowApyForSort(r) {
+  if (!r) return Number.POSITIVE_INFINITY;
+  const norm = parseFloat((r.summary?.borrowApy?.normalized ?? "").trim());
+  if (Number.isFinite(norm) && norm >= 0) return norm;
+  const v = parseFloat((r.summary?.borrowApy?.value ?? "").trim());
+  if (Number.isFinite(v) && v >= 0) {
+    if (v > 0 && v <= 1) return v * 100;
+    return v;
+  }
+  return Number.POSITIVE_INFINITY;
+}
+function aaveV4SuppliableHumanFromHubReserve(r) {
+  if (!r) return null;
+  const n = parseFloat((r.summary?.suppliable?.amount?.value ?? "").trim());
+  return Number.isFinite(n) && n >= 0 ? n : null;
+}
+async function findAaveV4HubReserveForChainUnderlying(args) {
+  const onChain = args.hubs.filter((h) => h.chain.chainId === args.chainId);
+  if (!onChain.length) return null;
+  const prefer = viem.getAddress(args.preferHub.address);
+  const order = (() => {
+    const rest = onChain.filter((h) => viem.getAddress(h.address) !== prefer).sort(aaveV4HubAutoPickTiebreakOrder);
+    const first = onChain.find((h) => viem.getAddress(h.address) === prefer);
+    return first ? [first, ...rest] : rest;
+  })();
+  const candidates = [];
+  for (const h of order) {
+    const rows = await fetchAaveV4HubReserves({ chainId: args.chainId, hubAddress: h.address });
+    const c = findHubReserveForUnderlying(rows, args.underlying);
+    if (c) candidates.push({ hub: h, hubReserves: rows, reserve: c });
+  }
+  if (!candidates.length) return null;
+  const noDebt = () => candidates[0];
+  const rawDebt = (args.debtUnderlying ?? "").trim();
+  if (!rawDebt || !viem.isAddress(rawDebt)) {
+    return noDebt();
+  }
+  const debtU = viem.getAddress(rawDebt);
+  const withDebt = candidates.map((c) => {
+    const dr = findHubReserveForUnderlying(c.hubReserves, debtU);
+    return { ...c, debtReserve: dr };
+  }).filter(
+    (x2) => x2.debtReserve != null && x2.debtReserve.canBorrow === true && x2.debtReserve.settings?.borrowable === true
+  );
+  if (!withDebt.length) {
+    return noDebt();
+  }
+  const amountRaw = (args.debtBorrowAmountHumanForLiquidity ?? "").trim().replace(/,/g, "");
+  const wantN = amountRaw && parseFloat(amountRaw) > 0 ? parseFloat(amountRaw) : null;
+  const sortKey = (a, b) => {
+    const d = aaveV4HubReserveBorrowApyForSort(a.debtReserve) - aaveV4HubReserveBorrowApyForSort(b.debtReserve);
+    if (d !== 0) return d;
+    const pa = viem.getAddress(a.hub.address) === prefer ? 0 : 1;
+    const pb = viem.getAddress(b.hub.address) === prefer ? 0 : 1;
+    if (pa !== pb) return pa - pb;
+    return aaveV4HubAutoPickTiebreakOrder(a.hub, b.hub);
+  };
+  if (wantN == null) {
+    withDebt.sort(sortKey);
+    const x2 = withDebt[0];
+    return { hub: x2.hub, hubReserves: x2.hubReserves, reserve: x2.reserve };
+  }
+  const sufficient = withDebt.filter((c) => {
+    const s = aaveV4SuppliableHumanFromHubReserve(c.debtReserve);
+    return s != null && s + 1e-9 >= wantN;
+  });
+  const pool = sufficient.length ? sufficient : withDebt;
+  pool.sort(sortKey);
+  const x = pool[0];
+  return { hub: x.hub, hubReserves: x.hubReserves, reserve: x.reserve };
+}
+async function fetchAaveV4HubReserves(args) {
+  const h = viem.getAddress(args.hubAddress);
+  const k = hubReservesKey(args.chainId, h);
+  const hit = aaveV4HubReserves.get(k);
+  if (hit) return hit;
+  const p = (async () => {
+    const d = await aaveV4Gql(
+      `query R($r: ReservesRequest!) {
+        reserves(request: $r) {
+          canBorrow
+          canSupply
+          canUseAsCollateral
+          spoke { address }
+          settings {
+            borrowable
+            collateral
+            collateralFactor { normalized value }
+            collateralRisk { normalized value }
+          }
+          summary {
+            supplied { amount { value decimals } }
+            borrowed { amount { value decimals } }
+            suppliable { amount { value decimals } }
+            supplyApy { normalized value }
+            borrowApy { normalized value }
+          }
+          asset { underlying { address info { name symbol icon } } }
+        }
+      }`,
+      {
+        r: {
+          query: { hub: { address: h, chainId: args.chainId } },
+          filter: "ALL",
+          orderBy: { supplyApy: "DESC" }
+        }
+      }
+    );
+    return d.reserves ?? [];
+  })();
+  aaveV4HubReserves.set(k, p);
+  return p;
+}
+function formatAaveV4PercentDisplay(normalized, value) {
+  const n = (normalized ?? "").trim();
+  if (n) {
+    const f = parseFloat(n);
+    if (!Number.isFinite(f)) return "\u2014";
+    if (f === 0) return "\u2014";
+    if (f % 1 === 0) return `${f.toFixed(0)}%`;
+    return `${f >= 10 ? f.toFixed(0) : f >= 1 ? f.toFixed(1).replace(/\.0$/, "") : f.toFixed(2).replace(/\.?0+$/, "")}%`;
+  }
+  const v = parseFloat((value ?? "").trim());
+  if (Number.isFinite(v) && v > 0) {
+    return `${Math.round(v * 100)}%`;
+  }
+  return "\u2014";
+}
+function formatAaveV4RiskDisplay(normalized, value) {
+  const n = parseFloat((normalized ?? "").trim());
+  if (Number.isFinite(n) && n > 0) {
+    return n >= 0.01 ? `${n.toFixed(2).replace(/\.0+$|(\.\d*?)0+$/, "$1")}%` : `${n.toFixed(4)}%`;
+  }
+  const v = parseFloat((value ?? "").trim());
+  if (Number.isFinite(v) && v > 0) {
+    return `${(v * 100).toFixed(2).replace(/\.0+$|(\.\d*?)0+$/, "$1")}%`;
+  }
+  return "Low";
+}
+function findHubReserveForUnderlying(list, underlying) {
+  const t = viem.getAddress(underlying).toLowerCase();
+  return list.find((r) => (r.asset?.underlying?.address ?? "").toLowerCase() === t) ?? null;
+}
+function borrowableAssetsFromHubReserves(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of rows) {
+    if (!r.canBorrow || !r.settings?.borrowable) continue;
+    const a = (r.asset?.underlying?.address ?? "").trim();
+    if (!a || !viem.isAddress(a)) continue;
+    const lo = a.toLowerCase();
+    if (seen.has(lo)) continue;
+    seen.add(lo);
+    const info = r.asset?.underlying?.info;
+    out.push({
+      address: viem.getAddress(a),
+      symbol: (info?.symbol ?? "\u2014").trim() || "\u2014",
+      name: (info?.name ?? "").trim() || "\u2014",
+      icon: (info?.icon ?? "").trim() || null
+    });
+  }
+  out.sort((p, q) => p.symbol.localeCompare(q.symbol, void 0, { sensitivity: "base" }));
+  return out;
+}
+var USER_BORROWS_HUB = `
+  query AaveV4UserBorrowsHub($r: UserBorrowsRequest!) {
+    userBorrows(request: $r) {
+      debt { amount { value } }
+      reserve {
+        asset { underlying { address } }
+      }
+    }
+  }
+`;
+async function fetchAaveV4UserBorrowsDebtByUnderlyingForHub(args) {
+  const u = viem.getAddress(args.user);
+  const h = viem.getAddress(args.hubAddress);
+  const d = await aaveV4Gql(USER_BORROWS_HUB, {
+    r: {
+      query: {
+        userHub: {
+          user: u,
+          hub: { input: { address: h, chainId: args.chainId } }
+        }
+      },
+      orderBy: { amount: "DESC" },
+      includeZeroBalances: false
+    }
+  });
+  const m = /* @__PURE__ */ new Map();
+  for (const row of d.userBorrows ?? []) {
+    const addr = (row?.reserve?.asset?.underlying?.address ?? "").trim();
+    if (!addr) continue;
+    const lo = viem.getAddress(addr).toLowerCase();
+    const v = (row?.debt?.amount?.value ?? "").trim();
+    if (!v) continue;
+    const n = parseFloat(v);
+    if (!Number.isFinite(n) || n === 0) continue;
+    const prev = m.get(lo);
+    if (prev) {
+      const p = parseFloat(prev);
+      m.set(lo, String((Number.isFinite(p) ? p : 0) + n));
+    } else {
+      m.set(lo, v);
+    }
+  }
+  return m;
+}
+function buildAaveV4BorrowTableRowsFromHub(borrowable, hubReserves, debtByUnderlying) {
+  if (!hubReserves?.length) {
+    return borrowable.map((b) => ({
+      address: b.address,
+      symbol: b.symbol,
+      name: b.name,
+      icon: b.icon,
+      yourBorrowedDisplay: debtByUnderlying === void 0 ? "\u2014" : `0${b.symbol && b.symbol !== "\u2014" ? ` ${b.symbol}` : ""}`,
+      baseBorrowApyDisplay: "\u2014",
+      totalBorrowsDisplay: "\u2014",
+      liquidityDisplay: "\u2014"
+    }));
+  }
+  return borrowable.map((b) => {
+    const lo = b.address.toLowerCase();
+    const r = hubReserves.find((x) => (x.asset?.underlying?.address ?? "").toLowerCase() === lo) ?? null;
+    const s = r?.summary;
+    const debtRaw = debtByUnderlying?.get(lo) ?? null;
+    const symSuffix = b.symbol && b.symbol !== "\u2014" ? ` ${b.symbol}` : "";
+    return {
+      address: b.address,
+      symbol: b.symbol,
+      name: b.name,
+      icon: b.icon,
+      yourBorrowedDisplay: (() => {
+        if (debtByUnderlying === void 0) return "\u2014";
+        if (debtRaw == null || !String(debtRaw).trim()) return `0${symSuffix}`;
+        const n = parseFloat(String(debtRaw).trim());
+        if (!Number.isFinite(n) || n === 0) return `0${symSuffix}`;
+        return `${formatAaveV4AmountHumanFromApiString(debtRaw)}${symSuffix}`;
+      })(),
+      baseBorrowApyDisplay: formatAaveV4PercentDisplay(
+        s?.borrowApy?.normalized,
+        s?.borrowApy?.value
+      ),
+      totalBorrowsDisplay: s ? `${formatAaveV4AmountHumanFromApiString(s.borrowed?.amount?.value)}${symSuffix}` : "\u2014",
+      liquidityDisplay: s ? `${formatAaveV4ReserveLiquidityFromSummary({
+        suppliedValue: s.supplied?.amount?.value,
+        borrowedValue: s.borrowed?.amount?.value
+      })}${symSuffix}` : "\u2014"
+    };
+  });
+}
+var spokeStaticAbi = [
+  {
+    name: "getReserveCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "getReserve",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "reserveId", type: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "underlying", type: "address" },
+          { name: "hub", type: "address" },
+          { name: "assetId", type: "uint16" },
+          { name: "decimals", type: "uint8" },
+          { name: "collateralRisk", type: "uint24" },
+          { name: "flags", type: "uint8" },
+          { name: "dynamicConfigKey", type: "uint32" }
+        ]
+      }
+    ]
+  },
+  {
+    name: "getReserveConfig",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "reserveId", type: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "collateralRisk", type: "uint24" },
+          { name: "paused", type: "bool" },
+          { name: "frozen", type: "bool" },
+          { name: "borrowable", type: "bool" },
+          { name: "receiveSharesEnabled", type: "bool" }
+        ]
+      }
+    ]
+  }
+];
+async function fetchAaveV4SpokeReserveIdForUnderlying(args) {
+  const url = (args.rpcUrl ?? "").trim();
+  if (!continuumNodeSdk.isValidRpcUrl(url)) return null;
+  if (!Number.isFinite(args.chainId) || args.chainId < 0) return null;
+  const spoke = viem.getAddress(args.spoke);
+  const want = viem.getAddress(args.underlying).toLowerCase();
+  const chain = viem.defineChain({
+    id: args.chainId,
+    name: "Rpc",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [url] } }
+  });
+  const client = viem.createPublicClient({ chain, transport: viem.http(url) });
+  const count = await client.readContract({
+    address: spoke,
+    abi: spokeStaticAbi,
+    functionName: "getReserveCount"
+  });
+  const n = Number(count);
+  if (!Number.isFinite(n) || n < 0 || n > 256) return null;
+  for (let i = 0; i < n; i++) {
+    const r = await client.readContract({
+      address: spoke,
+      abi: spokeStaticAbi,
+      functionName: "getReserve",
+      args: [BigInt(i)]
+    });
+    if (r.underlying.toLowerCase() === want) return BigInt(i);
+  }
+  return null;
+}
+async function fetchAaveV4SpokeReserveStatusForUnderlying(args) {
+  const reserveId = await fetchAaveV4SpokeReserveIdForUnderlying(args);
+  if (reserveId == null) return null;
+  const url = (args.rpcUrl ?? "").trim();
+  const spoke = viem.getAddress(args.spoke);
+  const chain = viem.defineChain({
+    id: args.chainId,
+    name: "Rpc",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [url] } }
+  });
+  const client = viem.createPublicClient({ chain, transport: viem.http(url) });
+  const cfg = await client.readContract({
+    address: spoke,
+    abi: spokeStaticAbi,
+    functionName: "getReserveConfig",
+    args: [reserveId]
+  });
+  return {
+    reserveId,
+    paused: cfg.paused,
+    frozen: cfg.frozen,
+    borrowable: cfg.borrowable,
+    receiveSharesEnabled: cfg.receiveSharesEnabled,
+    collateralRisk: Number(cfg.collateralRisk)
+  };
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = purposeText.trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = continuumNodeSdk.getClientIdFromKeyGenResult(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return continuumNodeSdk.gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+
+// src/chains/evm/buildBatch.ts
+async function buildEvmMultisignBatch(args) {
+  const { context, steps } = args;
+  const {
+    chainId,
+    rpcUrl,
+    executorAddress,
+    chainDetail,
+    useCustomGas,
+    customGasChainDetails,
+    keyGen,
+    purposeText
+  } = context;
+  if (steps.length === 0) throw new Error("buildEvmMultisignBatch requires at least one step");
+  const ch = viem.defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
+  const feeParams = await continuumNodeSdk.fetchChainFeeParams(rpcUrl, chainId);
+  const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await publicClient.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const gasLimitConfig = useCustomGas && chainDetail?.gasLimit != null ? Number(chainDetail.gasLimit) : void 0;
+  const chainGasLimitRouter = chainDetail?.gasLimit != null && Number.isFinite(Number(chainDetail.gasLimit)) && Number(chainDetail.gasLimit) > 0 ? Number(chainDetail.gasLimit) : void 0;
+  const gasFeeMultiplier = useCustomGas && chainDetail?.gasMultiplier != null ? Number(chainDetail.gasMultiplier) : void 0;
+  const executor = viem.getAddress(executorAddress);
+  const baseNonce = await publicClient.getTransactionCount({ address: executor, blockTag: "pending" });
+  const legs = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const currentNonce = baseNonce + i;
+    let estimatedGas;
+    if (args.estimateGasForStep) {
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient, executor });
+    } else {
+      try {
+        estimatedGas = await publicClient.estimateGas({
+          to: step.to,
+          data: step.data,
+          value: step.value,
+          account: executor
+        });
+      } catch {
+        estimatedGas = step.fallbackGas ?? 100000n;
+      }
+    }
+    let gasLimitI;
+    if (args.resolveGasLimit) {
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient });
+    } else if (step.routerSwap) {
+      gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+    } else {
+      gasLimitI = useCustomGas ? continuumNodeSdk.gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    }
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
+    if (legacy) {
+      let gasPriceWei = await publicClient.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = viem.parseGwei(continuumNodeSdk.gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = viem.serializeTransaction({
+        type: "legacy",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWei.toString()
+      };
+      feeSnapshot = continuumNodeSdk.proposalTxParamsToFeeSnapshot(proposalTxParams);
+    } else {
+      const fetchedBase = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+      const configuredBase = useCustomGas && chainDetail?.baseFee != null ? Number(chainDetail.baseFee) : 0;
+      const configuredPriority = useCustomGas && chainDetail?.priorityFee != null ? Number(chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+      const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+      const baseFeeMultiplierPct = useCustomGas && chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+      const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? viem.parseGwei(continuumNodeSdk.gweiToDecimalString(effectivePriorityFeeGwei)) : viem.parseGwei("1");
+      let maxFeePerGas = viem.parseGwei(continuumNodeSdk.gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = continuumNodeSdk.alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = viem.serializeTransaction({
+        type: "eip1559",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGas.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+      };
+      feeSnapshot = i === 0 ? continuumNodeSdk.proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = viem.keccak256(serialized);
+    const msgHash = h.startsWith("0x") ? h.slice(2) : h;
+    const batchMetaExtra = args.buildBatchMeta({ step, index: i, gasLimit: gasLimitI });
+    legs.push({
+      msgHash,
+      msgRaw: i === 0 && args.firstMsgRawNo0x != null ? args.firstMsgRawNo0x : serialized,
+      destinationAddress: step.to,
+      signatureText: typeof batchMetaExtra.signatureText === "string" ? batchMetaExtra.signatureText : JSON.stringify(batchMetaExtra.signatureText ?? {}),
+      audit: batchMetaExtra,
+      feeSnapshot: i === 0 ? feeSnapshot : {},
+      proposalTxParams,
+      valueWei: i === 0 ? step.value : void 0
+    });
+    if (i === 0 && args.firstMsgRawNo0x != null) {
+      legs[0].msgRaw = args.firstMsgRawNo0x;
+    }
+  }
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
+  }
+  const result = finalizeMultisign({
+    keyGen,
+    purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: String(chainId),
+    destinationAddress: args.destinationAddress ?? steps[0].to,
+    legs,
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+
+// src/protocols/evm/aave-v4/multisign.ts
+var AAVE_V4_SPOKE_SUPPLY_DEFAULT_GAS_UNITS = 1200000n;
+var AAVE_SPOKE_SUPPLY_ESTIMATE_FALLBACK = AAVE_V4_SPOKE_SUPPLY_DEFAULT_GAS_UNITS;
+var AAVE_SPOKE_SET_USING_AS_COLLATERAL_FALLBACK = 450000n;
+var AAVE_ERC20_APPROVE_FALLBACK = 100000n;
+var AAVE_WETH_DEPOSIT_FALLBACK = 120000n;
+var AAVE_V4_SPOKE_WITHDRAW_DEFAULT_GAS_UNITS = 800000n;
+var AAVE_SPOKE_WITHDRAW_ESTIMATE_FALLBACK = AAVE_V4_SPOKE_WITHDRAW_DEFAULT_GAS_UNITS;
+var AAVE_V4_SPOKE_BORROW_DEFAULT_GAS_UNITS = 900000n;
+var AAVE_SPOKE_BORROW_ESTIMATE_FALLBACK = AAVE_V4_SPOKE_BORROW_DEFAULT_GAS_UNITS;
+var AAVE_V4_SPOKE_REPAY_DEFAULT_GAS_UNITS = 1000000n;
+var AAVE_SPOKE_REPAY_ESTIMATE_FALLBACK = AAVE_V4_SPOKE_REPAY_DEFAULT_GAS_UNITS;
+var AAVE_MERKL_CLAIM_ESTIMATE_FALLBACK = 500000n;
+var EULER_REUL_UNLOCK_ESTIMATE_FALLBACK = 500000n;
+var wethDepositAbi = viem.parseAbi(["function deposit() payable"]);
+var erc20AllowanceAbi = viem.parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+]);
+var erc20ApproveAbi = viem.parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+var spokeSupplyAbi = viem.parseAbi(["function supply(uint256 reserveId, uint256 amount, address onBehalfOf)"]);
+var spokeWithdrawAbi = viem.parseAbi(["function withdraw(uint256 reserveId, uint256 amount, address onBehalfOf)"]);
+var spokeBorrowAbi = viem.parseAbi(["function borrow(uint256 reserveId, uint256 amount, address onBehalfOf)"]);
+var spokeRepayAbi = viem.parseAbi(["function repay(uint256 reserveId, uint256 amount, address onBehalfOf)"]);
+var spokeSetUsingAsCollateralAbi = viem.parseAbi([
+  "function setUsingAsCollateral(uint256 reserveId, bool usingAsCollateral, address onBehalfOf)"
+]);
+async function buildEvmMultisignBodyAaveV4DepositBatch(args) {
+  const asset = viem.getAddress(args.asset);
+  const spoke = viem.getAddress(args.spoke);
+  const weth = viem.getAddress(args.nativeWrapped);
+  const executor = viem.getAddress(args.executorAddress);
+  const onBehalf = viem.getAddress(args.onBehalfOf);
+  if (args.isNativeIn && asset.toLowerCase() !== weth.toLowerCase()) {
+    throw new Error("Native deposit path: underlying asset must match the chain wrapped native token.");
+  }
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const dec = await publicClient.readContract({
+    address: asset,
+    abi: erc20AllowanceAbi,
+    functionName: "decimals"
+  });
+  const amountWei = viem.parseUnits(args.amountHuman, Number(dec));
+  if (amountWei === 0n) throw new Error("Amount is zero after converting with token decimals.");
+  const steps = [];
+  if (args.isNativeIn) {
+    const dataDeposit = viem.encodeFunctionData({ abi: wethDepositAbi, functionName: "deposit", args: [] });
+    steps.push({ kind: "weth_deposit", to: weth, data: dataDeposit, value: amountWei });
+    const wethAllowance = await publicClient.readContract({
+      address: weth,
+      abi: erc20AllowanceAbi,
+      functionName: "allowance",
+      args: [executor, spoke]
+    });
+    if (wethAllowance < amountWei) {
+      if (wethAllowance > 0n) {
+        const dataReset = viem.encodeFunctionData({
+          abi: erc20ApproveAbi,
+          functionName: "approve",
+          args: [spoke, 0n]
+        });
+        steps.push({ kind: "approve", to: weth, data: dataReset, value: 0n });
+      }
+      const dataApprove = viem.encodeFunctionData({
+        abi: erc20ApproveAbi,
+        functionName: "approve",
+        args: [spoke, amountWei]
+      });
+      steps.push({ kind: "approve", to: weth, data: dataApprove, value: 0n });
+    }
+  } else {
+    const currentAllowance = await publicClient.readContract({
+      address: asset,
+      abi: erc20AllowanceAbi,
+      functionName: "allowance",
+      args: [executor, spoke]
+    });
+    if (currentAllowance < amountWei) {
+      if (currentAllowance > 0n) {
+        const dataReset = viem.encodeFunctionData({
+          abi: erc20ApproveAbi,
+          functionName: "approve",
+          args: [spoke, 0n]
+        });
+        steps.push({ kind: "approve", to: asset, data: dataReset, value: 0n });
+      }
+      const dataApprove = viem.encodeFunctionData({
+        abi: erc20ApproveAbi,
+        functionName: "approve",
+        args: [spoke, amountWei]
+      });
+      steps.push({ kind: "approve", to: asset, data: dataApprove, value: 0n });
+    }
+  }
+  const reserveId = await fetchAaveV4SpokeReserveIdForUnderlying({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    spoke,
+    underlying: asset
+  });
+  if (reserveId == null) {
+    throw new Error(
+      "Could not resolve Aave v4 reserve id for this asset on the Spoke (getReserve). Check RPC and the selected market."
+    );
+  }
+  const supplyData = viem.encodeFunctionData({
+    abi: spokeSupplyAbi,
+    functionName: "supply",
+    args: [reserveId, amountWei, onBehalf]
+  });
+  steps.push({ kind: "supply", to: spoke, data: supplyData, value: 0n });
+  if (args.enableAsCollateralAfterSupply === true) {
+    const setCollateralData = viem.encodeFunctionData({
+      abi: spokeSetUsingAsCollateralAbi,
+      functionName: "setUsingAsCollateral",
+      args: [reserveId, true, onBehalf]
+    });
+    steps.push({ kind: "set_collateral", to: spoke, data: setCollateralData, value: 0n });
+  }
+  const marketLabel = String(args.market);
+  const evmSteps = steps.map((s) => ({
+    to: s.to,
+    data: s.data,
+    value: s.value,
+    fallbackGas: s.kind === "weth_deposit" ? AAVE_WETH_DEPOSIT_FALLBACK : s.kind === "approve" ? AAVE_ERC20_APPROVE_FALLBACK : s.kind === "set_collateral" ? AAVE_SPOKE_SET_USING_AS_COLLATERAL_FALLBACK : AAVE_SPOKE_SUPPLY_ESTIMATE_FALLBACK
+  }));
+  const n = steps.length;
+  const hasWrap = args.isNativeIn;
+  const withCollateral = args.enableAsCollateralAfterSupply === true;
+  const purposeSuffix = (() => {
+    if (hasWrap) {
+      return withCollateral ? `Aave v4: ${n}-tx batch \u2014 wrap native to WETH (if needed), approve spoke for the exact amount, supply, then setUsingAsCollateral.` : `Aave v4: ${n}-tx batch \u2014 wrap native to WETH (if needed), approve spoke for the exact amount, then supply.`;
+    }
+    if (n === 1) {
+      return "Aave v4: 1-tx \u2014 supply (allowance already sufficient).";
+    }
+    if (withCollateral && n === 2) {
+      return "Aave v4: 2-tx batch \u2014 supply (allowance already sufficient), then setUsingAsCollateral.";
+    }
+    if (withCollateral) {
+      return `Aave v4: ${n}-tx batch \u2014 approve spoke for the exact amount, supply, then setUsingAsCollateral.`;
+    }
+    return `Aave v4: ${n}-tx batch \u2014 approve spoke for the exact amount, then supply.`;
+  })();
+  const firstDataNo0x = evmSteps[0].data.startsWith("0x") ? evmSteps[0].data.slice(2) : evmSteps[0].data;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails
+    },
+    steps: evmSteps,
+    purposeSuffix,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: steps[0].to,
+    buildBatchMeta: ({ index, gasLimit }) => {
+      const s = steps[index];
+      if (s.kind === "weth_deposit") {
+        return {
+          signatureText: JSON.stringify({
+            kind: "AaveV4",
+            name: "WETH.deposit",
+            function: "deposit()",
+            valueWei: amountWei.toString(),
+            market: marketLabel,
+            note: "Wrap native to WETH, then supply to Aave v4 (same batch)."
+          }),
+          evm: { type: "aave_v4_weth_deposit", version: 1, chainId: String(args.chainId) },
+          aaveV4: { step: "weth_deposit", market: marketLabel, amountHuman: args.amountHuman, hubAsset: asset }
+        };
+      }
+      if (s.kind === "approve") {
+        return {
+          signatureText: JSON.stringify({
+            kind: "AaveV4",
+            name: "ERC20.approve",
+            to: "Aave v4 spoke",
+            function: "approve(address spender, uint256 amount)",
+            spoke,
+            amountHuman: args.amountHuman,
+            note: "Allowance for this supply amount only (not unlimited)."
+          }),
+          evm: { type: "aave_v4_erc20_approve", version: 1, chainId: String(args.chainId) },
+          aaveV4: { market: marketLabel, amountHuman: args.amountHuman, spoke }
+        };
+      }
+      if (s.kind === "set_collateral") {
+        return {
+          signatureText: JSON.stringify({
+            kind: "AaveV4",
+            name: "Spoke.setUsingAsCollateral",
+            function: "setUsingAsCollateral(uint256 reserveId, bool usingAsCollateral, address onBehalfOf)",
+            reserveId: reserveId.toString(),
+            usingAsCollateral: true,
+            onBehalfOf: onBehalf,
+            market: marketLabel,
+            note: "Enables this supplied reserve as collateral for borrowing (after supply in the same batch)."
+          }),
+          evm: { type: "aave_v4_spoke_set_using_as_collateral", version: 1, chainId: String(args.chainId) },
+          aaveV4: {
+            market: marketLabel,
+            asset,
+            spoke,
+            reserveId: reserveId.toString(),
+            gasBuildSetCollateral: { baseGasUnits: gasLimit.toString() }
+          }
+        };
+      }
+      return {
+        signatureText: JSON.stringify({
+          kind: "AaveV4",
+          name: "Spoke.supply",
+          function: "supply(uint256 reserveId, uint256 amount, address onBehalfOf)",
+          reserveId: reserveId.toString(),
+          asset,
+          onBehalfOf: onBehalf,
+          market: marketLabel,
+          amountHuman: args.amountHuman
+        }),
+        evm: { type: "aave_v4_spoke_supply", version: 1, chainId: String(args.chainId) },
+        aaveV4: {
+          market: marketLabel,
+          amountHuman: args.amountHuman,
+          asset,
+          spoke,
+          reserveId: reserveId.toString(),
+          gasBuildSupply: { baseGasUnits: gasLimit.toString() }
+        }
+      };
+    }
+  });
+}
+async function buildEvmMultisignBodyAaveV4SpokeWithdraw(args) {
+  const asset = viem.getAddress(args.underlying);
+  const spoke = viem.getAddress(args.spoke);
+  const onBehalf = viem.getAddress(args.onBehalfOf);
+  const executor = viem.getAddress(args.executorAddress);
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const dec = await publicClient.readContract({
+    address: asset,
+    abi: erc20AllowanceAbi,
+    functionName: "decimals"
+  });
+  const amountWei = viem.parseUnits(args.amountHuman, Number(dec));
+  if (amountWei === 0n) throw new Error("Withdraw amount is zero after converting with token decimals.");
+  let reserveId;
+  if (args.reserveIdOnChain != null && args.reserveIdOnChain >= 0n) {
+    reserveId = args.reserveIdOnChain;
+  } else {
+    const r = await fetchAaveV4SpokeReserveIdForUnderlying({
+      rpcUrl: args.rpcUrl,
+      chainId: args.chainId,
+      spoke,
+      underlying: asset
+    });
+    if (r == null) {
+      throw new Error("Could not resolve Aave v4 reserve id for this asset on the Spoke.");
+    }
+    reserveId = r;
+  }
+  const data = viem.encodeFunctionData({
+    abi: spokeWithdrawAbi,
+    functionName: "withdraw",
+    args: [reserveId, amountWei, onBehalf]
+  });
+  const tx = { to: spoke, data, value: 0n };
+  return buildEvmMultisignBodyAaveV4OneStep({
+    keyGen: args.keyGen,
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails ?? void 0,
+    purposeText: args.purposeText,
+    purposeSuffix: `Aave v4: 1-tx \u2014 Spoke.withdraw for ${(args.amountHuman || "").trim() || "\u2026"} of underlying on this market (see signature text).`,
+    executorAddress: executor,
+    v: tx,
+    estimateGasFallback: AAVE_SPOKE_WITHDRAW_ESTIMATE_FALLBACK,
+    buildBatchMeta: (ctx) => ({
+      destinationAddress: spoke,
+      signatureText: JSON.stringify({
+        kind: "AaveV4",
+        name: "Spoke.withdraw",
+        function: "withdraw(uint256 reserveId, uint256 amount, address onBehalfOf)",
+        reserveId: reserveId.toString(),
+        asset,
+        onBehalfOf: onBehalf,
+        market: args.marketLabel,
+        amountHuman: args.amountHuman
+      }),
+      evm: { type: "aave_v4_spoke_withdraw", version: 1, chainId: String(args.chainId) },
+      aaveV4: {
+        market: args.marketLabel,
+        amountHuman: args.amountHuman,
+        asset,
+        spoke,
+        reserveId: reserveId.toString(),
+        gasBuildWithdraw: { baseGasUnits: ctx.gasLimit.toString() }
+      }
+    })
+  });
+}
+async function buildEvmMultisignBodyAaveV4SpokeBorrow(args) {
+  const asset = viem.getAddress(args.underlying);
+  const spoke = viem.getAddress(args.spoke);
+  const onBehalf = viem.getAddress(args.onBehalfOf);
+  const executor = viem.getAddress(args.executorAddress);
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const dec = await publicClient.readContract({
+    address: asset,
+    abi: erc20AllowanceAbi,
+    functionName: "decimals"
+  });
+  const amountWei = viem.parseUnits(args.amountHuman, Number(dec));
+  if (amountWei === 0n) throw new Error("Borrow amount is zero after converting with token decimals.");
+  let reserveId;
+  if (args.reserveIdOnChain != null && args.reserveIdOnChain >= 0n) {
+    reserveId = args.reserveIdOnChain;
+  } else {
+    const r = await fetchAaveV4SpokeReserveIdForUnderlying({
+      rpcUrl: args.rpcUrl,
+      chainId: args.chainId,
+      spoke,
+      underlying: asset
+    });
+    if (r == null) {
+      throw new Error("Could not resolve Aave v4 reserve id for this asset on the Spoke.");
+    }
+    reserveId = r;
+  }
+  const data = viem.encodeFunctionData({
+    abi: spokeBorrowAbi,
+    functionName: "borrow",
+    args: [reserveId, amountWei, onBehalf]
+  });
+  const tx = { to: spoke, data, value: 0n };
+  return buildEvmMultisignBodyAaveV4OneStep({
+    keyGen: args.keyGen,
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails ?? void 0,
+    purposeText: args.purposeText,
+    purposeSuffix: `Aave v4: 1-tx \u2014 Spoke.borrow for ${(args.amountHuman || "").trim() || "\u2026"} of underlying on this market (see signature text).`,
+    executorAddress: executor,
+    v: tx,
+    estimateGasFallback: AAVE_SPOKE_BORROW_ESTIMATE_FALLBACK,
+    buildBatchMeta: (ctx) => ({
+      destinationAddress: spoke,
+      signatureText: JSON.stringify({
+        kind: "AaveV4",
+        name: "Spoke.borrow",
+        function: "borrow(uint256 reserveId, uint256 amount, address onBehalfOf)",
+        reserveId: reserveId.toString(),
+        asset,
+        onBehalfOf: onBehalf,
+        market: args.marketLabel,
+        amountHuman: args.amountHuman
+      }),
+      evm: { type: "aave_v4_spoke_borrow", version: 1, chainId: String(args.chainId) },
+      aaveV4: {
+        market: args.marketLabel,
+        amountHuman: args.amountHuman,
+        asset,
+        spoke,
+        reserveId: reserveId.toString(),
+        gasBuildBorrow: { baseGasUnits: ctx.gasLimit.toString() }
+      }
+    })
+  });
+}
+async function buildEvmMultisignBodyAaveV4SpokeRepay(args) {
+  const asset = viem.getAddress(args.underlying);
+  const spoke = viem.getAddress(args.spoke);
+  const onBehalf = viem.getAddress(args.onBehalfOf);
+  const executor = viem.getAddress(args.executorAddress);
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const dec = await publicClient.readContract({
+    address: asset,
+    abi: erc20AllowanceAbi,
+    functionName: "decimals"
+  });
+  const amountWei = viem.parseUnits(args.amountHuman, Number(dec));
+  if (amountWei === 0n) throw new Error("Repay amount is zero after converting with token decimals.");
+  let reserveId;
+  if (args.reserveIdOnChain != null && args.reserveIdOnChain >= 0n) {
+    reserveId = args.reserveIdOnChain;
+  } else {
+    const r = await fetchAaveV4SpokeReserveIdForUnderlying({
+      rpcUrl: args.rpcUrl,
+      chainId: args.chainId,
+      spoke,
+      underlying: asset
+    });
+    if (r == null) {
+      throw new Error("Could not resolve Aave v4 reserve id for this asset on the Spoke.");
+    }
+    reserveId = r;
+  }
+  const steps = [];
+  const currentAllowance = await publicClient.readContract({
+    address: asset,
+    abi: erc20AllowanceAbi,
+    functionName: "allowance",
+    args: [executor, spoke]
+  });
+  if (currentAllowance < amountWei) {
+    if (currentAllowance > 0n) {
+      const dataReset = viem.encodeFunctionData({
+        abi: erc20ApproveAbi,
+        functionName: "approve",
+        args: [spoke, 0n]
+      });
+      steps.push({ kind: "approve", to: asset, data: dataReset, value: 0n });
+    }
+    const dataApprove = viem.encodeFunctionData({
+      abi: erc20ApproveAbi,
+      functionName: "approve",
+      args: [spoke, amountWei]
+    });
+    steps.push({ kind: "approve", to: asset, data: dataApprove, value: 0n });
+  }
+  const repayData = viem.encodeFunctionData({
+    abi: spokeRepayAbi,
+    functionName: "repay",
+    args: [reserveId, amountWei, onBehalf]
+  });
+  steps.push({ kind: "repay", to: spoke, data: repayData, value: 0n });
+  const marketLabel = String(args.market);
+  const evmSteps = steps.map((s) => ({
+    to: s.to,
+    data: s.data,
+    value: s.value,
+    fallbackGas: s.kind === "approve" ? AAVE_ERC20_APPROVE_FALLBACK : AAVE_SPOKE_REPAY_ESTIMATE_FALLBACK
+  }));
+  const n = steps.length;
+  const purposeSuffix = `Aave v4: ${n}-tx batch \u2014 approve spoke if needed, then repay ${(args.amountHuman || "").trim() || "\u2026"} of debt.`;
+  const firstDataNo0x = evmSteps[0].data.startsWith("0x") ? evmSteps[0].data.slice(2) : evmSteps[0].data;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails
+    },
+    steps: evmSteps,
+    purposeSuffix,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: steps[0].to,
+    buildBatchMeta: ({ index, gasLimit }) => {
+      const s = steps[index];
+      if (s.kind === "approve") {
+        return {
+          signatureText: JSON.stringify({
+            kind: "AaveV4",
+            name: "ERC20.approve (repay)",
+            to: "Aave v4 spoke",
+            function: "approve(address spender, uint256 amount)",
+            spoke,
+            amountHuman: args.amountHuman,
+            note: "Allowance to repay this amount (or reset+approve to exact amount)."
+          }),
+          evm: { type: "aave_v4_erc20_approve", version: 1, chainId: String(args.chainId) },
+          aaveV4: { market: marketLabel, amountHuman: args.amountHuman, spoke, step: "repay_prepare" }
+        };
+      }
+      return {
+        signatureText: JSON.stringify({
+          kind: "AaveV4",
+          name: "Spoke.repay",
+          function: "repay(uint256 reserveId, uint256 amount, address onBehalfOf)",
+          reserveId: reserveId.toString(),
+          asset,
+          onBehalfOf: onBehalf,
+          market: marketLabel,
+          amountHuman: args.amountHuman
+        }),
+        evm: { type: "aave_v4_spoke_repay", version: 1, chainId: String(args.chainId) },
+        aaveV4: {
+          market: marketLabel,
+          amountHuman: args.amountHuman,
+          asset,
+          spoke,
+          reserveId: reserveId.toString(),
+          gasBuildRepay: { baseGasUnits: gasLimit.toString() }
+        }
+      };
+    }
+  });
+}
+async function buildEvmMultisignBodyAaveV4MerklClaimRewards(args) {
+  const to = viem.getAddress(args.to);
+  const executor = viem.getAddress(args.executorAddress);
+  return buildEvmMultisignBodyAaveV4OneStep({
+    keyGen: args.keyGen,
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails ?? void 0,
+    purposeText: args.purposeText,
+    purposeSuffix: `Aave v4: 1-tx \u2014 Merkl claim rewards (${args.rewardIdCount} id(s), see calldata in signature text).`,
+    executorAddress: executor,
+    v: { to, data: args.data, value: args.valueWei },
+    estimateGasFallback: AAVE_MERKL_CLAIM_ESTIMATE_FALLBACK,
+    buildBatchMeta: (ctx) => ({
+      destinationAddress: to,
+      signatureText: JSON.stringify({
+        kind: "AaveV4",
+        name: "claimRewards (Merkl)",
+        rewardIdCount: args.rewardIdCount,
+        chainId: args.chainId,
+        valueWei: args.valueWei.toString(),
+        note: "From Aave v4 claimRewards request."
+      }),
+      evm: { type: "aave_v4_merkl_claim_rewards", version: 1, chainId: String(args.chainId) },
+      aaveV4: { step: "merkl_claim", rewardIdCount: args.rewardIdCount, gasBuildClaim: { baseGasUnits: ctx.gasLimit.toString() } }
+    })
+  });
+}
+async function buildEvmMultisignBodyEulerV2MerklDistributorClaim(args) {
+  const to = viem.getAddress(args.to);
+  const executor = viem.getAddress(args.executorAddress);
+  return buildEvmMultisignBodyAaveV4OneStep({
+    keyGen: args.keyGen,
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails ?? void 0,
+    purposeText: args.purposeText,
+    purposeSuffix: `Euler v2: 1-tx \u2014 Merkl distributor claim (${args.claimLeafCount} reward(s), see calldata in signature text).`,
+    executorAddress: executor,
+    v: { to, data: args.data, value: args.valueWei },
+    estimateGasFallback: AAVE_MERKL_CLAIM_ESTIMATE_FALLBACK,
+    buildBatchMeta: (ctx) => ({
+      destinationAddress: to,
+      signatureText: JSON.stringify({
+        kind: "EulerV2",
+        name: "Merkl Distributor claim",
+        claimLeafCount: args.claimLeafCount,
+        chainId: args.chainId,
+        valueWei: args.valueWei.toString(),
+        note: "Merkl API proofs; Distributor.claim(users,tokens,amounts,proofs)."
+      }),
+      evm: { type: "euler_v2_merkl_distributor_claim", version: 1, chainId: String(args.chainId) },
+      eulerV2: { step: "merkl_distributor_claim", claimLeafCount: args.claimLeafCount, gasBuildClaim: { baseGasUnits: ctx.gasLimit.toString() } }
+    })
+  });
+}
+async function buildEvmMultisignBodyEulerV2ReulUnlock(args) {
+  const to = viem.getAddress(args.to);
+  const executor = viem.getAddress(args.executorAddress);
+  const lossLabel = args.allowRemainderLoss ? "early unlock (remainder to receiver)" : "vested only";
+  return buildEvmMultisignBodyAaveV4OneStep({
+    keyGen: args.keyGen,
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails ?? void 0,
+    purposeText: args.purposeText,
+    purposeSuffix: `Euler v2: 1-tx \u2014 rEUL unlock (${args.lockTimestampCount} lock(s), ${lossLabel}).`,
+    executorAddress: executor,
+    v: { to, data: args.data, value: args.valueWei },
+    estimateGasFallback: EULER_REUL_UNLOCK_ESTIMATE_FALLBACK,
+    buildBatchMeta: (ctx) => ({
+      destinationAddress: to,
+      signatureText: JSON.stringify({
+        kind: "EulerV2",
+        name: "rEUL unlock (RewardToken)",
+        lockTimestampCount: args.lockTimestampCount,
+        allowRemainderLoss: args.allowRemainderLoss,
+        chainId: args.chainId,
+        valueWei: args.valueWei.toString(),
+        note: "RewardToken.withdrawToByLockTimestamps(account, lockTimestamps, allowRemainderLoss)."
+      }),
+      evm: { type: "euler_v2_reul_unlock", version: 1, chainId: String(args.chainId) },
+      eulerV2: {
+        step: "reul_unlock",
+        lockTimestampCount: args.lockTimestampCount,
+        allowRemainderLoss: args.allowRemainderLoss,
+        gasBuildClaim: { baseGasUnits: ctx.gasLimit.toString() }
+      }
+    })
+  });
+}
+async function buildEvmMultisignBodyAaveV4OneStep(args) {
+  const firstDataNo0x = args.v.data.startsWith("0x") ? args.v.data.slice(2) : args.v.data;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      executorAddress: args.executorAddress,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails
+    },
+    steps: [
+      {
+        to: args.v.to,
+        data: args.v.data,
+        value: args.v.value,
+        fallbackGas: args.estimateGasFallback
+      }
+    ],
+    purposeSuffix: args.purposeSuffix,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: args.v.to,
+    buildBatchMeta: ({ gasLimit }) => args.buildBatchMeta({ gasLimit })
+  });
+}
+var MIN_AAVE_V4_DEPOSIT_GAS_EXEC = 400000n;
+var AAVE_V4_EVM_TYPES = /* @__PURE__ */ new Set([
+  "aave_v4_weth_deposit",
+  "aave_v4_erc20_approve",
+  "aave_v4_spoke_supply",
+  "aave_v4_spoke_set_using_as_collateral",
+  "aave_v4_spoke_withdraw",
+  "aave_v4_spoke_borrow",
+  "aave_v4_spoke_repay",
+  "aave_v4_merkl_claim_rewards"
+]);
+function parseExtraJsonObject(detail) {
+  if (!detail) return null;
+  const raw = detail.ExtraJSON ?? detail.extraJSON;
+  if (raw == null) return null;
+  if (typeof raw === "object" && !Array.isArray(raw)) return raw;
+  if (typeof raw === "string" && raw.trim()) {
+    try {
+      const p = JSON.parse(raw);
+      if (p && typeof p === "object" && !Array.isArray(p)) return p;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function parseOptionalGasLimitString(raw) {
+  if (raw == null) return null;
+  const s = String(raw).trim();
+  if (!s) return null;
+  try {
+    if (/^0x[0-9a-fA-F]+$/.test(s)) return BigInt(s);
+    return BigInt(s);
+  } catch {
+    return null;
+  }
+}
+function isAaveV4DepositEvmSignRequest(detail, batchIndex) {
+  const ex = parseExtraJsonObject(detail);
+  if (!ex) return false;
+  const idx = batchIndex != null && batchIndex >= 0 ? batchIndex : 0;
+  const bm = ex.batchMeta;
+  if (Array.isArray(bm) && bm[idx] && typeof bm[idx] === "object" && !Array.isArray(bm[idx])) {
+    const evm0 = bm[idx].evm;
+    if (evm0 && typeof evm0 === "object" && !Array.isArray(evm0)) {
+      if (AAVE_V4_EVM_TYPES.has(String(evm0.type ?? ""))) return true;
+    }
+  }
+  if (batchIndex != null && batchIndex >= 0) return false;
+  const evm = ex.evm;
+  if (evm && typeof evm === "object" && !Array.isArray(evm)) {
+    if (AAVE_V4_EVM_TYPES.has(String(evm.type ?? ""))) return true;
+  }
+  return false;
+}
+function resolveAaveV4DepositGasUnitsFromSignRequest(detail, batchIndex) {
+  if (!detail) return null;
+  const index = batchIndex != null && batchIndex >= 0 ? batchIndex : 0;
+  const propBatch = detail.proposal_tx_params ?? detail.proposalTxParams ?? detail.ProposalTxParams;
+  if (Array.isArray(propBatch) && propBatch.length > index) {
+    const row = propBatch[index];
+    if (row && typeof row === "object" && !Array.isArray(row)) {
+      const r = row;
+      const gl = parseOptionalGasLimitString(
+        r.gas_limit ?? r.gasLimit ?? r.GasLimit
+      );
+      if (gl != null && gl > 0n) return gl;
+    }
+  }
+  if (batchIndex == null || batchIndex === 0) {
+    const tp = detail.txParams ?? detail.TxParams;
+    if (tp && typeof tp === "object") {
+      const gl = parseOptionalGasLimitString(
+        tp.gasLimit ?? tp.GasLimit ?? tp.txGasLimit
+      );
+      if (gl != null && gl > 0n) return gl;
+    }
+  }
+  const ex = parseExtraJsonObject(detail);
+  const bm = ex?.batchMeta;
+  if (Array.isArray(bm) && bm[index] && typeof bm[index] === "object" && !Array.isArray(bm[index])) {
+    const a4 = bm[index].aaveV4;
+    if (a4 && typeof a4 === "object") {
+      const gs = a4.gasBuildSupply ?? a4.gasBuildSetCollateral ?? a4.gasBuildWithdraw ?? a4.gasBuildBorrow ?? a4.gasBuildRepay ?? a4.gasBuildClaim;
+      const base = parseOptionalGasLimitString(gs?.baseGasUnits);
+      if (base != null && base > 0n) return base;
+    }
+  }
+  return null;
+}
+
+// src/protocols/evm/aave-v4/index.ts
+var AAVE_V4_PROTOCOL_ID = "aave-v4";
+var aaveV4ProtocolModule = {
+  id: AAVE_V4_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    return ctx.chainCategory === "evm";
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
+  },
+  actions: [
+    { id: "aave-v4.deposit", protocolId: AAVE_V4_PROTOCOL_ID, chainCategory: "evm", description: "Supply to Aave v4 Spoke", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "aave-v4.withdraw", protocolId: AAVE_V4_PROTOCOL_ID, chainCategory: "evm", description: "Withdraw from Spoke", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "aave-v4.borrow", protocolId: AAVE_V4_PROTOCOL_ID, chainCategory: "evm", description: "Borrow from Spoke", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "aave-v4.repay", protocolId: AAVE_V4_PROTOCOL_ID, chainCategory: "evm", description: "Repay Spoke debt", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+registerProtocolModule(aaveV4ProtocolModule);
+
+exports.AAVE_V4_GRAPHQL_URL = AAVE_V4_GRAPHQL_URL;
+exports.AAVE_V4_PROTOCOL_ID = AAVE_V4_PROTOCOL_ID;
+exports.AAVE_V4_SPOKE_BORROW_DEFAULT_GAS_UNITS = AAVE_V4_SPOKE_BORROW_DEFAULT_GAS_UNITS;
+exports.AAVE_V4_SPOKE_REPAY_DEFAULT_GAS_UNITS = AAVE_V4_SPOKE_REPAY_DEFAULT_GAS_UNITS;
+exports.AAVE_V4_SPOKE_SUPPLY_DEFAULT_GAS_UNITS = AAVE_V4_SPOKE_SUPPLY_DEFAULT_GAS_UNITS;
+exports.AAVE_V4_SPOKE_WITHDRAW_DEFAULT_GAS_UNITS = AAVE_V4_SPOKE_WITHDRAW_DEFAULT_GAS_UNITS;
+exports.MIN_AAVE_V4_DEPOSIT_GAS_EXEC = MIN_AAVE_V4_DEPOSIT_GAS_EXEC;
+exports.aaveV4Gql = aaveV4Gql;
+exports.aaveV4KeyForNodeAssetRow = aaveV4KeyForNodeAssetRow;
+exports.aaveV4ProtocolModule = aaveV4ProtocolModule;
+exports.aaveV4UiMarketIdForHubName = aaveV4UiMarketIdForHubName;
+exports.aggregateV4SupplyDisplay = aggregateV4SupplyDisplay;
+exports.borrowableAssetsFromHubReserves = borrowableAssetsFromHubReserves;
+exports.buildAaveV4BorrowTableRowsFromHub = buildAaveV4BorrowTableRowsFromHub;
+exports.buildEvmMultisignBodyAaveV4DepositBatch = buildEvmMultisignBodyAaveV4DepositBatch;
+exports.buildEvmMultisignBodyAaveV4MerklClaimRewards = buildEvmMultisignBodyAaveV4MerklClaimRewards;
+exports.buildEvmMultisignBodyAaveV4SpokeBorrow = buildEvmMultisignBodyAaveV4SpokeBorrow;
+exports.buildEvmMultisignBodyAaveV4SpokeRepay = buildEvmMultisignBodyAaveV4SpokeRepay;
+exports.buildEvmMultisignBodyAaveV4SpokeWithdraw = buildEvmMultisignBodyAaveV4SpokeWithdraw;
+exports.buildEvmMultisignBodyEulerV2MerklDistributorClaim = buildEvmMultisignBodyEulerV2MerklDistributorClaim;
+exports.buildEvmMultisignBodyEulerV2ReulUnlock = buildEvmMultisignBodyEulerV2ReulUnlock;
+exports.ensureAaveV4ChainTokenCache = ensureAaveV4ChainTokenCache;
+exports.fetchAaveV4Chains = fetchAaveV4Chains;
+exports.fetchAaveV4HubReserves = fetchAaveV4HubReserves;
+exports.fetchAaveV4HubsForChain = fetchAaveV4HubsForChain;
+exports.fetchAaveV4NativeWrappedToken = fetchAaveV4NativeWrappedToken;
+exports.fetchAaveV4ReservesForUnderlying = fetchAaveV4ReservesForUnderlying;
+exports.fetchAaveV4SpokeReserveIdForUnderlying = fetchAaveV4SpokeReserveIdForUnderlying;
+exports.fetchAaveV4SpokeReserveStatusForUnderlying = fetchAaveV4SpokeReserveStatusForUnderlying;
+exports.fetchAaveV4SupportedUnderlyingAddressSet = fetchAaveV4SupportedUnderlyingAddressSet;
+exports.fetchAaveV4UserBorrowsDebtByUnderlyingForHub = fetchAaveV4UserBorrowsDebtByUnderlyingForHub;
+exports.findAaveV4HubReserveForChainUnderlying = findAaveV4HubReserveForChainUnderlying;
+exports.findHubReserveForUnderlying = findHubReserveForUnderlying;
+exports.formatAaveV4AmountHumanFromApiString = formatAaveV4AmountHumanFromApiString;
+exports.formatAaveV4PercentDisplay = formatAaveV4PercentDisplay;
+exports.formatAaveV4ReserveLiquidityFromSummary = formatAaveV4ReserveLiquidityFromSummary;
+exports.formatAaveV4RiskDisplay = formatAaveV4RiskDisplay;
+exports.formatAaveV4TokenAmount = formatAaveV4TokenAmount;
+exports.isAaveV4DepositEvmSignRequest = isAaveV4DepositEvmSignRequest;
+exports.loadAaveV4SupportedChainIdsFromV4Api = loadAaveV4SupportedChainIdsFromV4Api;
+exports.pickAaveV4ReserveRowForSpoke = pickAaveV4ReserveRowForSpoke;
+exports.resolveAaveV4DepositGasUnitsFromSignRequest = resolveAaveV4DepositGasUnitsFromSignRequest;
+exports.resolveAaveV4HubForUiMarket = resolveAaveV4HubForUiMarket;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map