@hypurrquant/defi-cli 1.0.11 → 1.0.13

package/dist/main.js

@@ -18,6 +18,12 @@ import { resolve } from "path";
 import { fileURLToPath } from "url";
 import { parse } from "smol-toml";
 import { existsSync } from "fs";
+function defaultSwapSlippage() {
+  return { bps: 50 };
+}
+function applyMinSlippage(slippage, amount) {
+  return amount * BigInt(1e4 - slippage.bps) / 10000n;
+}
 function jsonReplacerDecimal(_key, value) {
   if (typeof value === "bigint") {
     return value.toString();
@@ -55,11 +61,15 @@ function buildTransfer(token, to, amount) {
     gas_estimate: 65e3
   };
 }
-function getProvider(rpcUrl) {
-  const cached = providerCache.get(rpcUrl);
+function getProvider(rpcUrl, chain) {
+  const key = chain ? `${rpcUrl}@${chain.id}` : rpcUrl;
+  const cached = providerCache.get(key);
   if (cached) return cached;
-  const client = createPublicClient({ transport: http(rpcUrl) });
-  providerCache.set(rpcUrl, client);
+  const client = createPublicClient({
+    transport: http(rpcUrl),
+    ...chain ? { chain } : {}
+  });
+  providerCache.set(key, client);
   return client;
 }
 async function multicallRead(rpcUrl, calls) {
@@ -229,6 +239,28 @@ var init_dist = __esm({
         const chainEnv = this.name.toUpperCase().replace(/ /g, "_") + "_RPC_URL";
         return process.env[chainEnv] ?? this.rpc_url;
       }
+      /**
+       * Build a viem Chain object pinned to this config so wallet/public clients
+       * can sign with an explicit chainId rather than auto-fetching it from the
+       * RPC. SSOT 7.4: anchoring chainId at client-construction time defends
+       * against an MITM RPC that returns the wrong eth_chainId, and keeps
+       * offline signing safe against RPC drift.
+       */
+      viemChain() {
+        const rpcUrl = this.effectiveRpcUrl();
+        return {
+          id: this.chain_id,
+          name: this.name,
+          nativeCurrency: {
+            name: this.native_token,
+            symbol: this.native_token,
+            decimals: 18
+          },
+          rpcUrls: { default: { http: [rpcUrl] } },
+          ...this.explorer_url ? { blockExplorers: { default: { name: this.name, url: this.explorer_url } } } : {},
+          ...this.multicall3 ? { contracts: { multicall3: { address: this.multicall3 } } } : {}
+        };
+      }
     };
     ProtocolCategory = /* @__PURE__ */ ((ProtocolCategory2) => {
       ProtocolCategory2["Dex"] = "dex";
@@ -420,13 +452,13 @@ __export(dist_exports, {
 import { encodeFunctionData as encodeFunctionData4, parseAbi as parseAbi4, createPublicClient as createPublicClient4, http as http4, decodeAbiParameters } from "viem";
 import { encodeFunctionData as encodeFunctionData22, parseAbi as parseAbi22, createPublicClient as createPublicClient22, http as http22, decodeFunctionResult as decodeFunctionResult2, decodeAbiParameters as decodeAbiParameters2 } from "viem";
 import { encodeFunctionData as encodeFunctionData32, parseAbi as parseAbi32, createPublicClient as createPublicClient32, http as http32, decodeAbiParameters as decodeAbiParameters3, concatHex, zeroAddress } from "viem";
-import { encodeFunctionData as encodeFunctionData42, parseAbi as parseAbi42, zeroAddress as zeroAddress2 } from "viem";
+import { encodeFunctionData as encodeFunctionData42, parseAbi as parseAbi42 } from "viem";
 import { encodeFunctionData as encodeFunctionData5, parseAbi as parseAbi5 } from "viem";
 import { encodeFunctionData as encodeFunctionData6, parseAbi as parseAbi6, decodeAbiParameters as decodeAbiParameters4 } from "viem";
-import { encodeFunctionData as encodeFunctionData7, parseAbi as parseAbi7, createPublicClient as createPublicClient42, http as http42, zeroAddress as zeroAddress3 } from "viem";
-import { createPublicClient as createPublicClient5, decodeFunctionResult as decodeFunctionResult22, encodeFunctionData as encodeFunctionData8, http as http5, parseAbi as parseAbi8, zeroAddress as zeroAddress4 } from "viem";
-import { encodeFunctionData as encodeFunctionData9, parseAbi as parseAbi9, zeroAddress as zeroAddress5 } from "viem";
-import { createPublicClient as createPublicClient6, decodeFunctionResult as decodeFunctionResult3, encodeFunctionData as encodeFunctionData10, http as http6, parseAbi as parseAbi10, zeroAddress as zeroAddress6 } from "viem";
+import { encodeFunctionData as encodeFunctionData7, parseAbi as parseAbi7, createPublicClient as createPublicClient42, http as http42, zeroAddress as zeroAddress2 } from "viem";
+import { createPublicClient as createPublicClient5, decodeFunctionResult as decodeFunctionResult22, encodeFunctionData as encodeFunctionData8, http as http5, parseAbi as parseAbi8, zeroAddress as zeroAddress3 } from "viem";
+import { encodeFunctionData as encodeFunctionData9, parseAbi as parseAbi9, zeroAddress as zeroAddress4 } from "viem";
+import { createPublicClient as createPublicClient6, decodeFunctionResult as decodeFunctionResult3, encodeFunctionData as encodeFunctionData10, http as http6, parseAbi as parseAbi10, zeroAddress as zeroAddress5 } from "viem";
 import { encodeFunctionData as encodeFunctionData11, parseAbi as parseAbi11, createPublicClient as createPublicClient7, http as http7 } from "viem";
 import {
   encodeFunctionData as encodeFunctionData12,
@@ -444,24 +476,24 @@ import {
   keccak256,
   parseAbi as parseAbi13,
   decodeFunctionResult as decodeFunctionResult5,
-  zeroAddress as zeroAddress7
+  zeroAddress as zeroAddress6
 } from "viem";
-import { createPublicClient as createPublicClient10, http as http10, parseAbi as parseAbi14, encodeFunctionData as encodeFunctionData14, decodeFunctionResult as decodeFunctionResult6, zeroAddress as zeroAddress8 } from "viem";
-import { createPublicClient as createPublicClient11, http as http11, parseAbi as parseAbi15, encodeFunctionData as encodeFunctionData15, zeroAddress as zeroAddress9 } from "viem";
+import { createPublicClient as createPublicClient10, http as http10, parseAbi as parseAbi14, encodeFunctionData as encodeFunctionData14, decodeFunctionResult as decodeFunctionResult6, zeroAddress as zeroAddress7 } from "viem";
+import { createPublicClient as createPublicClient11, http as http11, parseAbi as parseAbi15, encodeFunctionData as encodeFunctionData15, zeroAddress as zeroAddress8 } from "viem";
 import { createPublicClient as createPublicClient12, http as http12, parseAbi as parseAbi16 } from "viem";
 import { createPublicClient as createPublicClient13, http as http13, parseAbi as parseAbi17, encodeFunctionData as encodeFunctionData16 } from "viem";
 import { createPublicClient as createPublicClient14, http as http14, parseAbi as parseAbi18, encodeFunctionData as encodeFunctionData17 } from "viem";
 import { createPublicClient as createPublicClient15, http as http15, parseAbi as parseAbi19, encodeFunctionData as encodeFunctionData18 } from "viem";
-import { parseAbi as parseAbi20, encodeFunctionData as encodeFunctionData19, decodeFunctionResult as decodeFunctionResult7, zeroAddress as zeroAddress10 } from "viem";
-import { createPublicClient as createPublicClient16, http as http16, parseAbi as parseAbi21, encodeFunctionData as encodeFunctionData20, zeroAddress as zeroAddress11 } from "viem";
-import { createPublicClient as createPublicClient17, http as http17, parseAbi as parseAbi222 } from "viem";
-import { createPublicClient as createPublicClient18, http as http18, parseAbi as parseAbi23, encodeFunctionData as encodeFunctionData21 } from "viem";
+import { parseAbi as parseAbi20, encodeFunctionData as encodeFunctionData19, decodeFunctionResult as decodeFunctionResult7, zeroAddress as zeroAddress9, createPublicClient as createPublicClient16, http as http16 } from "viem";
+import { createPublicClient as createPublicClient17, http as http17, parseAbi as parseAbi21, encodeFunctionData as encodeFunctionData20, zeroAddress as zeroAddress10 } from "viem";
+import { createPublicClient as createPublicClient18, http as http18, parseAbi as parseAbi222 } from "viem";
+import { createPublicClient as createPublicClient19, http as http19, parseAbi as parseAbi23, encodeFunctionData as encodeFunctionData21 } from "viem";
 import { parseAbi as parseAbi24, encodeFunctionData as encodeFunctionData222 } from "viem";
-import { createPublicClient as createPublicClient19, http as http19, parseAbi as parseAbi25, encodeFunctionData as encodeFunctionData23, zeroAddress as zeroAddress12 } from "viem";
-import { createPublicClient as createPublicClient20, http as http20, parseAbi as parseAbi26, encodeFunctionData as encodeFunctionData24, zeroAddress as zeroAddress13 } from "viem";
+import { createPublicClient as createPublicClient20, http as http20, parseAbi as parseAbi25, encodeFunctionData as encodeFunctionData23, zeroAddress as zeroAddress11 } from "viem";
+import { createPublicClient as createPublicClient21, http as http21, parseAbi as parseAbi26, encodeFunctionData as encodeFunctionData24, zeroAddress as zeroAddress12 } from "viem";
 import { parseAbi as parseAbi27, encodeFunctionData as encodeFunctionData25 } from "viem";
 import { parseAbi as parseAbi28, encodeFunctionData as encodeFunctionData26 } from "viem";
-import { createPublicClient as createPublicClient21, http as http21, parseAbi as parseAbi29 } from "viem";
+import { createPublicClient as createPublicClient222, http as http222, parseAbi as parseAbi29 } from "viem";
 function pctToTickDelta(pct) {
   return Math.round(Math.log(1 + pct / 100) / Math.log(1.0001));
 }
@@ -715,15 +747,6 @@ function u256ToF642(v) {
   if (v > MAX_U128) return Infinity;
   return Number(v);
 }
-function defaultMarketParams(loanToken = zeroAddress10) {
-  return {
-    loanToken,
-    collateralToken: zeroAddress10,
-    oracle: zeroAddress10,
-    irm: zeroAddress10,
-    lltv: 0n
-  };
-}
 function decodeMarket(data) {
   if (!data) return null;
   try {
@@ -956,7 +979,7 @@ function createKittenSwapFarming(entry, rpcUrl) {
   const bonusRewardToken = entry.contracts?.["bonus_reward_token"];
   return new KittenSwapFarmingAdapter(entry.name, farmingCenter, eternalFarming, positionManager, rpcUrl, factory, rewardToken, bonusRewardToken);
 }
-var DEFAULT_FEE, swapRouterAbi, quoterAbi, ramsesQuoterAbi, positionManagerAbi, slipstreamMintAbi, UniswapV3Adapter, abi, lbQuoterAbi, UniswapV2Adapter, abi2, algebraQuoterAbi, algebraSingleQuoterAbi, algebraIntegralPmAbi, algebraV2PmAbi, algebraSharedPmAbi, AlgebraV3Adapter, abi3, BalancerV3Adapter, poolAbi, CurveStableSwapAdapter, abi4, abiV2, SolidlyAdapter, thenaPmAbi, thenaRouterAbi, thenaPoolAbi, thenaFactoryAbi, ThenaCLAdapter, _addressDecodeAbi, _symbolDecodeAbi, gaugeManagerAbi, gaugeCLAbi, nfpmAbi, veAbi, voterAbi, HybraGaugeAdapter, abi5, WooFiAdapter, gaugeAbi, veAbi2, voterAbi2, _addressDecodeAbi2, _symbolDecodeAbi2, _boolDecodeAbi, HYPEREVM_TOKENS, CL_TICK_SPACINGS, SolidlyGaugeAdapter, masterchefAbi, MasterChefAdapter, lbRouterAbi, lbFactoryAbi, lbPairAbi, lbRewarderAbi, masterChefAbi, veMoeAbi, lbPairBinAbi, lbQuoterAbi2, erc20Abi2, _addressAbi, _uint256Abi, _boolAbi, _rangeAbi, _binAbi, _uint256ArrayAbi, MerchantMoeLBAdapter, KITTEN_TOKEN, WHYPE_TOKEN, MAX_NONCE_SCAN, HYPEREVM_TOKENS2, farmingCenterAbi, positionManagerAbi2, eternalFarmingAbi, algebraFactoryAbi, _addressDecodeAbi3, nonceCache, KittenSwapFarmingAdapter, DEFAULT_BASE_URL, FALLBACK_BASE_URL, NEST_TOKEN, NEST_DECIMALS, NestOffChainAdapter, POOL_ABI, ERC20_ABI2, INCENTIVES_ABI, REWARDS_CONTROLLER_ABI, POOL_PROVIDER_ABI, ADDRESSES_PROVIDER_ABI, ORACLE_ABI, ERC20_DECIMALS_ABI, AaveV3Adapter, POOL_ABI2, ERC20_ABI22, AaveV2Adapter, ORACLE_ABI2, AaveOracleAdapter, CTOKEN_ABI, BSC_BLOCKS_PER_YEAR, CompoundV2Adapter, COMET_ABI, SECONDS_PER_YEAR, CompoundV3Adapter, EULER_VAULT_ABI, SECONDS_PER_YEAR2, EulerV2Adapter, MORPHO_ABI, META_MORPHO_ABI, ERC4626_ABI, MAX_UINT256, IRM_ABI, SECONDS_PER_YEAR3, MorphoBlueAdapter, BORROWER_OPS_ABI, TROVE_MANAGER_ABI, HINT_HELPERS_ABI, SORTED_TROVES_ABI, FelixCdpAdapter, PRICE_FEED_ABI, FelixOracleAdapter, ERC4626_ABI2, ERC4626VaultAdapter, GENERIC_LST_ABI, GenericLstAdapter, STHYPE_ABI, ERC20_ABI3, StHypeAdapter, KINETIQ_ABI, ORACLE_ABI3, WHYPE, HYPERLEND_ORACLE, KinetiqAdapter, PendleAdapter, GenericYieldAdapter, HLP_ABI, HlpVaultAdapter, GenericDerivativesAdapter, RYSK_ABI, RyskAdapter, GenericOptionsAdapter, ERC721_ABI, ERC721Adapter, DexSpotPrice;
+var DEFAULT_FEE, swapRouterAbi, quoterAbi, ramsesQuoterAbi, positionManagerAbi, slipstreamMintAbi, ramsesMintAbi, UniswapV3Adapter, abi, lbQuoterAbi, UniswapV2Adapter, abi2, algebraQuoterAbi, algebraSingleQuoterAbi, algebraIntegralPmAbi, algebraV2PmAbi, algebraSharedPmAbi, AlgebraV3Adapter, abi3, BalancerV3Adapter, poolAbi, CurveStableSwapAdapter, abi4, abiV2, SolidlyAdapter, thenaPmAbi, thenaRouterAbi, thenaPoolAbi, thenaFactoryAbi, ThenaCLAdapter, _addressDecodeAbi, _symbolDecodeAbi, gaugeManagerAbi, gaugeCLAbi, nfpmAbi, veAbi, voterAbi, HybraGaugeAdapter, abi5, WooFiAdapter, gaugeAbi, veAbi2, voterAbi2, _addressDecodeAbi2, _symbolDecodeAbi2, _boolDecodeAbi, HYPEREVM_TOKENS, CL_TICK_SPACINGS, SolidlyGaugeAdapter, masterchefAbi, MasterChefAdapter, lbRouterAbi, lbFactoryAbi, lbPairAbi, lbRewarderAbi, masterChefAbi, veMoeAbi, lbPairBinAbi, lbQuoterAbi2, erc20Abi2, _addressAbi, _uint256Abi, _boolAbi, _rangeAbi, _binAbi, _uint256ArrayAbi, MerchantMoeLBAdapter, KITTEN_TOKEN, WHYPE_TOKEN, MAX_NONCE_SCAN, HYPEREVM_TOKENS2, farmingCenterAbi, positionManagerAbi2, eternalFarmingAbi, algebraFactoryAbi, _addressDecodeAbi3, nonceCache, KittenSwapFarmingAdapter, DEFAULT_BASE_URL, FALLBACK_BASE_URL, NEST_TOKEN, NEST_DECIMALS, NestOffChainAdapter, POOL_ABI, ERC20_ABI2, INCENTIVES_ABI, REWARDS_CONTROLLER_ABI, POOL_PROVIDER_ABI, ADDRESSES_PROVIDER_ABI, ORACLE_ABI, ERC20_DECIMALS_ABI, AaveV3Adapter, POOL_ABI2, ERC20_ABI22, AaveV2Adapter, ORACLE_ABI2, AaveOracleAdapter, CTOKEN_ABI, NATIVE_CTOKEN_ABI, COMPTROLLER_ABI, NATIVE_SENTINEL, BSC_BLOCKS_PER_YEAR, CompoundV2Adapter, COMET_ABI, SECONDS_PER_YEAR, CompoundV3Adapter, EULER_VAULT_ABI, SECONDS_PER_YEAR2, EulerV2Adapter, MORPHO_ABI, META_MORPHO_ABI, ERC4626_ABI, MAX_UINT256, IRM_ABI, SECONDS_PER_YEAR3, MorphoBlueAdapter, BORROWER_OPS_ABI, TROVE_MANAGER_ABI, HINT_HELPERS_ABI, SORTED_TROVES_ABI, FelixCdpAdapter, PRICE_FEED_ABI, FelixOracleAdapter, ERC4626_ABI2, ERC4626VaultAdapter, GENERIC_LST_ABI, GenericLstAdapter, STHYPE_ABI, ERC20_ABI3, StHypeAdapter, KINETIQ_ABI, ORACLE_ABI3, WHYPE, HYPERLEND_ORACLE, KinetiqAdapter, PendleAdapter, GenericYieldAdapter, HLP_ABI, HlpVaultAdapter, GenericDerivativesAdapter, RYSK_ABI, RyskAdapter, GenericOptionsAdapter, ERC721_ABI, ERC721Adapter, DexSpotPrice;
 var init_dist2 = __esm({
   "../defi-protocols/dist/index.js"() {
     "use strict";
@@ -1024,6 +1047,10 @@ var init_dist2 = __esm({
       "struct SlipstreamMintParams { address token0; address token1; int24 tickSpacing; int24 tickLower; int24 tickUpper; uint256 amount0Desired; uint256 amount1Desired; uint256 amount0Min; uint256 amount1Min; address recipient; uint256 deadline; uint160 sqrtPriceX96; }",
       "function mint(SlipstreamMintParams calldata params) external payable returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1)"
     ]);
+    ramsesMintAbi = parseAbi4([
+      "struct RamsesMintParams { address token0; address token1; int24 tickSpacing; int24 tickLower; int24 tickUpper; uint256 amount0Desired; uint256 amount1Desired; uint256 amount0Min; uint256 amount1Min; address recipient; uint256 deadline; }",
+      "function mint(RamsesMintParams calldata params) external payable returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1)"
+    ]);
     UniswapV3Adapter = class {
       protocolName;
       router;
@@ -1033,6 +1060,7 @@ var init_dist2 = __esm({
       fee;
       rpcUrl;
       useTickSpacingQuoter;
+      clStyle;
       constructor(entry, rpcUrl) {
         this.protocolName = entry.name;
         const router = entry.contracts?.["router"];
@@ -1045,6 +1073,7 @@ var init_dist2 = __esm({
         this.factory = entry.contracts?.["factory"];
         this.fee = DEFAULT_FEE;
         this.rpcUrl = rpcUrl;
+        this.clStyle = entry.cl_style;
         this.useTickSpacingQuoter = entry.cl_style === "slipstream" || entry.cl_style === "ramses" || entry.contracts?.["pool_deployer"] !== void 0 || entry.contracts?.["gauge_factory"] !== void 0;
       }
       name() {
@@ -1052,7 +1081,15 @@ var init_dist2 = __esm({
       }
       async buildSwap(params) {
         const deadline = BigInt(params.deadline ?? 18446744073709551615n);
-        const amountOutMinimum = 0n;
+        const amountOutMinimum = params.amount_out_min ?? applyMinSlippage(
+          params.slippage,
+          (await this.quote({
+            protocol: this.protocolName,
+            token_in: params.token_in,
+            token_out: params.token_out,
+            amount_in: params.amount_in
+          })).amount_out
+        );
         const data = encodeFunctionData4({
           abi: swapRouterAbi,
           functionName: "exactInputSingle",
@@ -1218,31 +1255,37 @@ var init_dist2 = __esm({
         if (!pm) {
           throw new DefiError("CONTRACT_ERROR", "Position manager address not configured");
         }
-        const [token0, token1, rawAmount0, rawAmount1] = params.token_a.toLowerCase() < params.token_b.toLowerCase() ? [params.token_a, params.token_b, params.amount_a, params.amount_b] : [params.token_b, params.token_a, params.amount_b, params.amount_a];
+        const isAFirst = params.token_a.toLowerCase() < params.token_b.toLowerCase();
+        const [token0, token1, rawAmount0, rawAmount1] = isAFirst ? [params.token_a, params.token_b, params.amount_a, params.amount_b] : [params.token_b, params.token_a, params.amount_b, params.amount_a];
         const amount0 = rawAmount0 === 0n && rawAmount1 > 0n ? 1n : rawAmount0;
         const amount1 = rawAmount1 === 0n && rawAmount0 > 0n ? 1n : rawAmount1;
+        const slippage = params.slippage ?? defaultSwapSlippage();
+        const minA = params.amount_a_min ?? applyMinSlippage(slippage, params.amount_a);
+        const minB = params.amount_b_min ?? applyMinSlippage(slippage, params.amount_b);
+        const [amount0Min, amount1Min] = isAFirst ? [minA, minB] : [minB, minA];
         let thirdField = this.fee;
         let tickLower = -887220;
         let tickUpper = 887220;
         if (params.pool && this.rpcUrl) {
           const poolAbi2 = parseAbi4([
             "function fee() view returns (uint24)",
-            "function tickSpacing() view returns (int24)",
-            "function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16, uint16, uint16, bool)"
+            "function tickSpacing() view returns (int24)"
           ]);
           const client = createPublicClient4({ transport: http4(this.rpcUrl) });
-          const [poolFee, poolTs, slot0] = await Promise.all([
+          const [poolFee, poolTs, slot0Raw] = await Promise.all([
             client.readContract({ address: params.pool, abi: poolAbi2, functionName: "fee" }).catch(() => null),
             client.readContract({ address: params.pool, abi: poolAbi2, functionName: "tickSpacing" }).catch(() => null),
-            client.readContract({ address: params.pool, abi: poolAbi2, functionName: "slot0" }).catch(() => null)
+            client.call({ to: params.pool, data: "0x3850c7bd" }).then((r) => r.data ?? null).catch(() => null)
           ]);
           if (this.useTickSpacingQuoter && poolTs !== null) {
             thirdField = poolTs;
           } else if (poolFee !== null) {
             thirdField = poolFee;
           }
-          if (params.range_pct !== void 0 && slot0 && poolTs !== null) {
-            const currentTick = slot0[1];
+          if (params.range_pct !== void 0 && slot0Raw && poolTs !== null) {
+            const tickWord = slot0Raw.slice(2 + 64, 2 + 128);
+            const tickU = BigInt("0x" + tickWord);
+            const currentTick = tickU >= 1n << 255n ? Number(tickU - (1n << 256n)) : Number(tickU);
             const rangeTicks = Math.floor(params.range_pct * 100);
             tickLower = Math.floor((currentTick - rangeTicks) / poolTs) * poolTs;
             tickUpper = Math.ceil((currentTick + rangeTicks) / poolTs) * poolTs;
@@ -1250,7 +1293,25 @@ var init_dist2 = __esm({
         }
         if (params.tick_lower !== void 0) tickLower = params.tick_lower;
         if (params.tick_upper !== void 0) tickUpper = params.tick_upper;
-        const data = this.useTickSpacingQuoter ? encodeFunctionData4({
+        const data = this.clStyle === "ramses" ? encodeFunctionData4({
+          abi: ramsesMintAbi,
+          functionName: "mint",
+          args: [
+            {
+              token0,
+              token1,
+              tickSpacing: thirdField,
+              tickLower,
+              tickUpper,
+              amount0Desired: amount0,
+              amount1Desired: amount1,
+              amount0Min,
+              amount1Min,
+              recipient: params.recipient,
+              deadline: BigInt("18446744073709551615")
+            }
+          ]
+        }) : this.useTickSpacingQuoter ? encodeFunctionData4({
           abi: slipstreamMintAbi,
           functionName: "mint",
           args: [
@@ -1262,8 +1323,8 @@ var init_dist2 = __esm({
               tickUpper,
               amount0Desired: amount0,
               amount1Desired: amount1,
-              amount0Min: 0n,
-              amount1Min: 0n,
+              amount0Min,
+              amount1Min,
               recipient: params.recipient,
               deadline: BigInt("18446744073709551615"),
               sqrtPriceX96: 0n
@@ -1281,8 +1342,8 @@ var init_dist2 = __esm({
               tickUpper,
               amount0Desired: amount0,
               amount1Desired: amount1,
-              amount0Min: 0n,
-              amount1Min: 0n,
+              amount0Min,
+              amount1Min,
               recipient: params.recipient,
               deadline: BigInt("18446744073709551615")
             }
@@ -1316,10 +1377,17 @@ var init_dist2 = __esm({
         const liquidity = params.liquidity;
         const MAX_UINT128 = (1n << 128n) - 1n;
         const deadline = BigInt("18446744073709551615");
+        if (params.amount_a_min === void 0 || params.amount_b_min === void 0) {
+          throw DefiError.invalidParam(
+            `[${this.protocolName}] V3 remove_liquidity requires amount_a_min and amount_b_min for slippage protection (SSOT 7.3). Caller must compute expected token outputs from the pool state and apply a slippage tolerance before calling buildRemoveLiquidity.`
+          );
+        }
+        const isAFirst = params.token_a.toLowerCase() < params.token_b.toLowerCase();
+        const [amount0Min, amount1Min] = isAFirst ? [params.amount_a_min, params.amount_b_min] : [params.amount_b_min, params.amount_a_min];
         const decreaseData = encodeFunctionData4({
           abi: positionManagerAbi,
           functionName: "decreaseLiquidity",
-          args: [{ tokenId, liquidity, amount0Min: 0n, amount1Min: 0n, deadline }]
+          args: [{ tokenId, liquidity, amount0Min, amount1Min, deadline }]
         });
         const collectData = encodeFunctionData4({
           abi: positionManagerAbi,
@@ -1617,7 +1685,13 @@ var init_dist2 = __esm({
           to: this.router,
           data,
           value: 0n,
-          gas_estimate: 25e4
+          gas_estimate: 25e4,
+          // Same LP-approval requirement as Solidly forks: the V2 router pulls the
+          // LP pair token via transferFrom and reverts at gas ~42k otherwise.
+          // Caller passes --pool so we can target the pair contract for approval.
+          // Discovered live on Uniswap V2 Monad WMON/AUSD 2026-05-08
+          // (failed tx 0x2268659a…09ae → recovered with this fix).
+          ...params.pool ? { approvals: [{ token: params.pool, spender: this.router, amount: params.liquidity }] } : {}
         };
       }
     };
@@ -1672,7 +1746,15 @@ var init_dist2 = __esm({
       }
       async buildSwap(params) {
         const deadline = BigInt(params.deadline ?? 18446744073709551615n);
-        const amountOutMinimum = 0n;
+        const amountOutMinimum = params.amount_out_min ?? applyMinSlippage(
+          params.slippage,
+          (await this.quote({
+            protocol: this.protocolName,
+            token_in: params.token_in,
+            token_out: params.token_out,
+            amount_in: params.amount_in
+          })).amount_out
+        );
         const data = encodeFunctionData32({
           abi: abi2,
           functionName: "exactInputSingle",
@@ -1786,7 +1868,12 @@ var init_dist2 = __esm({
         if (!pm) {
           throw new DefiError("CONTRACT_ERROR", "Position manager address not configured");
         }
-        const [token0, token1, rawAmount0, rawAmount1] = params.token_a.toLowerCase() < params.token_b.toLowerCase() ? [params.token_a, params.token_b, params.amount_a, params.amount_b] : [params.token_b, params.token_a, params.amount_b, params.amount_a];
+        const isAFirst = params.token_a.toLowerCase() < params.token_b.toLowerCase();
+        const [token0, token1, rawAmount0, rawAmount1] = isAFirst ? [params.token_a, params.token_b, params.amount_a, params.amount_b] : [params.token_b, params.token_a, params.amount_b, params.amount_a];
+        const slippage = params.slippage ?? defaultSwapSlippage();
+        const minA = params.amount_a_min ?? applyMinSlippage(slippage, params.amount_a);
+        const minB = params.amount_b_min ?? applyMinSlippage(slippage, params.amount_b);
+        const [amount0Min, amount1Min] = isAFirst ? [minA, minB] : [minB, minA];
         let tickLower = params.tick_lower ?? -887220;
         let tickUpper = params.tick_upper ?? 887220;
         const isSingleSide = rawAmount0 === 0n || rawAmount1 === 0n;
@@ -1823,11 +1910,11 @@ var init_dist2 = __esm({
         const data = this.useSingleQuoter ? encodeFunctionData32({
           abi: algebraV2PmAbi,
           functionName: "mint",
-          args: [{ token0, token1, tickLower, tickUpper, amount0Desired: amount0, amount1Desired: amount1, amount0Min: 0n, amount1Min: 0n, recipient: params.recipient, deadline: BigInt("18446744073709551615") }]
+          args: [{ token0, token1, tickLower, tickUpper, amount0Desired: amount0, amount1Desired: amount1, amount0Min, amount1Min, recipient: params.recipient, deadline: BigInt("18446744073709551615") }]
         }) : encodeFunctionData32({
           abi: algebraIntegralPmAbi,
           functionName: "mint",
-          args: [{ token0, token1, deployer: zeroAddress, tickLower, tickUpper, amount0Desired: amount0, amount1Desired: amount1, amount0Min: 0n, amount1Min: 0n, recipient: params.recipient, deadline: BigInt("18446744073709551615") }]
+          args: [{ token0, token1, deployer: zeroAddress, tickLower, tickUpper, amount0Desired: amount0, amount1Desired: amount1, amount0Min, amount1Min, recipient: params.recipient, deadline: BigInt("18446744073709551615") }]
         });
         const approvals = [];
         if (amount0 > 0n) approvals.push({ token: token0, spender: pm, amount: amount0 });
@@ -1845,12 +1932,19 @@ var init_dist2 = __esm({
         const pm = this.positionManager;
         if (!pm) throw DefiError.contractError(`[${this.protocolName}] Missing 'position_manager'`);
         if (!params.token_id) throw DefiError.invalidParam(`[${this.protocolName}] V3 remove_liquidity requires --token-id`);
+        if (params.amount_a_min === void 0 || params.amount_b_min === void 0) {
+          throw DefiError.invalidParam(
+            `[${this.protocolName}] remove_liquidity requires amount_a_min and amount_b_min for slippage protection (SSOT 7.3). Compute expected outputs from positions(tokenId) + pool.globalState off-chain and apply tolerance.`
+          );
+        }
+        const isAFirst = params.token_a.toLowerCase() < params.token_b.toLowerCase();
+        const [amount0Min, amount1Min] = isAFirst ? [params.amount_a_min, params.amount_b_min] : [params.amount_b_min, params.amount_a_min];
         const MAX_UINT128 = (1n << 128n) - 1n;
         const deadline = BigInt("18446744073709551615");
         const decreaseData = encodeFunctionData32({
           abi: algebraSharedPmAbi,
           functionName: "decreaseLiquidity",
-          args: [{ tokenId: params.token_id, liquidity: params.liquidity, amount0Min: 0n, amount1Min: 0n, deadline }]
+          args: [{ tokenId: params.token_id, liquidity: params.liquidity, amount0Min, amount1Min, deadline }]
         });
         const collectData = encodeFunctionData32({
           abi: algebraSharedPmAbi,
@@ -1877,6 +1971,7 @@ var init_dist2 = __esm({
     BalancerV3Adapter = class {
       protocolName;
       router;
+      pool;
       constructor(entry, _rpcUrl) {
         this.protocolName = entry.name;
         const router = entry.contracts?.["router"];
@@ -1884,19 +1979,29 @@ var init_dist2 = __esm({
           throw new DefiError("CONTRACT_ERROR", "Missing 'router' contract");
         }
         this.router = router;
+        this.pool = entry.contracts?.["pool"];
       }
       name() {
         return this.protocolName;
       }
       async buildSwap(params) {
-        const minAmountOut = 0n;
+        if (params.amount_out_min === void 0) {
+          throw DefiError.invalidParam(
+            `[${this.protocolName}] buildSwap requires amount_out_min for slippage protection (SSOT 7.3) \u2014 Balancer V3 has no on-chain quoter wired in this adapter. Compute the floor off-chain (e.g. via the Vault's static-call simulation) and pass it explicitly.`
+          );
+        }
+        if (!this.pool) {
+          throw DefiError.invalidParam(
+            `[${this.protocolName}] buildSwap requires a pool address. Register the pool under [protocol.contracts] as \`pool = "0x..."\` in the protocol's TOML config. Multi-pool routing is intentionally not implemented in this adapter \u2014 for that, quote against the Balancer V3 BatchRouter off-chain and route via a different surface.`
+          );
+        }
+        const minAmountOut = params.amount_out_min;
         const deadline = BigInt(params.deadline ?? 18446744073709551615n);
         const data = encodeFunctionData42({
           abi: abi3,
           functionName: "swapSingleTokenExactIn",
           args: [
-            zeroAddress2,
-            // TODO: resolve pool from registry
+            this.pool,
             params.token_in,
             params.token_out,
             params.amount_in,
@@ -1907,7 +2012,7 @@ var init_dist2 = __esm({
           ]
         });
         return {
-          description: `[${this.protocolName}] Swap ${params.amount_in} via Balancer V3`,
+          description: `[${this.protocolName}] Swap ${params.amount_in} via Balancer V3 pool ${this.pool}`,
           to: this.router,
           data,
           value: 0n,
@@ -1927,8 +2032,8 @@ var init_dist2 = __esm({
     poolAbi = parseAbi5([
       "function exchange(int128 i, int128 j, uint256 dx, uint256 min_dy) external returns (uint256)",
       "function get_dy(int128 i, int128 j, uint256 dx) external view returns (uint256)",
-      "function add_liquidity(uint256[2] amounts, uint256 min_mint_amount) external returns (uint256)",
-      "function remove_liquidity(uint256 amount, uint256[2] min_amounts) external returns (uint256[2])"
+      "function add_liquidity(uint256[] amounts, uint256 min_mint_amount) external returns (uint256)",
+      "function remove_liquidity(uint256 amount, uint256[] min_amounts) external returns (uint256[])"
     ]);
     CurveStableSwapAdapter = class {
       protocolName;
@@ -1963,28 +2068,42 @@ var init_dist2 = __esm({
         throw DefiError.unsupported(`[${this.protocolName}] quote requires RPC connection`);
       }
       async buildAddLiquidity(params) {
+        if (!params.pool) {
+          throw DefiError.invalidParam(
+            `[${this.protocolName}] Curve add_liquidity needs --pool <address>. The router does not proxy this call; it lives on the pool itself.`
+          );
+        }
         const data = encodeFunctionData5({
           abi: poolAbi,
           functionName: "add_liquidity",
           args: [[params.amount_a, params.amount_b], 0n]
         });
+        const approvals = [];
+        if (params.amount_a > 0n) approvals.push({ token: params.token_a, spender: params.pool, amount: params.amount_a });
+        if (params.amount_b > 0n) approvals.push({ token: params.token_b, spender: params.pool, amount: params.amount_b });
         return {
-          description: `[${this.protocolName}] Curve add liquidity`,
-          to: this.router,
+          description: `[${this.protocolName}] Curve add liquidity to ${params.pool}`,
+          to: params.pool,
           data,
           value: 0n,
-          gas_estimate: 4e5
+          gas_estimate: 4e5,
+          approvals
         };
       }
       async buildRemoveLiquidity(params) {
+        if (!params.pool) {
+          throw DefiError.invalidParam(
+            `[${this.protocolName}] Curve remove_liquidity needs --pool <address>. The router does not proxy this call.`
+          );
+        }
         const data = encodeFunctionData5({
           abi: poolAbi,
           functionName: "remove_liquidity",
           args: [params.liquidity, [0n, 0n]]
         });
         return {
-          description: `[${this.protocolName}] Curve remove liquidity`,
-          to: this.router,
+          description: `[${this.protocolName}] Curve remove liquidity from ${params.pool}`,
+          to: params.pool,
           data,
           value: 0n,
           gas_estimate: 35e4
@@ -2150,7 +2269,12 @@ var init_dist2 = __esm({
           to: this.router,
           data,
           value: 0n,
-          gas_estimate: 3e5
+          gas_estimate: 3e5,
+          // The router pulls the LP token via transferFrom; without this approval
+          // the tx reverts at gas ~42k. Caller must pass --pool so we know which
+          // LP pair to approve. Discovered live on Aerodrome USDC/USDT 2026-05-08
+          // (failed tx 0x6d052e0a…3298 → recovered with manual approve 0xa126fc3a).
+          ...params.pool ? { approvals: [{ token: params.pool, spender: this.router, amount: params.liquidity }] } : {}
         };
       }
     };
@@ -2197,6 +2321,11 @@ var init_dist2 = __esm({
         return this.protocolName;
       }
       async buildSwap(params) {
+        if (params.amount_out_min === void 0) {
+          throw DefiError.invalidParam(
+            `[${this.protocolName}] buildSwap requires amount_out_min for slippage protection (SSOT 7.3) \u2014 Thena CL has no on-chain quoter. Compute the floor off-chain (e.g. via the router's static-call simulation) and pass it explicitly.`
+          );
+        }
         const data = encodeFunctionData7({
           abi: thenaRouterAbi,
           functionName: "exactInputSingle",
@@ -2207,7 +2336,7 @@ var init_dist2 = __esm({
             recipient: params.recipient,
             deadline: BigInt(params.deadline ?? 18446744073709551615n),
             amountIn: params.amount_in,
-            amountOutMinimum: 0n,
+            amountOutMinimum: params.amount_out_min,
             sqrtPriceLimitX96: 0n
           }]
         });
@@ -2227,7 +2356,12 @@ var init_dist2 = __esm({
         const pm = this.positionManager;
         if (!pm) throw new DefiError("CONTRACT_ERROR", "Position manager not configured");
         if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required");
-        const [token0, token1, rawAmount0, rawAmount1] = params.token_a.toLowerCase() < params.token_b.toLowerCase() ? [params.token_a, params.token_b, params.amount_a, params.amount_b] : [params.token_b, params.token_a, params.amount_b, params.amount_a];
+        const isAFirst = params.token_a.toLowerCase() < params.token_b.toLowerCase();
+        const [token0, token1, rawAmount0, rawAmount1] = isAFirst ? [params.token_a, params.token_b, params.amount_a, params.amount_b] : [params.token_b, params.token_a, params.amount_b, params.amount_a];
+        const slippage = params.slippage ?? defaultSwapSlippage();
+        const minA = params.amount_a_min ?? applyMinSlippage(slippage, params.amount_a);
+        const minB = params.amount_b_min ?? applyMinSlippage(slippage, params.amount_b);
+        const [amount0Min, amount1Min] = isAFirst ? [minA, minB] : [minB, minA];
         const client = createPublicClient42({ transport: http42(this.rpcUrl) });
         const poolAddr = params.pool;
         let tickSpacing = this.defaultTickSpacing;
@@ -2242,7 +2376,7 @@ var init_dist2 = __esm({
               functionName: "getPool",
               args: [token0, token1, tickSpacing]
             });
-            if (pool === zeroAddress3) throw new DefiError("CONTRACT_ERROR", "Pool not found");
+            if (pool === zeroAddress2) throw new DefiError("CONTRACT_ERROR", "Pool not found");
           }
           if (pool) {
             const [slot0, ts] = await Promise.all([
@@ -2285,8 +2419,8 @@ var init_dist2 = __esm({
             tickUpper,
             amount0Desired: rawAmount0,
             amount1Desired: rawAmount1,
-            amount0Min: 0n,
-            amount1Min: 0n,
+            amount0Min,
+            amount1Min,
             recipient: params.recipient,
             deadline: BigInt("18446744073709551615"),
             sqrtPriceX96: 0n
@@ -2308,12 +2442,19 @@ var init_dist2 = __esm({
         const pm = this.positionManager;
         if (!pm) throw DefiError.contractError(`[${this.protocolName}] Missing 'position_manager'`);
         if (!params.token_id) throw DefiError.invalidParam(`[${this.protocolName}] V3 remove_liquidity requires --token-id`);
+        if (params.amount_a_min === void 0 || params.amount_b_min === void 0) {
+          throw DefiError.invalidParam(
+            `[${this.protocolName}] remove_liquidity requires amount_a_min and amount_b_min for slippage protection (SSOT 7.3). Compute expected outputs from positions(tokenId) + pool.slot0 off-chain and apply tolerance.`
+          );
+        }
+        const isAFirst = params.token_a.toLowerCase() < params.token_b.toLowerCase();
+        const [amount0Min, amount1Min] = isAFirst ? [params.amount_a_min, params.amount_b_min] : [params.amount_b_min, params.amount_a_min];
         const MAX_UINT128 = (1n << 128n) - 1n;
         const deadline = BigInt("18446744073709551615");
         const decreaseData = encodeFunctionData7({
           abi: thenaPmAbi,
           functionName: "decreaseLiquidity",
-          args: [{ tokenId: params.token_id, liquidity: params.liquidity, amount0Min: 0n, amount1Min: 0n, deadline }]
+          args: [{ tokenId: params.token_id, liquidity: params.liquidity, amount0Min, amount1Min, deadline }]
         });
         const collectData = encodeFunctionData7({
           abi: thenaPmAbi,
@@ -2380,8 +2521,8 @@ var init_dist2 = __esm({
         const ve = entry.contracts?.["ve_token"];
         if (!ve) throw new DefiError("CONTRACT_ERROR", "Missing 've_token' contract");
         this.veToken = ve;
-        this.voter = entry.contracts?.["voter"] ?? zeroAddress4;
-        this.positionManager = entry.contracts?.["position_manager"] ?? zeroAddress4;
+        this.voter = entry.contracts?.["voter"] ?? zeroAddress3;
+        this.positionManager = entry.contracts?.["position_manager"] ?? zeroAddress3;
         this.poolFactory = entry.contracts?.["pool_factory"];
         this.rpcUrl = rpcUrl;
       }
@@ -2423,7 +2564,7 @@ var init_dist2 = __esm({
           ]);
         }
         const poolAddressResults = await multicallRead(this.rpcUrl, poolAddressCalls);
-        const pools = poolAddressResults.map((r) => decodeAddress(r)).filter((a) => a !== null && a !== zeroAddress4);
+        const pools = poolAddressResults.map((r) => decodeAddress(r)).filter((a) => a !== null && a !== zeroAddress3);
         if (pools.length === 0) return [];
         const gaugeCalls = pools.map((pool) => [
           this.gaugeManager,
@@ -2433,7 +2574,7 @@ var init_dist2 = __esm({
         const gaugedPools = [];
         for (let i = 0; i < pools.length; i++) {
           const gauge = decodeAddress(gaugeResults[i] ?? null);
-          if (gauge && gauge !== zeroAddress4) {
+          if (gauge && gauge !== zeroAddress3) {
             gaugedPools.push({ pool: pools[i], gauge });
           }
         }
@@ -2448,8 +2589,8 @@ var init_dist2 = __esm({
         for (let i = 0; i < gaugedPools.length; i++) {
           const t0 = decodeAddress(tokenResults[i * 2] ?? null);
           const t1 = decodeAddress(tokenResults[i * 2 + 1] ?? null);
-          if (t0 && t0 !== zeroAddress4) tokenAddrs.add(t0);
-          if (t1 && t1 !== zeroAddress4) tokenAddrs.add(t1);
+          if (t0 && t0 !== zeroAddress3) tokenAddrs.add(t0);
+          if (t1 && t1 !== zeroAddress3) tokenAddrs.add(t1);
         }
         const uniqueTokens = Array.from(tokenAddrs);
         const symbolCalls = uniqueTokens.map((t) => [
@@ -2488,7 +2629,7 @@ var init_dist2 = __esm({
           functionName: "gauges",
           args: [pool]
         });
-        if (gauge === zeroAddress4) throw new DefiError("CONTRACT_ERROR", `No gauge for pool ${pool}`);
+        if (gauge === zeroAddress3) throw new DefiError("CONTRACT_ERROR", `No gauge for pool ${pool}`);
         return gauge;
       }
       // ─── CL Gauge: NFT Deposit/Withdraw ──────────────────────────
@@ -2650,7 +2791,7 @@ var init_dist2 = __esm({
             params.amount_in,
             minToAmount,
             params.recipient,
-            zeroAddress5
+            zeroAddress4
           ]
         });
         return {
@@ -2875,7 +3016,7 @@ var init_dist2 = __esm({
             poolCalls.push([this.voter, encodeFunctionData10({ abi: voterPoolsAbi, functionName: "pools", args: [BigInt(i)] })]);
           }
           const poolResults = await multicallRead(this.rpcUrl, poolCalls);
-          pairs = poolResults.map((r) => decodeAddress2(r)).filter((a) => a !== null && a !== zeroAddress6);
+          pairs = poolResults.map((r) => decodeAddress2(r)).filter((a) => a !== null && a !== zeroAddress5);
         } else {
           const v2FactoryAbi = parseAbi10(["function allPairsLength() view returns (uint256)", "function allPairs(uint256) view returns (address)"]);
           const solidlyFactoryAbi = parseAbi10(["function allPoolsLength() view returns (uint256)", "function allPools(uint256) view returns (address)"]);
@@ -2900,17 +3041,17 @@ var init_dist2 = __esm({
           const pairCalls = [];
           for (let i = startIdx; i < count; i++) pairCalls.push([this.v2Factory, encodeFunctionData10({ abi: fetchAbi, functionName: fetchFn, args: [BigInt(i)] })]);
           const pairResults = await multicallRead(this.rpcUrl, pairCalls);
-          pairs = pairResults.map((r) => decodeAddress2(r)).filter((a) => a !== null && a !== zeroAddress6);
+          pairs = pairResults.map((r) => decodeAddress2(r)).filter((a) => a !== null && a !== zeroAddress5);
         }
         if (pairs.length === 0) return;
         const gaugeCalls = pairs.map((p) => [this.voter, encodeFunctionData10({ abi: gaugeForPoolAbi, functionName: "gaugeForPool", args: [p] })]);
         let gaugeResults = await multicallRead(this.rpcUrl, gaugeCalls);
-        const allNull = gaugeResults.every((r) => !r || decodeAddress2(r) === zeroAddress6 || decodeAddress2(r) === null);
+        const allNull = gaugeResults.every((r) => !r || decodeAddress2(r) === zeroAddress5 || decodeAddress2(r) === null);
         if (allNull) {
           const fb1 = pairs.map((p) => [this.voter, encodeFunctionData10({ abi: poolToGaugeAbi, functionName: "poolToGauge", args: [p] })]);
           gaugeResults = await multicallRead(this.rpcUrl, fb1);
         }
-        const allNull2 = gaugeResults.every((r) => !r || decodeAddress2(r) === zeroAddress6 || decodeAddress2(r) === null);
+        const allNull2 = gaugeResults.every((r) => !r || decodeAddress2(r) === zeroAddress5 || decodeAddress2(r) === null);
         if (allNull2) {
           const fb2 = pairs.map((p) => [this.voter, encodeFunctionData10({ abi: gaugesAbi, functionName: "gauges", args: [p] })]);
           gaugeResults = await multicallRead(this.rpcUrl, fb2);
@@ -2918,7 +3059,7 @@ var init_dist2 = __esm({
         const gaugedPairs = [];
         for (let i = 0; i < pairs.length; i++) {
           const gauge = decodeAddress2(gaugeResults[i] ?? null);
-          if (gauge && gauge !== zeroAddress6) {
+          if (gauge && gauge !== zeroAddress5) {
             gaugedPairs.push({ pair: pairs[i], gauge });
           }
         }
@@ -2934,8 +3075,8 @@ var init_dist2 = __esm({
         for (let i = 0; i < gaugedPairs.length; i++) {
           const t0 = decodeAddress2(metaResults[i * 3] ?? null);
           const t1 = decodeAddress2(metaResults[i * 3 + 1] ?? null);
-          if (t0 && t0 !== zeroAddress6) tokenAddrs.add(t0);
-          if (t1 && t1 !== zeroAddress6) tokenAddrs.add(t1);
+          if (t0 && t0 !== zeroAddress5) tokenAddrs.add(t0);
+          if (t1 && t1 !== zeroAddress5) tokenAddrs.add(t1);
         }
         const uniqueTokens = Array.from(tokenAddrs);
         const symbolCalls = uniqueTokens.map((t) => [
@@ -3025,7 +3166,7 @@ var init_dist2 = __esm({
         const candidatePools = [];
         for (let i = 0; i < getPoolCalls.length; i++) {
           const pool = decodeAddress2(getPoolResults[i] ?? null);
-          if (pool && pool !== zeroAddress6) {
+          if (pool && pool !== zeroAddress5) {
             const { pairIdx, tickSpacing } = callMeta[i];
             const [tokenA, tokenB] = pairs[pairIdx];
             candidatePools.push({ pool, tokenA, tokenB, tickSpacing });
@@ -3037,7 +3178,7 @@ var init_dist2 = __esm({
           encodeFunctionData10({ abi: gaugeForPoolAbi, functionName: "gaugeForPool", args: [pool] })
         ]);
         let gaugeResults = await multicallRead(this.rpcUrl, gaugeCalls);
-        const allNull = gaugeResults.every((r) => !r || decodeAddress2(r) === zeroAddress6 || decodeAddress2(r) === null);
+        const allNull = gaugeResults.every((r) => !r || decodeAddress2(r) === zeroAddress5 || decodeAddress2(r) === null);
         if (allNull) {
           const fallbackCalls = candidatePools.map(({ pool }) => [
             this.voter,
@@ -3048,7 +3189,7 @@ var init_dist2 = __esm({
         const gaugedCL = [];
         for (let i = 0; i < candidatePools.length; i++) {
           const gauge = decodeAddress2(gaugeResults[i] ?? null);
-          if (gauge && gauge !== zeroAddress6) {
+          if (gauge && gauge !== zeroAddress5) {
             gaugedCL.push({ ...candidatePools[i], gauge });
           }
         }
@@ -3078,8 +3219,8 @@ var init_dist2 = __esm({
           const { pool, gauge, tokenA, tokenB, tickSpacing } = gaugedCL[i];
           const rawT0 = decodeAddress2(poolTokenResults[i * 2] ?? null);
           const rawT1 = decodeAddress2(poolTokenResults[i * 2 + 1] ?? null);
-          const t0 = rawT0 && rawT0 !== zeroAddress6 ? rawT0 : tokenA;
-          const t1 = rawT1 && rawT1 !== zeroAddress6 ? rawT1 : tokenB;
+          const t0 = rawT0 && rawT0 !== zeroAddress5 ? rawT0 : tokenA;
+          const t1 = rawT1 && rawT1 !== zeroAddress5 ? rawT1 : tokenB;
           out.push({
             pool,
             gauge,
@@ -3181,7 +3322,7 @@ var init_dist2 = __esm({
               functionName: fn,
               args: [pool]
             });
-            if (gauge !== zeroAddress6) return gauge;
+            if (gauge !== zeroAddress5) return gauge;
           } catch {
           }
         }
@@ -3235,7 +3376,7 @@ var init_dist2 = __esm({
             abi: gaugeAbi,
             functionName: "rewardToken"
           });
-          if (rt !== zeroAddress6) return { tokens: [rt], multiToken: false };
+          if (rt !== zeroAddress5) return { tokens: [rt], multiToken: false };
         } catch {
         }
         return { tokens: [], multiToken: false };
@@ -3245,7 +3386,7 @@ var init_dist2 = __esm({
           const data = encodeFunctionData10({
             abi: gaugeAbi,
             functionName: "getReward",
-            args: [account ?? zeroAddress6]
+            args: [account ?? zeroAddress5]
           });
           return { description: `[${this.protocolName}] Claim gauge rewards`, to: gauge, data, value: 0n, gas_estimate: 2e5 };
         }
@@ -3469,7 +3610,7 @@ var init_dist2 = __esm({
               functionName: "earned",
               args: [user]
             });
-            results.push({ token: zeroAddress6, symbol: "unknown", amount: earned });
+            results.push({ token: zeroAddress5, symbol: "unknown", amount: earned });
           } catch {
           }
         }
@@ -3831,20 +3972,47 @@ var init_dist2 = __esm({
       /**
        * Build an addLiquidity transaction for a Liquidity Book pair.
        * Distributes tokenX/tokenY uniformly across active bin ± numBins.
+       *
+       * The LB pair stores tokenX/tokenY in the order set at factory creation,
+       * which is **not** address-sorted. Callers may pass tokens in either order;
+       * we always re-align with the pool's `getTokenX/getTokenY` (and swap amounts
+       * accordingly) so the router's `if (tokenX != pair.tokenX) revert` path is
+       * never hit.
        */
       async buildAddLiquidity(params) {
         const numBins = params.numBins ?? 5;
         const deadline = params.deadline ?? BigInt("18446744073709551615");
-        let activeIdDesired = params.activeIdDesired;
-        if (activeIdDesired === void 0) {
-          const rpcUrl = this.requireRpc();
-          const client = createPublicClient8({ transport: http8(rpcUrl) });
-          const activeId = await client.readContract({
-            address: params.pool,
-            abi: lbPairAbi,
-            functionName: "getActiveId"
-          });
-          activeIdDesired = activeId;
+        const rpcUrl = this.requireRpc();
+        const client = createPublicClient8({ transport: http8(rpcUrl) });
+        const [poolTokenX, poolTokenY, onChainActiveId] = await Promise.all([
+          client.readContract({ address: params.pool, abi: lbPairAbi, functionName: "getTokenX" }),
+          client.readContract({ address: params.pool, abi: lbPairAbi, functionName: "getTokenY" }),
+          params.activeIdDesired === void 0 ? client.readContract({ address: params.pool, abi: lbPairAbi, functionName: "getActiveId" }) : Promise.resolve(params.activeIdDesired)
+        ]);
+        const activeIdDesired = onChainActiveId;
+        const inX = params.tokenX.toLowerCase();
+        const inY = params.tokenY.toLowerCase();
+        const poolX = poolTokenX.toLowerCase();
+        const poolY = poolTokenY.toLowerCase();
+        let tokenX;
+        let tokenY;
+        let amountX;
+        let amountY;
+        if (inX === poolX && inY === poolY) {
+          tokenX = params.tokenX;
+          tokenY = params.tokenY;
+          amountX = params.amountX;
+          amountY = params.amountY;
+        } else if (inX === poolY && inY === poolX) {
+          tokenX = poolTokenX;
+          tokenY = poolTokenY;
+          amountX = params.amountY;
+          amountY = params.amountX;
+        } else {
+          throw new DefiError(
+            "CONTRACT_ERROR",
+            `[${this.protocolName}] tokenX/tokenY ${params.tokenX}/${params.tokenY} do not match pool ${params.pool} (${poolTokenX}/${poolTokenY})`
+          );
         }
         const deltaIds = [];
         for (let d = -numBins; d <= numBins; d++) {
@@ -3856,11 +4024,11 @@ var init_dist2 = __esm({
           functionName: "addLiquidity",
           args: [
             {
-              tokenX: params.tokenX,
-              tokenY: params.tokenY,
+              tokenX,
+              tokenY,
               binStep: BigInt(params.binStep),
-              amountX: params.amountX,
-              amountY: params.amountY,
+              amountX,
+              amountY,
               amountXMin: 0n,
               amountYMin: 0n,
               activeIdDesired: BigInt(activeIdDesired),
@@ -3875,31 +4043,63 @@ var init_dist2 = __esm({
           ]
         });
         return {
-          description: `[${this.protocolName}] LB addLiquidity ${params.amountX} tokenX + ${params.amountY} tokenY across ${deltaIds.length} bins`,
+          description: `[${this.protocolName}] LB addLiquidity ${amountX} tokenX + ${amountY} tokenY across ${deltaIds.length} bins`,
           to: this.lbRouter,
           data,
           value: 0n,
           gas_estimate: 8e5,
           approvals: [
-            { token: params.tokenX, spender: this.lbRouter, amount: params.amountX },
-            { token: params.tokenY, spender: this.lbRouter, amount: params.amountY }
+            { token: tokenX, spender: this.lbRouter, amount: amountX },
+            { token: tokenY, spender: this.lbRouter, amount: amountY }
           ]
         };
       }
       /**
        * Build a removeLiquidity transaction for specific LB bins.
+       *
+       * When `pool` is supplied, the adapter realigns tokenX/tokenY (and
+       * amountXMin/amountYMin) to the pool's actual ordering. Otherwise it trusts
+       * the caller — the router will revert if the order is wrong.
        */
       async buildRemoveLiquidity(params) {
         const deadline = params.deadline ?? BigInt("18446744073709551615");
+        let tokenX = params.tokenX;
+        let tokenY = params.tokenY;
+        let amountXMin = params.amountXMin ?? 0n;
+        let amountYMin = params.amountYMin ?? 0n;
+        if (params.pool) {
+          const rpcUrl = this.requireRpc();
+          const client = createPublicClient8({ transport: http8(rpcUrl) });
+          const [poolTokenX, poolTokenY] = await Promise.all([
+            client.readContract({ address: params.pool, abi: lbPairAbi, functionName: "getTokenX" }),
+            client.readContract({ address: params.pool, abi: lbPairAbi, functionName: "getTokenY" })
+          ]);
+          const inX = params.tokenX.toLowerCase();
+          const inY = params.tokenY.toLowerCase();
+          const poolX = poolTokenX.toLowerCase();
+          const poolY = poolTokenY.toLowerCase();
+          if (inX === poolY && inY === poolX) {
+            tokenX = poolTokenX;
+            tokenY = poolTokenY;
+            const x = amountXMin;
+            amountXMin = amountYMin;
+            amountYMin = x;
+          } else if (!(inX === poolX && inY === poolY)) {
+            throw new DefiError(
+              "CONTRACT_ERROR",
+              `[${this.protocolName}] tokenX/tokenY ${params.tokenX}/${params.tokenY} do not match pool ${params.pool} (${poolTokenX}/${poolTokenY})`
+            );
+          }
+        }
         const data = encodeFunctionData12({
           abi: lbRouterAbi,
           functionName: "removeLiquidity",
           args: [
-            params.tokenX,
-            params.tokenY,
+            tokenX,
+            tokenY,
             params.binStep,
-            params.amountXMin ?? 0n,
-            params.amountYMin ?? 0n,
+            amountXMin,
+            amountYMin,
             params.binIds.map(BigInt),
             params.amounts,
             params.recipient,
@@ -4809,7 +5009,7 @@ var init_dist2 = __esm({
         const poolSet = /* @__PURE__ */ new Set();
         for (const data of poolResults) {
           const addr = decodeAddress3(data);
-          if (addr && addr !== zeroAddress7) {
+          if (addr && addr !== zeroAddress6) {
             poolSet.add(addr.toLowerCase());
           }
         }
@@ -4974,6 +5174,34 @@ var init_dist2 = __esm({
         }
         return apr;
       }
+      /**
+       * Snapshot of all NEST gauged pools from the off-chain blaze API. The
+       * on-chain ve(3,3) gauges return `rewardRate=0` (emissions are credited
+       * off-chain via signed claim tickets), so the on-chain Solidly gauge
+       * reader cannot surface real emission APR. This API is the canonical
+       * read source — used by `lp discover` to expose non-zero NEST yields.
+       */
+      async getLiquidityPools() {
+        const raw = await this.fetchJson("/liquidity-pools");
+        const out = [];
+        for (const p of raw) {
+          const t0 = p.token0?.basetoken;
+          const t1 = p.token1?.basetoken;
+          if (!t0?.address || !t1?.address) continue;
+          out.push({
+            pool: p.id,
+            gauge: p.gauge ?? null,
+            token0: { address: t0.address, symbol: t0.symbol ?? "?" },
+            token1: { address: t1.address, symbol: t1.symbol ?? "?" },
+            tvlUSD: Number(p.tvlUSD ?? 0),
+            aprPercent: Number(p.apr ?? 0),
+            curEpochEmissionRewardsUSD: Number(p.curEpochEmissionRewardsUSD ?? 0),
+            poolType: p.poolType,
+            isStable: p.isStable
+          });
+        }
+        return out;
+      }
       /** Pending NEST emissions as IGauge-compatible RewardInfo[] */
       async getPendingRewards(user) {
         const status = await this.getClaimStatus(user);
@@ -5129,6 +5357,16 @@ var init_dist2 = __esm({
       "function borrow(address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf) external",
       "function repay(address asset, uint256 amount, uint256 interestRateMode, address onBehalfOf) external returns (uint256)",
       "function withdraw(address asset, uint256 amount, address to) external returns (uint256)",
+      // Toggles required to actually borrow against an isolation-mode reserve
+      // (https://aave.com/docs/aave-v3/smart-contracts/pool):
+      //   - setUserUseReserveAsCollateral: an isolation reserve can be enabled
+      //     only if no other asset is enabled; LTV=0 reserves can never be
+      //     enabled; disable reverts if the resulting HF would drop below the
+      //     liquidation threshold.
+      //   - setUserEMode: reverts if the user is borrowing a non-eMode-
+      //     compatible asset, or if the change would push HF below threshold.
+      "function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external",
+      "function setUserEMode(uint8 categoryId) external",
       "function getUserAccountData(address user) external view returns (uint256 totalCollateralBase, uint256 totalDebtBase, uint256 availableBorrowsBase, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor)",
       "function getReservesList() external view returns (address[])",
       "function getReserveData(address asset) external view returns (uint256 configuration, uint128 liquidityIndex, uint128 currentLiquidityRate, uint128 variableBorrowIndex, uint128 currentVariableBorrowRate, uint128 currentStableBorrowRate, uint40 lastUpdateTimestamp, uint16 id, address aTokenAddress, address stableDebtTokenAddress, address variableDebtTokenAddress, address interestRateStrategyAddress, uint128 accruedToTreasury, uint128 unbacked, uint128 isolationModeTotalDebt)"
@@ -5254,6 +5492,34 @@ var init_dist2 = __esm({
           gas_estimate: 25e4
         };
       }
+      async buildSetUseReserveAsCollateral(asset, useAsCollateral) {
+        const data = encodeFunctionData14({
+          abi: POOL_ABI,
+          functionName: "setUserUseReserveAsCollateral",
+          args: [asset, useAsCollateral]
+        });
+        return {
+          description: `[${this.protocolName}] ${useAsCollateral ? "Enable" : "Disable"} ${asset} as collateral`,
+          to: this.pool,
+          data,
+          value: 0n,
+          gas_estimate: 1e5
+        };
+      }
+      async buildSetEMode(categoryId) {
+        const data = encodeFunctionData14({
+          abi: POOL_ABI,
+          functionName: "setUserEMode",
+          args: [categoryId]
+        });
+        return {
+          description: `[${this.protocolName}] Set eMode category to ${categoryId}${categoryId === 0 ? " (opt out)" : ""}`,
+          to: this.pool,
+          data,
+          value: 0n,
+          gas_estimate: 15e4
+        };
+      }
       async getRates(asset) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
         const reserveCallData = encodeFunctionData14({
@@ -5298,7 +5564,7 @@ var init_dist2 = __esm({
             [aTokenAddress, encodeFunctionData14({ abi: INCENTIVES_ABI, functionName: "getIncentivesController" })]
           ]);
           const controllerAddr = decodeAddress4(controllerRaw ?? null);
-          if (controllerAddr && controllerAddr !== zeroAddress8) {
+          if (controllerAddr && controllerAddr !== zeroAddress7) {
             const [supplyRewardsRaw, borrowRewardsRaw] = await multicallRead(this.rpcUrl, [
               [controllerAddr, encodeFunctionData14({ abi: REWARDS_CONTROLLER_ABI, functionName: "getRewardsByAsset", args: [aTokenAddress] })],
               [controllerAddr, encodeFunctionData14({ abi: REWARDS_CONTROLLER_ABI, functionName: "getRewardsByAsset", args: [variableDebtTokenAddress] })]
@@ -5494,8 +5760,8 @@ var init_dist2 = __esm({
             if (p.value.borrow > 0n) borrows.push({ asset: p.value.asset, symbol: p.value.symbol, amount: p.value.borrow });
           }
         } catch {
-          if (collateralUsd > 0) supplies.push({ asset: zeroAddress8, symbol: "Total Collateral (per-asset breakdown unavailable)", amount: totalCollateralBase });
-          if (debtUsd > 0) borrows.push({ asset: zeroAddress8, symbol: "Total Debt (per-asset breakdown unavailable)", amount: totalDebtBase });
+          if (collateralUsd > 0) supplies.push({ asset: zeroAddress7, symbol: "Total Collateral (per-asset breakdown unavailable)", amount: totalCollateralBase });
+          if (debtUsd > 0) borrows.push({ asset: zeroAddress7, symbol: "Total Debt (per-asset breakdown unavailable)", amount: totalDebtBase });
         }
         return {
           protocol: this.protocolName,
@@ -5662,8 +5928,8 @@ var init_dist2 = __esm({
         const collateralUsd = u256ToF642(totalCollateralBase) / 1e18;
         const debtUsd = u256ToF642(totalDebtBase) / 1e18;
         const ltvBps = u256ToF642(ltv);
-        const supplies = collateralUsd > 0 ? [{ asset: zeroAddress9, symbol: "Total Collateral", amount: totalCollateralBase, value_usd: collateralUsd }] : [];
-        const borrows = debtUsd > 0 ? [{ asset: zeroAddress9, symbol: "Total Debt", amount: totalDebtBase, value_usd: debtUsd }] : [];
+        const supplies = collateralUsd > 0 ? [{ asset: zeroAddress8, symbol: "Total Collateral", amount: totalCollateralBase, value_usd: collateralUsd }] : [];
+        const borrows = debtUsd > 0 ? [{ asset: zeroAddress8, symbol: "Total Debt", amount: totalDebtBase, value_usd: debtUsd }] : [];
         return {
           protocol: this.protocolName,
           user,
@@ -5766,14 +6032,31 @@ var init_dist2 = __esm({
       "function borrow(uint256 borrowAmount) external returns (uint256)",
       "function repayBorrow(uint256 repayAmount) external returns (uint256)"
     ]);
+    NATIVE_CTOKEN_ABI = parseAbi17([
+      "function mint() external payable",
+      "function repayBorrow() external payable"
+    ]);
+    COMPTROLLER_ABI = parseAbi17([
+      "function enterMarkets(address[] cTokens) external returns (uint256[])",
+      "function exitMarket(address cToken) external returns (uint256)"
+    ]);
+    NATIVE_SENTINEL = "0x0000000000000000000000000000000000000000";
     BSC_BLOCKS_PER_YEAR = 10512e3;
     CompoundV2Adapter = class {
       protocolName;
       defaultVtoken;
       vTokenCandidates;
+      comptroller;
       rpcUrl;
-      // Lazy cache: underlying asset address (lowercased) → vToken address
+      // Lazy cache: underlying asset address (lowercased) → vToken address.
+      // The native sentinel (0x0…) is mapped to the cETH/vBNB-style vToken
+      // when one is detected during resolveVtoken().
       vTokenByAsset = null;
+      // The cETH/vBNB-style vToken whose underlying() reverts (it has no
+      // ERC20 underlying — the underlying is the chain's native gas token).
+      // Set lazily by resolveVtoken() and consulted by buildSupply/buildRepay
+      // to switch to the payable mint() / repayBorrow() variants.
+      nativeVtoken = null;
       constructor(entry, rpcUrl) {
         this.protocolName = entry.name;
         this.rpcUrl = rpcUrl;
@@ -5781,6 +6064,7 @@ var init_dist2 = __esm({
         const vtoken = contracts["vusdt"] ?? contracts["vusdc"] ?? contracts["vbnb"] ?? contracts["comptroller"];
         if (!vtoken) throw DefiError.contractError("Missing vToken or comptroller address");
         this.defaultVtoken = vtoken;
+        this.comptroller = contracts["comptroller"];
         this.vTokenCandidates = Object.entries(contracts).filter(([k]) => /^v[a-z][a-z0-9]*$/i.test(k)).map(([, v]) => v);
         if (this.vTokenCandidates.length === 0) this.vTokenCandidates = [vtoken];
       }
@@ -5789,19 +6073,38 @@ var init_dist2 = __esm({
         if (!this.vTokenByAsset) {
           const client = createPublicClient13({ transport: http13(this.rpcUrl) });
           const map = /* @__PURE__ */ new Map();
+          let nativeVtoken = null;
           const lookups = await Promise.allSettled(
             this.vTokenCandidates.map(async (v) => {
-              const u = await client.readContract({ address: v, abi: CTOKEN_ABI, functionName: "underlying" });
-              return [u.toLowerCase(), v];
+              try {
+                const u = await client.readContract({ address: v, abi: CTOKEN_ABI, functionName: "underlying" });
+                return { vtoken: v, underlying: u };
+              } catch {
+                return { vtoken: v, underlying: null };
+              }
             })
           );
           for (const r of lookups) {
-            if (r.status === "fulfilled") map.set(r.value[0], r.value[1]);
+            if (r.status !== "fulfilled") continue;
+            const { vtoken, underlying } = r.value;
+            if (underlying) {
+              map.set(underlying.toLowerCase(), vtoken);
+            } else if (!nativeVtoken) {
+              nativeVtoken = vtoken;
+            }
+          }
+          if (nativeVtoken) {
+            map.set(NATIVE_SENTINEL, nativeVtoken);
           }
           this.vTokenByAsset = map;
+          this.nativeVtoken = nativeVtoken;
         }
         return this.vTokenByAsset.get(asset.toLowerCase()) ?? null;
       }
+      /** True iff `vtoken` is the cETH/vBNB-style native cToken for this protocol. */
+      isNativeVtoken(vtoken) {
+        return this.nativeVtoken !== null && vtoken.toLowerCase() === this.nativeVtoken.toLowerCase();
+      }
       name() {
         return this.protocolName;
       }
@@ -5815,6 +6118,16 @@ var init_dist2 = __esm({
       }
       async buildSupply(params) {
         const vtoken = await this.vtokenFor(params.asset);
+        if (this.isNativeVtoken(vtoken)) {
+          const data2 = encodeFunctionData16({ abi: NATIVE_CTOKEN_ABI, functionName: "mint" });
+          return {
+            description: `[${this.protocolName}] Supply ${params.amount} (native) to Venus`,
+            to: vtoken,
+            data: data2,
+            value: params.amount,
+            gas_estimate: 3e5
+          };
+        }
         const data = encodeFunctionData16({ abi: CTOKEN_ABI, functionName: "mint", args: [params.amount] });
         return {
           description: `[${this.protocolName}] Supply ${params.amount} of ${params.asset} to Venus`,
@@ -5838,6 +6151,16 @@ var init_dist2 = __esm({
       }
       async buildRepay(params) {
         const vtoken = await this.vtokenFor(params.asset);
+        if (this.isNativeVtoken(vtoken)) {
+          const data2 = encodeFunctionData16({ abi: NATIVE_CTOKEN_ABI, functionName: "repayBorrow" });
+          return {
+            description: `[${this.protocolName}] Repay ${params.amount} (native) to Venus`,
+            to: vtoken,
+            data: data2,
+            value: params.amount,
+            gas_estimate: 3e5
+          };
+        }
         const data = encodeFunctionData16({ abi: CTOKEN_ABI, functionName: "repayBorrow", args: [params.amount] });
         return {
           description: `[${this.protocolName}] Repay ${params.amount} of ${params.asset} to Venus`,
@@ -5850,6 +6173,37 @@ var init_dist2 = __esm({
       }
       async buildWithdraw(params) {
         const vtoken = await this.vtokenFor(params.asset);
+        const MAX_UINT2562 = (1n << 256n) - 1n;
+        if (params.amount === MAX_UINT2562 && this.rpcUrl) {
+          const client = createPublicClient13({ transport: http13(this.rpcUrl) });
+          const [vtokenBalance, borrowBalance] = await Promise.all([
+            client.readContract({
+              address: vtoken,
+              abi: CTOKEN_ABI,
+              functionName: "balanceOf",
+              args: [params.to]
+            }),
+            client.readContract({
+              address: vtoken,
+              abi: CTOKEN_ABI,
+              functionName: "borrowBalanceStored",
+              args: [params.to]
+            }).catch(() => 0n)
+          ]);
+          if (borrowBalance > 0n) {
+            throw DefiError.contractError(
+              `[${this.protocolName}] Cannot withdraw all (uint256.max) \u2014 wallet has an outstanding borrow of ${borrowBalance} on this market. Repay the borrow first, or pass an explicit --amount that leaves enough collateral.`
+            );
+          }
+          const redeemData = encodeFunctionData16({ abi: CTOKEN_ABI, functionName: "redeem", args: [vtokenBalance] });
+          return {
+            description: `[${this.protocolName}] Withdraw all (auto-max, ${vtokenBalance} vTokens) of ${params.asset} from Venus`,
+            to: vtoken,
+            data: redeemData,
+            value: 0n,
+            gas_estimate: 35e4
+          };
+        }
         const data = encodeFunctionData16({ abi: CTOKEN_ABI, functionName: "redeemUnderlying", args: [params.amount] });
         return {
           description: `[${this.protocolName}] Withdraw ${params.amount} of ${params.asset} from Venus`,
@@ -5859,6 +6213,37 @@ var init_dist2 = __esm({
           gas_estimate: 25e4
         };
       }
+      /**
+       * Compound V2 family: enter cTokens as collateral via Comptroller.
+       * Without this call, supplied assets sit dormant in the Comptroller's
+       * accountAssets[] and `getAccountLiquidity` reports zero collateral —
+       * any borrow then reverts. Mirrors the role of Aave V3's
+       * setUserUseReserveAsCollateral, but the API is batch-by-cToken.
+       */
+      async buildEnterMarkets(cTokens) {
+        if (!this.comptroller) {
+          throw DefiError.contractError(
+            `[${this.protocolName}] enterMarkets requires the Comptroller address to be registered under [protocol.contracts] as 'comptroller'.`
+          );
+        }
+        if (cTokens.length === 0) {
+          throw DefiError.invalidParam(
+            `[${this.protocolName}] enterMarkets requires at least one cToken address.`
+          );
+        }
+        const data = encodeFunctionData16({
+          abi: COMPTROLLER_ABI,
+          functionName: "enterMarkets",
+          args: [cTokens]
+        });
+        return {
+          description: `[${this.protocolName}] Enter ${cTokens.length} market(s) as collateral`,
+          to: this.comptroller,
+          data,
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
       async getRates(asset) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
         const client = createPublicClient13({ transport: http13(this.rpcUrl) });
@@ -6226,9 +6611,11 @@ var init_dist2 = __esm({
       "function market(bytes32 id) external view returns (uint128 totalSupplyAssets, uint128 totalSupplyShares, uint128 totalBorrowAssets, uint128 totalBorrowShares, uint128 lastUpdate, uint128 fee)",
       "function idToMarketParams(bytes32 id) external view returns (address loanToken, address collateralToken, address oracle, address irm, uint256 lltv)",
       "function supply((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, bytes data) external returns (uint256 assetsSupplied, uint256 sharesSupplied)",
+      "function supplyCollateral((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, address onBehalf, bytes data) external",
       "function borrow((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, address receiver) external returns (uint256 assetsBorrowed, uint256 sharesBorrowed)",
       "function repay((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, bytes data) external returns (uint256 assetsRepaid, uint256 sharesRepaid)",
-      "function withdraw((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, address receiver) external returns (uint256 assetsWithdrawn, uint256 sharesWithdrawn)"
+      "function withdraw((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, address receiver) external returns (uint256 assetsWithdrawn, uint256 sharesWithdrawn)",
+      "function withdrawCollateral((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, address onBehalf, address receiver) external"
     ]);
     META_MORPHO_ABI = parseAbi20([
       "function supplyQueueLength() external view returns (uint256)",
@@ -6255,6 +6642,8 @@ var init_dist2 = __esm({
       rpcUrl;
       metaMorphoVaults;
       metaMorphoVaultEntries;
+      namedMarkets;
+      namedMarketByName;
       vaultAssetMap = null;
       constructor(entry, rpcUrl) {
         this.protocolName = entry.name;
@@ -6266,6 +6655,26 @@ var init_dist2 = __esm({
         this.defaultVault = contracts["fehype"] ?? contracts["vault"] ?? contracts["feusdc"];
         this.metaMorphoVaultEntries = Object.entries(contracts).filter(([key]) => /^fe[a-z0-9_]+$/i.test(key) || key === "vault").map(([key, addr]) => ({ key, addr }));
         this.metaMorphoVaults = this.metaMorphoVaultEntries.map((e) => e.addr);
+        this.namedMarkets = entry.markets ?? [];
+        const byName = /* @__PURE__ */ new Map();
+        for (const m of this.namedMarkets) byName.set(m.name.toLowerCase(), m.id);
+        this.namedMarketByName = byName;
+      }
+      /**
+       * Resolve a friendly market name (e.g. `WMON-AUSD`) to its 32-byte
+       * marketId via the per-protocol TOML registry. Returns null when the
+       * adapter has no markets[] block or the name doesn't match any entry —
+       * callers fall back to treating the input as a raw hex marketId.
+       */
+      resolveMarketIdByName(name) {
+        return this.namedMarketByName.get(name.toLowerCase()) ?? null;
+      }
+      /**
+       * Returns the registered named markets for diagnostics (e.g. CLI error
+       * messages listing valid choices when the user passes an unknown name).
+       */
+      listNamedMarkets() {
+        return this.namedMarkets;
       }
       async resolveVault(asset, preferKey) {
         if (this.metaMorphoVaultEntries.length === 0 || !this.rpcUrl) return null;
@@ -6299,10 +6708,61 @@ var init_dist2 = __esm({
       name() {
         return this.protocolName;
       }
+      /**
+       * Resolve a Morpho Blue marketId into the full MarketParams tuple by
+       * calling Morpho.idToMarketParams(id). Used by every direct-market
+       * method (supply / borrow / repay / withdraw / supplyCollateral /
+       * withdrawCollateral) so the caller only has to pass the 32-byte
+       * marketId — same shape as the Morpho UI / API.
+       */
+      async resolveMarketParams(marketId) {
+        if (!this.rpcUrl) {
+          throw DefiError.rpcError(
+            `[${this.protocolName}] No RPC URL configured \u2014 cannot resolve marketId ${marketId}`
+          );
+        }
+        const client = createPublicClient16({ transport: http16(this.rpcUrl) });
+        let result;
+        try {
+          result = await client.readContract({
+            address: this.morpho,
+            abi: MORPHO_ABI,
+            functionName: "idToMarketParams",
+            args: [marketId]
+          });
+        } catch (e) {
+          throw DefiError.rpcError(
+            `[${this.protocolName}] idToMarketParams(${marketId}) failed: ${e}`
+          );
+        }
+        const [loanToken, collateralToken, oracle, irm, lltv] = result;
+        if (loanToken === zeroAddress9 || collateralToken === zeroAddress9 || lltv === 0n) {
+          throw DefiError.invalidParam(
+            `[${this.protocolName}] marketId ${marketId} resolves to an empty MarketParams (loan=${loanToken}, collateral=${collateralToken}, lltv=${lltv}). Verify the id matches a registered market on this chain.`
+          );
+        }
+        return { loanToken, collateralToken, oracle, irm, lltv };
+      }
       async buildSupply(params) {
+        if (params.market_id) {
+          const market = await this.resolveMarketParams(params.market_id);
+          const data = encodeFunctionData19({
+            abi: MORPHO_ABI,
+            functionName: "supply",
+            args: [market, params.amount, 0n, params.on_behalf_of, "0x"]
+          });
+          return {
+            description: `[${this.protocolName}] Supply ${params.amount} of ${params.asset} to market ${params.market_id.slice(0, 10)}\u2026`,
+            to: this.morpho,
+            data,
+            value: 0n,
+            gas_estimate: 35e4,
+            approvals: [{ token: params.asset, spender: this.morpho, amount: params.amount }]
+          };
+        }
         const vault = await this.resolveVault(params.asset);
         if (vault) {
-          const data2 = encodeFunctionData19({
+          const data = encodeFunctionData19({
             abi: ERC4626_ABI,
             functionName: "deposit",
             args: [params.amount, params.on_behalf_of]
@@ -6310,50 +6770,118 @@ var init_dist2 = __esm({
           return {
             description: `[${this.protocolName}] Deposit ${params.amount} into MetaMorpho vault`,
             to: vault,
-            data: data2,
+            data,
             value: 0n,
             gas_estimate: 4e5,
             approvals: [{ token: params.asset, spender: vault, amount: params.amount }]
           };
         }
-        const market = defaultMarketParams(params.asset);
+        throw DefiError.invalidParam(
+          `[${this.protocolName}] supply requires either a registered MetaMorpho vault for ${params.asset} or an explicit --market <marketId>. The legacy zero-MarketParams stub was removed (it always reverted on-chain).`
+        );
+      }
+      async buildBorrow(params) {
+        if (!params.market_id) {
+          throw DefiError.invalidParam(
+            `[${this.protocolName}] Morpho Blue borrow requires --market <marketId>. Find one via the Morpho API (https://blue-api.morpho.org/graphql).`
+          );
+        }
+        const market = await this.resolveMarketParams(params.market_id);
+        const data = encodeFunctionData19({
+          abi: MORPHO_ABI,
+          functionName: "borrow",
+          args: [market, params.amount, 0n, params.on_behalf_of, params.on_behalf_of]
+        });
+        return {
+          description: `[${this.protocolName}] Borrow ${params.amount} of ${params.asset} from market ${params.market_id.slice(0, 10)}\u2026`,
+          to: this.morpho,
+          data,
+          value: 0n,
+          gas_estimate: 4e5
+        };
+      }
+      async buildRepay(params) {
+        if (!params.market_id) {
+          throw DefiError.invalidParam(
+            `[${this.protocolName}] Morpho Blue repay requires --market <marketId>.`
+          );
+        }
+        const market = await this.resolveMarketParams(params.market_id);
+        if (params.amount === MAX_UINT256) {
+          if (!this.rpcUrl) {
+            throw DefiError.rpcError(
+              `[${this.protocolName}] max-repay requires an RPC URL to read borrowShares.`
+            );
+          }
+          const client = createPublicClient16({ transport: http16(this.rpcUrl) });
+          const positionAbi = parseAbi20([
+            "function position(bytes32 id, address user) external view returns (uint256 supplyShares, uint128 borrowShares, uint128 collateral)"
+          ]);
+          const pos = await client.readContract({
+            address: this.morpho,
+            abi: positionAbi,
+            functionName: "position",
+            args: [params.market_id, params.on_behalf_of]
+          });
+          const [, borrowShares] = pos;
+          if (borrowShares === 0n) {
+            throw DefiError.invalidParam(
+              `[${this.protocolName}] cannot repay max \u2014 user has no borrow position in market ${params.market_id}.`
+            );
+          }
+          const data2 = encodeFunctionData19({
+            abi: MORPHO_ABI,
+            functionName: "repay",
+            args: [market, 0n, borrowShares, params.on_behalf_of, "0x"]
+          });
+          return {
+            description: `[${this.protocolName}] Repay max (${borrowShares} shares) to market ${params.market_id.slice(0, 10)}\u2026`,
+            to: this.morpho,
+            data: data2,
+            value: 0n,
+            gas_estimate: 35e4,
+            approvals: [{ token: params.asset, spender: this.morpho, amount: MAX_UINT256 }]
+          };
+        }
         const data = encodeFunctionData19({
           abi: MORPHO_ABI,
-          functionName: "supply",
+          functionName: "repay",
           args: [market, params.amount, 0n, params.on_behalf_of, "0x"]
         });
         return {
-          description: `[${this.protocolName}] Supply ${params.amount} to Morpho market`,
+          description: `[${this.protocolName}] Repay ${params.amount} of ${params.asset} to market ${params.market_id.slice(0, 10)}\u2026`,
           to: this.morpho,
           data,
           value: 0n,
-          gas_estimate: 3e5
+          gas_estimate: 35e4,
+          approvals: [{ token: params.asset, spender: this.morpho, amount: params.amount }]
         };
       }
-      async buildBorrow(params) {
-        const market = defaultMarketParams(params.asset);
+      async buildSupplyCollateral(params) {
+        const market = await this.resolveMarketParams(params.market_id);
         const data = encodeFunctionData19({
           abi: MORPHO_ABI,
-          functionName: "borrow",
-          args: [market, params.amount, 0n, params.on_behalf_of, params.on_behalf_of]
+          functionName: "supplyCollateral",
+          args: [market, params.amount, params.on_behalf_of, "0x"]
         });
         return {
-          description: `[${this.protocolName}] Borrow ${params.amount} from Morpho market`,
+          description: `[${this.protocolName}] Supply collateral ${params.amount} of ${params.asset} to market ${params.market_id.slice(0, 10)}\u2026`,
           to: this.morpho,
           data,
           value: 0n,
-          gas_estimate: 35e4
+          gas_estimate: 35e4,
+          approvals: [{ token: params.asset, spender: this.morpho, amount: params.amount }]
         };
       }
-      async buildRepay(params) {
-        const market = defaultMarketParams(params.asset);
+      async buildWithdrawCollateral(params) {
+        const market = await this.resolveMarketParams(params.market_id);
         const data = encodeFunctionData19({
           abi: MORPHO_ABI,
-          functionName: "repay",
-          args: [market, params.amount, 0n, params.on_behalf_of, "0x"]
+          functionName: "withdrawCollateral",
+          args: [market, params.amount, params.to, params.to]
         });
         return {
-          description: `[${this.protocolName}] Repay ${params.amount} to Morpho market`,
+          description: `[${this.protocolName}] Withdraw collateral ${params.amount} of ${params.asset} from market ${params.market_id.slice(0, 10)}\u2026`,
           to: this.morpho,
           data,
           value: 0n,
@@ -6361,6 +6889,21 @@ var init_dist2 = __esm({
         };
       }
       async buildWithdraw(params) {
+        if (params.market_id) {
+          const market = await this.resolveMarketParams(params.market_id);
+          const data = encodeFunctionData19({
+            abi: MORPHO_ABI,
+            functionName: "withdraw",
+            args: [market, params.amount, 0n, params.to, params.to]
+          });
+          return {
+            description: `[${this.protocolName}] Withdraw ${params.amount} of ${params.asset} from market ${params.market_id.slice(0, 10)}\u2026`,
+            to: this.morpho,
+            data,
+            value: 0n,
+            gas_estimate: 3e5
+          };
+        }
         const vault = await this.resolveVault(params.asset);
         if (vault) {
           if (params.amount === MAX_UINT256) {
@@ -6369,7 +6912,7 @@ var init_dist2 = __esm({
               [vault, encodeFunctionData19({ abi: ERC4626_ABI, functionName: "balanceOf", args: [params.to] })]
             ]);
             const shares = decodeU256(balRaw ?? null);
-            const data3 = encodeFunctionData19({
+            const data2 = encodeFunctionData19({
               abi: ERC4626_ABI,
               functionName: "redeem",
               args: [shares, params.to, params.to]
@@ -6377,12 +6920,12 @@ var init_dist2 = __esm({
             return {
               description: `[${this.protocolName}] Redeem all shares (${shares}) from MetaMorpho vault`,
               to: vault,
-              data: data3,
+              data: data2,
               value: 0n,
               gas_estimate: 4e5
             };
           }
-          const data2 = encodeFunctionData19({
+          const data = encodeFunctionData19({
             abi: ERC4626_ABI,
             functionName: "withdraw",
             args: [params.amount, params.to, params.to]
@@ -6390,24 +6933,14 @@ var init_dist2 = __esm({
           return {
             description: `[${this.protocolName}] Withdraw ${params.amount} assets from MetaMorpho vault`,
             to: vault,
-            data: data2,
+            data,
             value: 0n,
             gas_estimate: 4e5
           };
         }
-        const market = defaultMarketParams(params.asset);
-        const data = encodeFunctionData19({
-          abi: MORPHO_ABI,
-          functionName: "withdraw",
-          args: [market, params.amount, 0n, params.to, params.to]
-        });
-        return {
-          description: `[${this.protocolName}] Withdraw ${params.amount} from Morpho market`,
-          to: this.morpho,
-          data,
-          value: 0n,
-          gas_estimate: 25e4
-        };
+        throw DefiError.invalidParam(
+          `[${this.protocolName}] withdraw requires either a registered MetaMorpho vault for ${params.asset} or an explicit --market <marketId>. The legacy zero-MarketParams stub was removed (it always reverted on-chain).`
+        );
       }
       async getRates(asset) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
@@ -6524,7 +7057,7 @@ var init_dist2 = __esm({
         if (!this.hintHelpers || !this.sortedTroves || !this.rpcUrl) {
           return [0n, 0n];
         }
-        const client = createPublicClient16({ transport: http16(this.rpcUrl) });
+        const client = createPublicClient17({ transport: http17(this.rpcUrl) });
         const approxResult = await client.readContract({
           address: this.hintHelpers,
           abi: HINT_HELPERS_ABI,
@@ -6615,7 +7148,7 @@ var init_dist2 = __esm({
       async getCdpInfo(cdpId) {
         if (!this.rpcUrl) throw DefiError.rpcError(`[${this.protocolName}] getCdpInfo requires RPC \u2014 set HYPEREVM_RPC_URL`);
         if (!this.troveManager) throw DefiError.contractError(`[${this.protocolName}] trove_manager contract not configured`);
-        const client = createPublicClient16({ transport: http16(this.rpcUrl) });
+        const client = createPublicClient17({ transport: http17(this.rpcUrl) });
         const data = await client.readContract({
           address: this.troveManager,
           abi: TROVE_MANAGER_ABI,
@@ -6633,13 +7166,13 @@ var init_dist2 = __esm({
           protocol: this.protocolName,
           cdp_id: cdpId,
           collateral: {
-            token: zeroAddress11,
+            token: zeroAddress10,
             symbol: "WHYPE",
             amount: entireColl,
             decimals: 18
           },
           debt: {
-            token: zeroAddress11,
+            token: zeroAddress10,
             symbol: "feUSD",
             amount: entireDebt,
             decimals: 18
@@ -6674,7 +7207,7 @@ var init_dist2 = __esm({
         if (asset !== this.asset && this.asset !== "0x0000000000000000000000000000000000000000") {
           throw DefiError.unsupported(`[${this.protocolName}] Felix PriceFeed only supports asset ${this.asset}`);
         }
-        const client = createPublicClient17({ transport: http17(this.rpcUrl) });
+        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
         let priceVal;
         try {
           const result = await client.readContract({
@@ -6766,7 +7299,7 @@ var init_dist2 = __esm({
       }
       async totalAssets() {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
+        const client = createPublicClient19({ transport: http19(this.rpcUrl) });
         return client.readContract({
           address: this.vaultAddress,
           abi: ERC4626_ABI2,
@@ -6777,7 +7310,7 @@ var init_dist2 = __esm({
       }
       async convertToShares(assets) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
+        const client = createPublicClient19({ transport: http19(this.rpcUrl) });
         return client.readContract({
           address: this.vaultAddress,
           abi: ERC4626_ABI2,
@@ -6789,7 +7322,7 @@ var init_dist2 = __esm({
       }
       async convertToAssets(shares) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
+        const client = createPublicClient19({ transport: http19(this.rpcUrl) });
         return client.readContract({
           address: this.vaultAddress,
           abi: ERC4626_ABI2,
@@ -6801,7 +7334,7 @@ var init_dist2 = __esm({
       }
       async getVaultInfo() {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
+        const client = createPublicClient19({ transport: http19(this.rpcUrl) });
         const [totalAssets, totalSupply, asset] = await Promise.all([
           client.readContract({ address: this.vaultAddress, abi: ERC4626_ABI2, functionName: "totalAssets" }).catch((e) => {
             throw DefiError.rpcError(`[${this.protocolName}] totalAssets failed: ${e}`);
@@ -6893,7 +7426,7 @@ var init_dist2 = __esm({
         const data = encodeFunctionData23({
           abi: STHYPE_ABI,
           functionName: "submit",
-          args: [zeroAddress12]
+          args: [zeroAddress11]
         });
         return {
           description: `[${this.protocolName}] Stake ${params.amount} HYPE for stHYPE`,
@@ -6919,7 +7452,7 @@ var init_dist2 = __esm({
       }
       async getInfo() {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient19({ transport: http19(this.rpcUrl) });
+        const client = createPublicClient20({ transport: http20(this.rpcUrl) });
         const tokenAddr = this.sthypeToken ?? this.staking;
         const totalSupply = await client.readContract({
           address: tokenAddr,
@@ -6930,7 +7463,7 @@ var init_dist2 = __esm({
         });
         return {
           protocol: this.protocolName,
-          staked_token: zeroAddress12,
+          staked_token: zeroAddress11,
           liquid_token: tokenAddr,
           exchange_rate: 1,
           total_staked: totalSupply
@@ -6989,7 +7522,7 @@ var init_dist2 = __esm({
       }
       async getInfo() {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient20({ transport: http20(this.rpcUrl) });
+        const client = createPublicClient21({ transport: http21(this.rpcUrl) });
         const totalStaked = await client.readContract({
           address: this.staking,
           abi: KINETIQ_ABI,
@@ -7004,7 +7537,7 @@ var init_dist2 = __esm({
         const rateF64 = hypePrice > 0n && khypePrice > 0n ? Number(khypePrice * 10n ** 18n / hypePrice) / 1e18 : 1;
         return {
           protocol: this.protocolName,
-          staked_token: zeroAddress13,
+          staked_token: zeroAddress12,
           liquid_token: this.liquidToken,
           exchange_rate: rateF64,
           total_staked: totalStaked
@@ -7224,7 +7757,7 @@ var init_dist2 = __esm({
       }
       async getCollectionInfo(collection) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient21({ transport: http21(this.rpcUrl) });
+        const client = createPublicClient222({ transport: http222(this.rpcUrl) });
         const [collectionName, symbol, totalSupply] = await Promise.all([
           client.readContract({ address: collection, abi: ERC721_ABI, functionName: "name" }).catch((e) => {
             throw DefiError.rpcError(`[${this.protocolName}] name failed: ${e}`);
@@ -7243,7 +7776,7 @@ var init_dist2 = __esm({
       }
       async getTokenInfo(collection, tokenId) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient21({ transport: http21(this.rpcUrl) });
+        const client = createPublicClient222({ transport: http222(this.rpcUrl) });
         const [owner, tokenUri] = await Promise.all([
           client.readContract({ address: collection, abi: ERC721_ABI, functionName: "ownerOf", args: [tokenId] }).catch((e) => {
             throw DefiError.rpcError(`[${this.protocolName}] ownerOf failed: ${e}`);
@@ -7259,7 +7792,7 @@ var init_dist2 = __esm({
       }
       async getBalance(owner, collection) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient21({ transport: http21(this.rpcUrl) });
+        const client = createPublicClient222({ transport: http222(this.rpcUrl) });
         return client.readContract({ address: collection, abi: ERC721_ABI, functionName: "balanceOf", args: [owner] }).catch((e) => {
           throw DefiError.rpcError(`[${this.protocolName}] balanceOf failed: ${e}`);
         });
@@ -7328,15 +7861,34 @@ var Executor = class _Executor {
   dryRun;
   rpcUrl;
   explorerUrl;
-  constructor(broadcast, rpcUrl, explorerUrl) {
+  /**
+   * Optional viem Chain object. When set, all wallet/public clients built
+   * inside this executor anchor to the explicit chainId at construction
+   * time, defending against MITM RPCs that lie about eth_chainId and
+   * keeping offline-signing safe under RPC drift (SSOT 7.4).
+   */
+  chain;
+  constructor(broadcast, rpcUrl, explorerUrl, chain) {
     this.dryRun = !broadcast;
     this.rpcUrl = rpcUrl;
     this.explorerUrl = explorerUrl;
+    this.chain = chain;
+  }
+  /** Returns the optional `{ chain }` spread for viem client constructors. */
+  chainOpt() {
+    return this.chain ? { chain: this.chain } : {};
   }
   /** Apply 20% buffer to a gas estimate */
   static applyGasBuffer(gas) {
     return gas * GAS_BUFFER_BPS / 10000n;
   }
+  /**
+   * EIP-1559 max-fee formula: `baseFee * 1.25 + priorityFee`.
+   * Extracted as a static so the math is unit-testable without mocking viem.
+   */
+  static computeMaxFee(baseFeePerGas, priorityFee) {
+    return baseFeePerGas * 125n / 100n + priorityFee;
+  }
   /**
    * Check allowance for a single token/spender pair and send an approve tx if needed.
    * Only called in broadcast mode (not dry-run).
@@ -7448,7 +8000,7 @@ var Executor = class _Executor {
    */
   async fetchEip1559Fees(rpcUrl) {
     try {
-      const client = createPublicClient2({ transport: http2(rpcUrl) });
+      const client = createPublicClient2({ transport: http2(rpcUrl), ...this.chainOpt() });
       let priorityFee = DEFAULT_PRIORITY_FEE_WEI;
       try {
         priorityFee = await client.estimateMaxPriorityFeePerGas();
@@ -7457,8 +8009,7 @@ var Executor = class _Executor {
       try {
         const block = await client.getBlock({ blockTag: "latest" });
         if (block.baseFeePerGas !== null && block.baseFeePerGas !== void 0) {
-          const maxFee = block.baseFeePerGas * 125n / 100n + priorityFee;
-          return [maxFee, priorityFee];
+          return [_Executor.computeMaxFee(block.baseFeePerGas, priorityFee), priorityFee];
         }
       } catch {
       }
@@ -7471,7 +8022,7 @@ var Executor = class _Executor {
   /** Estimate gas dynamically with buffer, falling back to a hardcoded estimate */
   async estimateGasWithBuffer(rpcUrl, tx, from) {
     try {
-      const client = createPublicClient2({ transport: http2(rpcUrl) });
+      const client = createPublicClient2({ transport: http2(rpcUrl), ...this.chainOpt() });
       const estimated = await client.estimateGas({
         to: tx.to,
         data: tx.data,
@@ -7495,7 +8046,7 @@ var Executor = class _Executor {
     if (!rpcUrl) {
       throw DefiError.rpcError("No RPC URL \u2014 cannot simulate. Set HYPEREVM_RPC_URL.");
     }
-    const client = createPublicClient2({ transport: http2(rpcUrl) });
+    const client = createPublicClient2({ transport: http2(rpcUrl), ...this.chainOpt() });
     const privateKey = process.env["DEFI_PRIVATE_KEY"];
     const from = privateKey ? privateKeyToAccount(privateKey).address : "0x0000000000000000000000000000000000000001";
     if (tx.approvals && tx.approvals.length > 0) {
@@ -7609,8 +8160,8 @@ var Executor = class _Executor {
     if (!rpcUrl) {
       throw DefiError.rpcError("No RPC URL configured for broadcasting");
     }
-    const publicClient = createPublicClient2({ transport: http2(rpcUrl) });
-    const walletClient = createWalletClient({ account, transport: http2(rpcUrl) });
+    const publicClient = createPublicClient2({ transport: http2(rpcUrl), ...this.chainOpt() });
+    const walletClient = createWalletClient({ account, transport: http2(rpcUrl), ...this.chainOpt() });
     if (tx.pre_txs && tx.pre_txs.length > 0) {
       for (const preTx of tx.pre_txs) {
         process.stderr.write(`  Pre-tx: ${preTx.description}...
@@ -8280,7 +8831,8 @@ function handleSchema(params) {
 function registerSchema(parent, getOpts) {
   parent.command("schema [command]").description("Output JSON schema for a command (agent-friendly)").option("--all", "Show all schemas").action(async (command, opts) => {
     const mode = getOpts();
-    const action = opts.all ? "all" : command ?? "all";
+    const raw = opts.all ? "all" : command ?? "all";
+    const action = raw.replace(/-/g, ".");
     const params = { action };
     const schema = handleSchema(params);
     printOutput(schema, mode);
@@ -8291,7 +8843,7 @@ function registerSchema(parent, getOpts) {
 init_dist();
 init_dist();
 init_dist2();
-import { parseAbi as parseAbi30, encodeFunctionData as encodeFunctionData27, decodeFunctionResult as decodeFunctionResult8, createPublicClient as createPublicClient23, http as http23, zeroAddress as zeroAddress14 } from "viem";
+import { parseAbi as parseAbi30, encodeFunctionData as encodeFunctionData27, decodeFunctionResult as decodeFunctionResult8, createPublicClient as createPublicClient23, http as http23, zeroAddress as zeroAddress13 } from "viem";
 
 // src/whitelist.ts
 import { readFileSync as readFileSync2 } from "fs";
@@ -8471,6 +9023,11 @@ function buildPipelineSteps(p, input = {}) {
     ["--protocol", slug, "slug"],
     ["--gauge", input.gauge, "gauge-from-voter.gaugeForPool"]
   ]);
+  const claimAutoStakeNftGauge = () => `defi ${chainFlag}lp claim ` + buildCmd([
+    ["--protocol", slug, "slug"],
+    ["--gauge", input.gauge, "gauge-from-voter.gaugeForPool"],
+    ["--token-id", input.tokenId, "token-id-from-mint-result"]
+  ]);
   switch (p.reward_strategy) {
     case "lp_fee_only":
       return [
@@ -8495,11 +9052,18 @@ function buildPipelineSteps(p, input = {}) {
         { step: "stake", function: "gauge.deposit(amount)", cli_command: baseFarm },
         { step: "claim", function: "gauge.earned(token, account) \u2192 gauge.getReward(account, tokens[])", cli_command: claimWithGauge() }
       ];
-    case "auto_stake":
+    case "auto_stake": {
+      const isNftAutoStake = p.interface === "uniswap_v3";
       return [
         { step: "mint", function: "Router.addLiquidity / NPM.mint", note: "LP automatically receives x(3,3) emissions \u2014 no separate stake step", cli_command: baseAdd },
-        { step: "claim", function: "gauge.getReward(account, tokens[])", note: "Multi-token reward (xRAM + WHYPE on Ramses HL)", cli_command: claimWithGauge() }
+        {
+          step: "claim",
+          function: isNftAutoStake ? "NPM.getPeriodReward(currentEpoch, tokenId, tokens[], receiver)" : "gauge.getReward(account, tokens[])",
+          note: isNftAutoStake ? "Ramses CL: claim via NPM with --token-id; gauge.getReward* reverts NOT_AUTHORIZED_CLAIMER for EOAs" : "Multi-token reward (xRAM + WHYPE on Ramses HL)",
+          cli_command: isNftAutoStake ? claimAutoStakeNftGauge() : claimWithGauge()
+        }
       ];
+    }
     case "on_chain_masterchef":
       return [
         { step: "mint", function: "NPM.mint or pool.mint", cli_command: baseAdd },
@@ -8700,6 +9264,24 @@ function registerLP(parent, getOpts, makeExecutor2) {
     await Promise.allSettled(
       protocols.map(async (protocol) => {
         try {
+          if (protocol.reward_strategy === "off_chain_api") {
+            const adapter = createNestOffChain(protocol);
+            const pools = await adapter.getLiquidityPools();
+            for (const p of pools) {
+              if (p.aprPercent === 0 && opts.emissionOnly) continue;
+              results.push({
+                protocol: protocol.slug,
+                pool: p.pool,
+                pair: `${p.token0.symbol}/${p.token1.symbol}`,
+                type: p.aprPercent > 0 ? "EMISSION" : "FEE",
+                source: "off_chain_api",
+                aprPercent: p.aprPercent,
+                poolTvlUsd: p.tvlUSD,
+                emissionUsd: p.curEpochEmissionRewardsUSD
+              });
+            }
+            return;
+          }
           const isGaugeProtocol = ["solidly_v2", "solidly_cl", "algebra_v3", "hybra"].includes(protocol.interface) || protocol.interface === "uniswap_v3" && protocol.contracts?.["voter"];
           if (isGaugeProtocol) {
             const chainTokens = registry.tokens.get(chainName)?.map((t) => t.address);
@@ -8815,7 +9397,7 @@ function registerLP(parent, getOpts, makeExecutor2) {
                 try {
                   const decoded = decodeFunctionResult8({ abi: mcAbi, functionName: "poolInfo", data: raw });
                   const [allocPoint, v3Pool, t0, t1, , totalLiq] = decoded;
-                  if (allocPoint === 0n || v3Pool === zeroAddress14) continue;
+                  if (allocPoint === 0n || v3Pool === zeroAddress13) continue;
                   const tokens = registry.tokens.get(chainName);
                   const sym0 = tokens?.find((t) => t.address.toLowerCase() === t0?.toLowerCase())?.symbol ?? t0?.slice(0, 8) ?? "?";
                   const sym1 = tokens?.find((t) => t.address.toLowerCase() === t1?.toLowerCase())?.symbol ?? t1?.slice(0, 8) ?? "?";
@@ -8882,7 +9464,7 @@ function registerLP(parent, getOpts, makeExecutor2) {
     if (opts.emissionOnly) {
       printOutput(
         results.filter(
-          (r) => r.type === "EMISSION" && ((r.moePerDay ?? 0) > 0 || r.rewardRate && BigInt(r.rewardRate) > 0n)
+          (r) => r.type === "EMISSION" && ((r.moePerDay ?? 0) > 0 || r.rewardRate && BigInt(r.rewardRate) > 0n || (r.aprPercent ?? 0) > 0)
         ),
         getOpts()
       );
@@ -8890,7 +9472,7 @@ function registerLP(parent, getOpts, makeExecutor2) {
       printOutput(results, getOpts());
     }
   });
-  lp.command("add").description("Add liquidity to a pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--amount-a <amount>", "Amount of token A in wei").requiredOption("--amount-b <amount>", "Amount of token B in wei").option("--pool <name_or_address>", "Pool name (e.g. WHYPE/USDC) or address").option("--recipient <address>", "Recipient address").option("--tick-lower <tick>", "Lower tick for concentrated LP (default: full range)").option("--tick-upper <tick>", "Upper tick for concentrated LP (default: full range)").option("--range <percent>", "\xB1N% concentrated range around current price (e.g. --range 2)").option("--num-bins <n>", "Merchant Moe LB: bins on each side of active (default 5)").action(async (opts) => {
+  lp.command("add").description("Add liquidity to a pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--amount-a <amount>", "Amount of token A in wei").requiredOption("--amount-b <amount>", "Amount of token B in wei").option("--pool <name_or_address>", "Pool name (e.g. WHYPE/USDC) or address").option("--recipient <address>", "Recipient address").option("--tick-lower <tick>", "Lower tick for concentrated LP (default: full range)").option("--tick-upper <tick>", "Upper tick for concentrated LP (default: full range)").option("--range <percent>", "\xB1N% concentrated range around current price (e.g. --range 2)").option("--num-bins <n>", "Merchant Moe LB: bins on each side of active (default 5)").option("--slippage <bps>", "Slippage tolerance in basis points (default 50 = 0.5%). Sets amount{0,1}Min per side via applyMinSlippage.").option("--amount-a-min <wei>", "Explicit minimum of token_a accepted on add (overrides --slippage for that side).").option("--amount-b-min <wei>", "Explicit minimum of token_b accepted on add (overrides --slippage for that side).").action(async (opts) => {
     const executor = makeExecutor2();
     const chainName = parent.opts().chain;
     if (!chainName) {
@@ -8907,13 +9489,27 @@ function registerLP(parent, getOpts, makeExecutor2) {
     if (protocol.interface === "uniswap_v2" && protocol.contracts?.["lb_factory"]) {
       if (!poolAddr) throw new Error(`--pool is required for ${protocol.name} (Liquidity Book \u2014 pass --pool <addr>; use \`lp discover --protocol ${protocol.slug}\` to list active pools)`);
       const lbAdapter = createMerchantMoeLB(protocol, chain.effectiveRpcUrl());
-      const [tokenX, tokenY, amountX, amountY] = tokenA.toLowerCase() < tokenB.toLowerCase() ? [tokenA, tokenB, BigInt(opts.amountA), BigInt(opts.amountB)] : [tokenB, tokenA, BigInt(opts.amountB), BigInt(opts.amountA)];
       const client = createPublicClient23({ transport: http23(chain.effectiveRpcUrl()) });
-      const binStep = await client.readContract({
-        address: poolAddr,
-        abi: parseAbi30(["function getBinStep() view returns (uint16)"]),
-        functionName: "getBinStep"
-      });
+      const lbPairOrderAbi = parseAbi30([
+        "function getTokenX() view returns (address)",
+        "function getTokenY() view returns (address)",
+        "function getBinStep() view returns (uint16)"
+      ]);
+      const [poolTokenX, poolTokenY, binStep] = await Promise.all([
+        client.readContract({ address: poolAddr, abi: lbPairOrderAbi, functionName: "getTokenX" }),
+        client.readContract({ address: poolAddr, abi: lbPairOrderAbi, functionName: "getTokenY" }),
+        client.readContract({ address: poolAddr, abi: lbPairOrderAbi, functionName: "getBinStep" })
+      ]);
+      const aIsX = tokenA.toLowerCase() === poolTokenX.toLowerCase();
+      const bIsX = tokenB.toLowerCase() === poolTokenX.toLowerCase();
+      const aIsY = tokenA.toLowerCase() === poolTokenY.toLowerCase();
+      const bIsY = tokenB.toLowerCase() === poolTokenY.toLowerCase();
+      if (!(aIsX && bIsY || bIsX && aIsY)) {
+        throw new Error(
+          `[${protocol.name}] --token-a/--token-b (${tokenA}/${tokenB}) do not match pool tokens (X=${poolTokenX}, Y=${poolTokenY})`
+        );
+      }
+      const [tokenX, tokenY, amountX, amountY] = aIsX ? [tokenA, tokenB, BigInt(opts.amountA), BigInt(opts.amountB)] : [tokenB, tokenA, BigInt(opts.amountB), BigInt(opts.amountA)];
       const tx2 = await lbAdapter.buildAddLiquidity({
         pool: poolAddr,
         tokenX,
@@ -8939,12 +9535,15 @@ function registerLP(parent, getOpts, makeExecutor2) {
       tick_lower: opts.tickLower !== void 0 ? parseInt(opts.tickLower) : void 0,
       tick_upper: opts.tickUpper !== void 0 ? parseInt(opts.tickUpper) : void 0,
       range_pct: opts.range !== void 0 ? parseFloat(opts.range) : void 0,
-      pool: poolAddr
+      pool: poolAddr,
+      slippage: opts.slippage !== void 0 ? { bps: parseInt(opts.slippage, 10) } : void 0,
+      amount_a_min: opts.amountAMin !== void 0 ? BigInt(opts.amountAMin) : void 0,
+      amount_b_min: opts.amountBMin !== void 0 ? BigInt(opts.amountBMin) : void 0
     });
     const result = await executor.execute(tx);
     printOutput(result, getOpts());
   });
-  lp.command("farm").description("Add liquidity and auto-stake into gauge/farming for emissions").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--amount-a <amount>", "Amount of token A in wei").requiredOption("--amount-b <amount>", "Amount of token B in wei").option("--pool <name_or_address>", "Pool name (e.g. WHYPE/USDC) or address").option("--gauge <address>", "Gauge address (required for solidly/hybra if not resolved automatically)").option("--recipient <address>", "Recipient / owner address").option("--tick-lower <tick>", "Lower tick for concentrated LP").option("--tick-upper <tick>", "Upper tick for concentrated LP").option("--range <percent>", "\xB1N% concentrated range around current price").action(async (opts) => {
+  lp.command("farm").description("Add liquidity and auto-stake into gauge/farming for emissions").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--amount-a <amount>", "Amount of token A in wei").requiredOption("--amount-b <amount>", "Amount of token B in wei").option("--pool <name_or_address>", "Pool name (e.g. WHYPE/USDC) or address").option("--gauge <address>", "Gauge address (required for solidly/hybra if not resolved automatically)").option("--recipient <address>", "Recipient / owner address").option("--tick-lower <tick>", "Lower tick for concentrated LP").option("--tick-upper <tick>", "Upper tick for concentrated LP").option("--range <percent>", "\xB1N% concentrated range around current price").option("--slippage <bps>", "Slippage tolerance in basis points (default 50 = 0.5%). Applied to the underlying mint step.").option("--amount-a-min <wei>", "Explicit minimum of token_a accepted on add (overrides --slippage for that side).").option("--amount-b-min <wei>", "Explicit minimum of token_b accepted on add (overrides --slippage for that side).").action(async (opts) => {
     const executor = makeExecutor2();
     const chainName = parent.opts().chain;
     if (!chainName) {
@@ -8970,7 +9569,10 @@ function registerLP(parent, getOpts, makeExecutor2) {
       tick_lower: opts.tickLower !== void 0 ? parseInt(opts.tickLower) : void 0,
       tick_upper: opts.tickUpper !== void 0 ? parseInt(opts.tickUpper) : void 0,
       range_pct: opts.range !== void 0 ? parseFloat(opts.range) : void 0,
-      pool: poolAddr
+      pool: poolAddr,
+      slippage: opts.slippage !== void 0 ? { bps: parseInt(opts.slippage, 10) } : void 0,
+      amount_a_min: opts.amountAMin !== void 0 ? BigInt(opts.amountAMin) : void 0,
+      amount_b_min: opts.amountBMin !== void 0 ? BigInt(opts.amountBMin) : void 0
     });
     process.stderr.write("Step 1/2: Adding liquidity...\n");
     const addResult = await executor.execute(addTx);
@@ -9210,7 +9812,7 @@ function registerLP(parent, getOpts, makeExecutor2) {
       note: "Plan output. Run each cli_command sequentially. After the mint step, broadcast mode prints `details.minted_token_id` \u2014 feed that into the next step's --token-id."
     }, getOpts());
   });
-  lp.command("remove").description("Auto-unstake (if staked) and remove liquidity from a pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--liquidity <amount>", "Liquidity amount to remove in wei").option("--pool <address>", "Pool address (needed to resolve gauge)").option("--gauge <address>", "Gauge contract address (for solidly/hybra unstake)").option("--token-id <id>", "NFT tokenId (for CL gauge or farming positions)").option("--recipient <address>", "Recipient address").option("--redeem-type <n>", "Hybra: 0=instant exit (with penalty), 1=lock into 2-year veHYBR (default \u2014 WARNING: long lock)").option("--bins <binIds>", "Merchant Moe LB: comma-separated bin IDs to withdraw").option("--amounts <wei>", "Merchant Moe LB: comma-separated bin amounts (parallel to --bins, default: full balance)").action(async (opts) => {
+  lp.command("remove").description("Auto-unstake (if staked) and remove liquidity from a pool").requiredOption("--protocol <protocol>", "Protocol slug").option("--token-a <token>", "First token symbol or address (required for V2/Curve/LB)").option("--token-b <token>", "Second token symbol or address (required for V2/Curve/LB)").option("--liquidity <amount>", "Liquidity amount to remove in wei (required for V2/Curve/LB)").option("--pool <address>", "Pool address (needed to resolve gauge)").option("--gauge <address>", "Gauge contract address (for solidly/hybra unstake)").option("--token-id <id>", "NFT tokenId (for CL gauge or farming positions)").option("--recipient <address>", "Recipient address").option("--redeem-type <n>", "Hybra: 0=instant exit (with penalty), 1=lock into 2-year veHYBR (default \u2014 WARNING: long lock)").option("--bins <binIds>", "Merchant Moe LB: comma-separated bin IDs to withdraw").option("--amount-a-min <wei>", "Explicit minimum of token_a accepted on remove (REQUIRED for V3/Algebra/Thena CL \u2014 caller must compute from positions(tokenId) + pool state and apply tolerance).").option("--amount-b-min <wei>", "Explicit minimum of token_b accepted on remove (REQUIRED for V3/Algebra/Thena CL).").option("--amounts <wei>", "Merchant Moe LB: comma-separated bin amounts (parallel to --bins, default: full balance)").action(async (opts) => {
     const executor = makeExecutor2();
     const chainName = parent.opts().chain;
     if (!chainName) {
@@ -9226,17 +9828,34 @@ function registerLP(parent, getOpts, makeExecutor2) {
     if (iface === "uniswap_v2" && protocol.contracts?.["lb_factory"]) {
       if (!opts.pool) throw new Error(`--pool is required for ${protocol.name} (Liquidity Book \u2014 pass --pool <addr>)`);
       if (!opts.bins) throw new Error("--bins <id1,id2,...> is required for Merchant Moe LB remove");
+      if (!opts.tokenA || !opts.tokenB) {
+        throw new Error(`--token-a and --token-b are required for ${protocol.name} (Liquidity Book) remove`);
+      }
       const lbAdapter = createMerchantMoeLB(protocol, rpcUrl);
       const tokenA2 = opts.tokenA.startsWith("0x") ? opts.tokenA : registry.resolveToken(chainName, opts.tokenA).address;
       const tokenB2 = opts.tokenB.startsWith("0x") ? opts.tokenB : registry.resolveToken(chainName, opts.tokenB).address;
-      const [tokenX, tokenY] = tokenA2.toLowerCase() < tokenB2.toLowerCase() ? [tokenA2, tokenB2] : [tokenB2, tokenA2];
       const binIds = opts.bins.split(",").map((s) => parseInt(s.trim()));
       const client = createPublicClient23({ transport: http23(rpcUrl) });
-      const binStep = await client.readContract({
-        address: opts.pool,
-        abi: parseAbi30(["function getBinStep() view returns (uint16)"]),
-        functionName: "getBinStep"
-      });
+      const lbPairOrderAbi = parseAbi30([
+        "function getTokenX() view returns (address)",
+        "function getTokenY() view returns (address)",
+        "function getBinStep() view returns (uint16)"
+      ]);
+      const [poolTokenX, poolTokenY, binStep] = await Promise.all([
+        client.readContract({ address: opts.pool, abi: lbPairOrderAbi, functionName: "getTokenX" }),
+        client.readContract({ address: opts.pool, abi: lbPairOrderAbi, functionName: "getTokenY" }),
+        client.readContract({ address: opts.pool, abi: lbPairOrderAbi, functionName: "getBinStep" })
+      ]);
+      const aIsX = tokenA2.toLowerCase() === poolTokenX.toLowerCase();
+      const bIsX = tokenB2.toLowerCase() === poolTokenX.toLowerCase();
+      const aIsY = tokenA2.toLowerCase() === poolTokenY.toLowerCase();
+      const bIsY = tokenB2.toLowerCase() === poolTokenY.toLowerCase();
+      if (!(aIsX && bIsY || bIsX && aIsY)) {
+        throw new Error(
+          `[${protocol.name}] --token-a/--token-b (${tokenA2}/${tokenB2}) do not match pool tokens (X=${poolTokenX}, Y=${poolTokenY})`
+        );
+      }
+      const [tokenX, tokenY] = aIsX ? [tokenA2, tokenB2] : [tokenB2, tokenA2];
       let amounts;
       if (opts.amounts) {
         amounts = opts.amounts.split(",").map((s) => BigInt(s.trim()));
@@ -9256,6 +9875,7 @@ function registerLP(parent, getOpts, makeExecutor2) {
         gas_estimate: 8e4
       };
       const tx = await lbAdapter.buildRemoveLiquidity({
+        pool: opts.pool,
         tokenX,
         tokenY,
         binStep,
@@ -9268,8 +9888,22 @@ function registerLP(parent, getOpts, makeExecutor2) {
       printOutput({ step: "lb_remove", ...result }, getOpts());
       return;
     }
-    const tokenA = opts.tokenA.startsWith("0x") ? opts.tokenA : registry.resolveToken(chainName, opts.tokenA).address;
-    const tokenB = opts.tokenB.startsWith("0x") ? opts.tokenB : registry.resolveToken(chainName, opts.tokenB).address;
+    const NFT_REMOVE_IFACES = /* @__PURE__ */ new Set(["uniswap_v3", "algebra_v3", "thena_cl", "hybra"]);
+    const isNftRemove = !!opts.tokenId && NFT_REMOVE_IFACES.has(iface);
+    if (!isNftRemove) {
+      const missing = [];
+      if (!opts.tokenA) missing.push("--token-a");
+      if (!opts.tokenB) missing.push("--token-b");
+      if (!opts.liquidity) missing.push("--liquidity");
+      if (missing.length > 0) {
+        printOutput({
+          error: `${missing.join(", ")} required for ${protocol.name} remove (or pass --token-id for V3/CL NFT-based remove).`
+        }, getOpts());
+        return;
+      }
+    }
+    const tokenA = opts.tokenA ? opts.tokenA.startsWith("0x") ? opts.tokenA : registry.resolveToken(chainName, opts.tokenA).address : void 0;
+    const tokenB = opts.tokenB ? opts.tokenB.startsWith("0x") ? opts.tokenB : registry.resolveToken(chainName, opts.tokenB).address : void 0;
     const poolAddr = opts.pool ? opts.pool : void 0;
     let didUnstake = false;
     if (iface === "algebra_v3" && protocol.contracts?.["farming_center"] && opts.tokenId && poolAddr) {
@@ -9319,7 +9953,7 @@ function registerLP(parent, getOpts, makeExecutor2) {
         if (iface === "hybra" && (!wOpts || wOpts.redeemType === 1)) {
           process.stderr.write("WARNING: Hybra default redeemType=1 locks rewards into 2-year veHYBR NFT. Pass --redeem-type 0 for instant exit (with penalty).\n");
         }
-        const withdrawTx = await gaugeAdapter.buildWithdraw(gaugeAddr, BigInt(opts.liquidity), tokenId, wOpts);
+        const withdrawTx = await gaugeAdapter.buildWithdraw(gaugeAddr, opts.liquidity ? BigInt(opts.liquidity) : 0n, tokenId, wOpts);
         const withdrawResult = await executor.execute(withdrawTx);
         printOutput({ step: "unstake_gauge", ...withdrawResult }, getOpts());
         if (withdrawResult.status !== "confirmed" && withdrawResult.status !== "simulated") {
@@ -9334,13 +9968,37 @@ function registerLP(parent, getOpts, makeExecutor2) {
     }
     process.stderr.write("Step 2/2: Removing liquidity...\n");
     const dexAdapter = createDex(protocol, rpcUrl);
+    let removeLiquidity = opts.liquidity ? BigInt(opts.liquidity) : 0n;
+    if (isNftRemove && removeLiquidity === 0n) {
+      const npm = protocol.contracts?.["position_manager"];
+      if (npm) {
+        const c = createPublicClient23({ transport: http23(rpcUrl) });
+        const pos = await detectV3Liquidity(c, npm, BigInt(opts.tokenId));
+        if (pos) {
+          removeLiquidity = pos.liquidity;
+          process.stderr.write(`  Read live liquidity ${removeLiquidity} from NPM.positions(${opts.tokenId}).
+`);
+        }
+      }
+    }
+    if (isNftRemove && removeLiquidity === 0n) {
+      printOutput({
+        error: `tokenId ${opts.tokenId} has zero liquidity (already removed?). Pass --liquidity explicitly to override, or pick a different tokenId.`
+      }, getOpts());
+      return;
+    }
+    const ZERO = "0x0000000000000000000000000000000000000000";
+    const removePoolAddr = opts.pool ? resolvePoolAddress(registry, opts.protocol, opts.pool) : void 0;
     const removeTx = await dexAdapter.buildRemoveLiquidity({
       protocol: protocol.name,
-      token_a: tokenA,
-      token_b: tokenB,
-      liquidity: BigInt(opts.liquidity),
+      token_a: tokenA ?? ZERO,
+      token_b: tokenB ?? ZERO,
+      liquidity: removeLiquidity,
       recipient,
-      token_id: opts.tokenId ? BigInt(opts.tokenId) : void 0
+      token_id: opts.tokenId ? BigInt(opts.tokenId) : void 0,
+      amount_a_min: opts.amountAMin !== void 0 ? BigInt(opts.amountAMin) : void 0,
+      amount_b_min: opts.amountBMin !== void 0 ? BigInt(opts.amountBMin) : void 0,
+      pool: removePoolAddr
     });
     const removeResult = await executor.execute(removeTx);
     printOutput({ step: "lp_remove", ...removeResult }, getOpts());
@@ -9693,6 +10351,7 @@ function registerLP(parent, getOpts, makeExecutor2) {
 // src/commands/lending.ts
 init_dist();
 init_dist2();
+import { maxUint256 } from "viem";
 
 // src/utils.ts
 init_dist();
@@ -9717,12 +10376,20 @@ function resolveTokenAddress(registry, chainName, tokenOrAddress) {
   return registry.resolveToken(chainName, tokenOrAddress).address;
 }
 var FALLBACK_ADDRESS = "0x0000000000000000000000000000000000000001";
+var warnedFallback = false;
 function resolveWallet(override) {
   if (override) return override;
   try {
     const { address } = resolveWalletWithSigner();
     return address;
   } catch {
+    if (!warnedFallback) {
+      process.stderr.write(
+        `WARNING: no wallet configured (set DEFI_WALLET_ADDRESS or DEFI_PRIVATE_KEY, or use --wallet <name>). Using placeholder ${FALLBACK_ADDRESS} for dry-run preview ONLY \u2014 do NOT pass --broadcast with this address.
+`
+      );
+      warnedFallback = true;
+    }
     return FALLBACK_ADDRESS;
   }
 }
@@ -9734,6 +10401,26 @@ function parseBigIntValue(v) {
 }
 
 // src/commands/lending.ts
+function parseAmount(s) {
+  const lower = s.toLowerCase();
+  if (lower === "max" || lower === "all") return maxUint256;
+  return BigInt(s);
+}
+function resolveMarketInput(adapter, raw) {
+  if (!raw) return void 0;
+  if (/^0x[0-9a-fA-F]{64}$/.test(raw)) return raw;
+  if (typeof adapter.resolveMarketIdByName !== "function") {
+    throw new Error(
+      `--market must be a 32-byte hex value; got '${raw}'. This adapter does not support named-market lookup.`
+    );
+  }
+  const id = adapter.resolveMarketIdByName(raw);
+  if (id) return id;
+  const known = adapter.listNamedMarkets?.()?.map((m) => m.name).join(", ") ?? "(none)";
+  throw new Error(
+    `--market '${raw}' is not a 32-byte hex and is not registered on this protocol. Known markets: ${known}.`
+  );
+}
 function registerLending(parent, getOpts, makeExecutor2) {
   const lending = parent.command("lending").description("Lending operations: supply, borrow, repay, withdraw, rates, position");
   lending.command("rates").description("Show current lending rates").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").action(async (opts) => {
@@ -9756,18 +10443,24 @@ function registerLending(parent, getOpts, makeExecutor2) {
     const position = await adapter.getUserPosition(address);
     printOutput(position, getOpts());
   });
-  lending.command("supply").description("Supply an asset to a lending protocol").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount to supply in wei").option("--on-behalf-of <address>", "On behalf of address").action(async (opts) => {
+  lending.command("supply").description("Supply an asset to a lending protocol").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount to supply in wei (or 'max')").option("--market <marketId>", "Morpho Blue marketId (32-byte hex) \u2014 required for direct Morpho markets, ignored elsewhere").option("--on-behalf-of <address>", "On behalf of address").action(async (opts) => {
     const executor = makeExecutor2();
     const ctx = resolveContext(parent, getOpts, opts.protocol);
     if (!ctx) return;
     const adapter = createLending(ctx.protocol, ctx.rpcUrl);
     const asset = resolveTokenAddress(ctx.registry, ctx.chainName, opts.asset);
     const onBehalfOf = resolveWallet(opts.onBehalfOf);
-    const tx = await adapter.buildSupply({ protocol: ctx.protocol.name, asset, amount: BigInt(opts.amount), on_behalf_of: onBehalfOf });
+    const tx = await adapter.buildSupply({
+      protocol: ctx.protocol.name,
+      asset,
+      amount: parseAmount(opts.amount),
+      on_behalf_of: onBehalfOf,
+      market_id: resolveMarketInput(adapter, opts.market)
+    });
     const result = await executor.execute(tx);
     printOutput(result, getOpts());
   });
-  lending.command("borrow").description("Borrow an asset").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount in wei").option("--rate-mode <mode>", "variable or stable", "variable").option("--on-behalf-of <address>", "On behalf of address").action(async (opts) => {
+  lending.command("borrow").description("Borrow an asset").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount in wei (or 'max')").option("--rate-mode <mode>", "variable or stable", "variable").option("--market <marketId>", "Morpho Blue marketId (32-byte hex) \u2014 required for direct Morpho markets, ignored elsewhere").option("--on-behalf-of <address>", "On behalf of address").action(async (opts) => {
     const executor = makeExecutor2();
     const ctx = resolveContext(parent, getOpts, opts.protocol);
     if (!ctx) return;
@@ -9777,14 +10470,15 @@ function registerLending(parent, getOpts, makeExecutor2) {
     const tx = await adapter.buildBorrow({
       protocol: ctx.protocol.name,
       asset,
-      amount: BigInt(opts.amount),
+      amount: parseAmount(opts.amount),
       interest_rate_mode: opts.rateMode === "stable" ? InterestRateMode.Stable : InterestRateMode.Variable,
-      on_behalf_of: onBehalfOf
+      on_behalf_of: onBehalfOf,
+      market_id: resolveMarketInput(adapter, opts.market)
     });
     const result = await executor.execute(tx);
     printOutput(result, getOpts());
   });
-  lending.command("repay").description("Repay a borrowed asset").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount in wei").option("--rate-mode <mode>", "variable or stable", "variable").option("--on-behalf-of <address>", "On behalf of address").action(async (opts) => {
+  lending.command("repay").description("Repay a borrowed asset").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount in wei (or 'max')").option("--rate-mode <mode>", "variable or stable", "variable").option("--market <marketId>", "Morpho Blue marketId (32-byte hex) \u2014 required for direct Morpho markets, ignored elsewhere").option("--on-behalf-of <address>", "On behalf of address").action(async (opts) => {
     const executor = makeExecutor2();
     const ctx = resolveContext(parent, getOpts, opts.protocol);
     if (!ctx) return;
@@ -9794,21 +10488,150 @@ function registerLending(parent, getOpts, makeExecutor2) {
     const tx = await adapter.buildRepay({
       protocol: ctx.protocol.name,
       asset,
-      amount: BigInt(opts.amount),
+      amount: parseAmount(opts.amount),
       interest_rate_mode: opts.rateMode === "stable" ? InterestRateMode.Stable : InterestRateMode.Variable,
-      on_behalf_of: onBehalfOf
+      on_behalf_of: onBehalfOf,
+      market_id: resolveMarketInput(adapter, opts.market)
     });
     const result = await executor.execute(tx);
     printOutput(result, getOpts());
   });
-  lending.command("withdraw").description("Withdraw a supplied asset").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount in wei").option("--to <address>", "Recipient address").action(async (opts) => {
+  lending.command("withdraw").description("Withdraw a supplied asset").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount in wei (or 'max')").option("--market <marketId>", "Morpho Blue marketId (32-byte hex) \u2014 required for direct Morpho markets, ignored elsewhere").option("--to <address>", "Recipient address").action(async (opts) => {
     const executor = makeExecutor2();
     const ctx = resolveContext(parent, getOpts, opts.protocol);
     if (!ctx) return;
     const adapter = createLending(ctx.protocol, ctx.rpcUrl);
     const asset = resolveTokenAddress(ctx.registry, ctx.chainName, opts.asset);
     const to = resolveWallet(opts.to);
-    const tx = await adapter.buildWithdraw({ protocol: ctx.protocol.name, asset, amount: BigInt(opts.amount), to });
+    const tx = await adapter.buildWithdraw({
+      protocol: ctx.protocol.name,
+      asset,
+      amount: parseAmount(opts.amount),
+      to,
+      market_id: resolveMarketInput(adapter, opts.market)
+    });
+    const result = await executor.execute(tx);
+    printOutput(result, getOpts());
+  });
+  lending.command("toggle-collateral").description("Enable or disable a supplied reserve as collateral (Aave V3 family)").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--asset <token>", "Token symbol or address").option("--enable", "Enable as collateral").option("--disable", "Disable as collateral").action(async (opts) => {
+    const executor = makeExecutor2();
+    const ctx = resolveContext(parent, getOpts, opts.protocol);
+    if (!ctx) return;
+    if (!opts.enable && !opts.disable) {
+      printOutput({ error: "must pass either --enable or --disable" }, getOpts());
+      return;
+    }
+    if (opts.enable && opts.disable) {
+      printOutput({ error: "--enable and --disable are mutually exclusive" }, getOpts());
+      return;
+    }
+    const adapter = createLending(ctx.protocol, ctx.rpcUrl);
+    if (typeof adapter.buildSetUseReserveAsCollateral !== "function") {
+      printOutput({
+        error: `[${ctx.protocol.name}] adapter does not implement buildSetUseReserveAsCollateral. Aave V3 forks support this; Compound V2/Morpho Blue use different flows.`
+      }, getOpts());
+      return;
+    }
+    const asset = resolveTokenAddress(ctx.registry, ctx.chainName, opts.asset);
+    const tx = await adapter.buildSetUseReserveAsCollateral(asset, !!opts.enable);
+    const result = await executor.execute(tx);
+    printOutput(result, getOpts());
+  });
+  lending.command("set-emode").description("Enroll the user in an Aave V3 efficiency-mode category (0 to opt out)").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--category-id <id>", "eMode category id (0 = opt out)").action(async (opts) => {
+    const executor = makeExecutor2();
+    const ctx = resolveContext(parent, getOpts, opts.protocol);
+    if (!ctx) return;
+    const adapter = createLending(ctx.protocol, ctx.rpcUrl);
+    if (typeof adapter.buildSetEMode !== "function") {
+      printOutput({
+        error: `[${ctx.protocol.name}] adapter does not implement buildSetEMode (Aave V3 only)`
+      }, getOpts());
+      return;
+    }
+    const id = parseInt(opts.categoryId, 10);
+    if (!Number.isInteger(id) || id < 0 || id > 255) {
+      printOutput({ error: `--category-id must be an integer in [0, 255], got '${opts.categoryId}'` }, getOpts());
+      return;
+    }
+    const tx = await adapter.buildSetEMode(id);
+    const result = await executor.execute(tx);
+    printOutput(result, getOpts());
+  });
+  lending.command("enter-markets").description("Compound V2 (Venus): enter supplied assets as collateral via Comptroller.enterMarkets").requiredOption("--protocol <protocol>", "Protocol slug (must be a Compound V2 fork)").requiredOption("--asset <token>", "Underlying asset symbol or address (resolved to its cToken)").action(async (opts) => {
+    const executor = makeExecutor2();
+    const ctx = resolveContext(parent, getOpts, opts.protocol);
+    if (!ctx) return;
+    const adapter = createLending(ctx.protocol, ctx.rpcUrl);
+    if (typeof adapter.buildEnterMarkets !== "function") {
+      printOutput({
+        error: `[${ctx.protocol.name}] adapter does not implement buildEnterMarkets. This is a Compound V2 family operation; Aave V3 uses toggle-collateral instead.`
+      }, getOpts());
+      return;
+    }
+    const asset = resolveTokenAddress(ctx.registry, ctx.chainName, opts.asset);
+    const contracts = ctx.protocol.contracts ?? {};
+    const vTokenEntries = Object.entries(contracts).filter(([k]) => /^v[a-z][a-z0-9]*$/i.test(k));
+    if (vTokenEntries.length === 0) {
+      printOutput({ error: `[${ctx.protocol.name}] no vTokens registered in TOML` }, getOpts());
+      return;
+    }
+    const symbol = opts.asset.toLowerCase();
+    const matchedKey = vTokenEntries.find(([k]) => k.toLowerCase() === `v${symbol}`);
+    const vToken = matchedKey ? matchedKey[1] : void 0;
+    if (!vToken) {
+      printOutput({
+        error: `[${ctx.protocol.name}] could not resolve a vToken for '${opts.asset}'. Registered vTokens: ${vTokenEntries.map(([k]) => k).join(", ")}. Pass --asset matching the symbol after the 'v' prefix (e.g. USDT for vusdt).`
+      }, getOpts());
+      return;
+    }
+    void asset;
+    const tx = await adapter.buildEnterMarkets([vToken]);
+    const result = await executor.execute(tx);
+    printOutput(result, getOpts());
+  });
+  lending.command("supply-collateral").description("Supply the collateral side of a Morpho Blue market (different selector from supply)").requiredOption("--protocol <protocol>", "Protocol slug (must be a Morpho Blue adapter)").requiredOption("--asset <token>", "Collateral token symbol or address").requiredOption("--amount <amount>", "Amount in wei (or 'max')").requiredOption("--market <marketId>", "32-byte Morpho marketId (find via Morpho API)").option("--on-behalf-of <address>", "On behalf of address").action(async (opts) => {
+    const executor = makeExecutor2();
+    const ctx = resolveContext(parent, getOpts, opts.protocol);
+    if (!ctx) return;
+    const adapter = createLending(ctx.protocol, ctx.rpcUrl);
+    if (typeof adapter.buildSupplyCollateral !== "function") {
+      printOutput({
+        error: `[${ctx.protocol.name}] adapter does not implement buildSupplyCollateral. Only Morpho Blue forks expose this; Aave V3 / Compound use plain supply.`
+      }, getOpts());
+      return;
+    }
+    const asset = resolveTokenAddress(ctx.registry, ctx.chainName, opts.asset);
+    const onBehalfOf = resolveWallet(opts.onBehalfOf);
+    const tx = await adapter.buildSupplyCollateral({
+      protocol: ctx.protocol.name,
+      asset,
+      amount: parseAmount(opts.amount),
+      on_behalf_of: onBehalfOf,
+      market_id: resolveMarketInput(adapter, opts.market)
+    });
+    const result = await executor.execute(tx);
+    printOutput(result, getOpts());
+  });
+  lending.command("withdraw-collateral").description("Withdraw the collateral side of a Morpho Blue market").requiredOption("--protocol <protocol>", "Protocol slug (must be a Morpho Blue adapter)").requiredOption("--asset <token>", "Collateral token symbol or address").requiredOption("--amount <amount>", "Amount in wei (or 'max')").requiredOption("--market <marketId>", "32-byte Morpho marketId").option("--to <address>", "Recipient address").action(async (opts) => {
+    const executor = makeExecutor2();
+    const ctx = resolveContext(parent, getOpts, opts.protocol);
+    if (!ctx) return;
+    const adapter = createLending(ctx.protocol, ctx.rpcUrl);
+    if (typeof adapter.buildWithdrawCollateral !== "function") {
+      printOutput({
+        error: `[${ctx.protocol.name}] adapter does not implement buildWithdrawCollateral.`
+      }, getOpts());
+      return;
+    }
+    const asset = resolveTokenAddress(ctx.registry, ctx.chainName, opts.asset);
+    const to = resolveWallet(opts.to);
+    const tx = await adapter.buildWithdrawCollateral({
+      protocol: ctx.protocol.name,
+      asset,
+      amount: parseAmount(opts.amount),
+      to,
+      market_id: resolveMarketInput(adapter, opts.market)
+    });
     const result = await executor.execute(tx);
     printOutput(result, getOpts());
   });
@@ -9825,7 +10648,8 @@ function resolveAsset(registry, chain, asset) {
 }
 async function collectLendingRates(registry, chainName, rpc, assetAddr) {
   const protos = registry.getProtocolsForChain(chainName).filter((p) => p.category === ProtocolCategory.Lending);
-  const results = [];
+  const rates = [];
+  const errors = [];
   let first = true;
   for (const proto of protos) {
     if (!first) {
@@ -9834,19 +10658,22 @@ async function collectLendingRates(registry, chainName, rpc, assetAddr) {
     first = false;
     try {
       const lending = createLending(proto, rpc);
-      const rates = await lending.getRates(assetAddr);
-      results.push(rates);
+      const r = await lending.getRates(assetAddr);
+      rates.push(r);
     } catch (err) {
       process.stderr.write(`Warning: ${proto.name} rates unavailable: ${err}
 `);
+      errors.push({ protocol: proto.name, type: "lending_supply", reason: errMsg(err) });
     }
   }
-  return results;
+  return { rates, errors };
 }
 async function collectAllYields(registry, chainName, rpc, asset, assetAddr) {
   const opportunities = [];
-  const lendingRates = await collectLendingRates(registry, chainName, rpc, assetAddr);
-  for (const r of lendingRates) {
+  const errors = [];
+  const lendingResult = await collectLendingRates(registry, chainName, rpc, assetAddr);
+  errors.push(...lendingResult.errors);
+  for (const r of lendingResult.rates) {
     if (r.supply_apy > 0) {
       opportunities.push({
         protocol: r.protocol,
@@ -9872,7 +10699,8 @@ async function collectAllYields(registry, chainName, rpc, asset, assetAddr) {
             utilization: rates.utilization
           });
         }
-      } catch {
+      } catch (e) {
+        errors.push({ protocol: proto.name, type: "morpho_vault", reason: errMsg(e) });
       }
     }
   }
@@ -9888,7 +10716,8 @@ async function collectAllYields(registry, chainName, rpc, asset, assetAddr) {
           apy: info.apy ?? 0,
           total_assets: info.total_assets.toString()
         });
-      } catch {
+      } catch (e) {
+        errors.push({ protocol: proto.name, type: "vault", reason: errMsg(e) });
       }
     }
   }
@@ -9897,7 +10726,7 @@ async function collectAllYields(registry, chainName, rpc, asset, assetAddr) {
     const ba = b["apy"] ?? 0;
     return ba - aa;
   });
-  return opportunities;
+  return { opportunities, errors };
 }
 async function runYieldScan(registry, asset, output) {
   const t0 = Date.now();
@@ -10039,10 +10868,13 @@ function registerYield(parent, getOpts, makeExecutor2) {
       const chain = registry.getChain(chainName);
       const rpc = chain.effectiveRpcUrl();
       const assetAddr = resolveAsset(registry, chainName, opts.asset);
-      const results = await collectLendingRates(registry, chainName, rpc, assetAddr);
+      const { rates: results, errors: ratesErrors } = await collectLendingRates(registry, chainName, rpc, assetAddr);
       if (results.length === 0) {
         printOutput(
-          { error: `No lending rate data available for asset '${opts.asset}'` },
+          ratesErrors.length > 0 ? {
+            error: `Could not collect lending rates for '${opts.asset}': ${ratesErrors.length} probe(s) failed (likely RPC throttling). Retry, or set ${chainName.toUpperCase()}_RPC_URL.`,
+            failed_probes: ratesErrors
+          } : { error: `No lending rate data available for asset '${opts.asset}'` },
           getOpts()
         );
         process.exit(1);
@@ -10284,9 +11116,16 @@ function registerYield(parent, getOpts, makeExecutor2) {
       const assetAddr = resolveAsset(registry, chainName, asset);
       const strategy = opts.strategy ?? "auto";
       if (strategy === "auto") {
-        const opportunities = await collectAllYields(registry, chainName, rpc, asset, assetAddr);
+        const { opportunities, errors } = await collectAllYields(registry, chainName, rpc, asset, assetAddr);
         if (opportunities.length === 0) {
-          printOutput({ error: `No yield opportunities found for '${asset}'` }, getOpts());
+          if (errors.length > 0) {
+            printOutput({
+              error: `Could not collect yield data for '${asset}': ${errors.length} probe(s) failed (likely RPC throttling or transport error). Retry, or set a private RPC URL via ${chainName.toUpperCase()}_RPC_URL.`,
+              failed_probes: errors
+            }, getOpts());
+          } else {
+            printOutput({ error: `No yield opportunities found for '${asset}'` }, getOpts());
+          }
           process.exit(1);
           return;
         }
@@ -10316,9 +11155,12 @@ function registerYield(parent, getOpts, makeExecutor2) {
           getOpts()
         );
       } else if (strategy === "best-supply") {
-        const results = await collectLendingRates(registry, chainName, rpc, assetAddr);
+        const { rates: results, errors: rErr } = await collectLendingRates(registry, chainName, rpc, assetAddr);
         if (results.length === 0) {
-          printOutput({ error: `No lending rate data available for asset '${asset}'` }, getOpts());
+          printOutput(
+            rErr.length > 0 ? { error: `Could not collect lending rates for '${asset}': ${rErr.length} probe(s) failed (RPC throttling likely).`, failed_probes: rErr } : { error: `No lending rate data available for asset '${asset}'` },
+            getOpts()
+          );
           process.exit(1);
           return;
         }
@@ -10341,9 +11183,12 @@ function registerYield(parent, getOpts, makeExecutor2) {
           getOpts()
         );
       } else if (strategy === "leverage-loop") {
-        const results = await collectLendingRates(registry, chainName, rpc, assetAddr);
+        const { rates: results, errors: lErr } = await collectLendingRates(registry, chainName, rpc, assetAddr);
         if (results.length === 0) {
-          printOutput({ error: `No lending rate data available for asset '${asset}'` }, getOpts());
+          printOutput(
+            lErr.length > 0 ? { error: `Could not collect lending rates for '${asset}': ${lErr.length} probe(s) failed (RPC throttling likely).`, failed_probes: lErr } : { error: `No lending rate data available for asset '${asset}'` },
+            getOpts()
+          );
           process.exit(1);
           return;
         }
@@ -10407,14 +11252,14 @@ function registerYield(parent, getOpts, makeExecutor2) {
 
 // src/commands/portfolio.ts
 init_dist();
-import { encodeFunctionData as encodeFunctionData29, parseAbi as parseAbi33 } from "viem";
+import { createPublicClient as createPublicClient25, encodeFunctionData as encodeFunctionData29, http as http25, parseAbi as parseAbi33 } from "viem";
 
 // src/portfolio-tracker.ts
 init_dist();
 import { mkdirSync, writeFileSync, readdirSync as readdirSync2, readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
 import { homedir } from "os";
 import { resolve as resolve3 } from "path";
-import { encodeFunctionData as encodeFunctionData28, parseAbi as parseAbi31 } from "viem";
+import { createPublicClient as createPublicClient24, encodeFunctionData as encodeFunctionData28, http as http24, parseAbi as parseAbi31 } from "viem";
 var ERC20_ABI4 = parseAbi31([
   "function balanceOf(address owner) external view returns (uint256)"
 ]);
@@ -10465,7 +11310,16 @@ async function takeSnapshot(chainName, wallet, registry) {
   const oracleEntry = registry.getProtocolsForChain(chainName).find((p) => p.interface === "aave_v3" && p.contracts?.["oracle"]);
   const oracleAddr = oracleEntry?.contracts?.["oracle"];
   const wrappedNative = chain.wrapped_native ?? "0x5555555555555555555555555555555555555555";
+  const priceTokens = [];
   if (oracleAddr) {
+    for (const t of tokenEntries) {
+      calls.push([
+        oracleAddr,
+        encodeFunctionData28({ abi: ORACLE_ABI4, functionName: "getAssetPrice", args: [t.address] })
+      ]);
+      callLabels.push(`price:${t.address}`);
+      priceTokens.push(t.address);
+    }
     calls.push([
       oracleAddr,
       encodeFunctionData28({ abi: ORACLE_ABI4, functionName: "getAssetPrice", args: [wrappedNative] })
@@ -10476,10 +11330,19 @@ async function takeSnapshot(chainName, wallet, registry) {
   if (calls.length > 0) {
     results = await multicallRead(rpc, calls);
   }
+  const balanceCount = tokenEntries.length;
+  const lendingCount = lendingProtocols.length;
+  const priceStartIdx = balanceCount + lendingCount;
   let nativePriceUsd = 0;
+  const priceByToken = /* @__PURE__ */ new Map();
   if (oracleAddr) {
-    const priceData = results[results.length - 1] ?? null;
-    nativePriceUsd = Number(decodeU256Word(priceData)) / 1e8;
+    for (let i = 0; i < priceTokens.length; i++) {
+      const priceData = results[priceStartIdx + i] ?? null;
+      const px = Number(decodeU256Word(priceData)) / 1e8;
+      if (px > 0) priceByToken.set(priceTokens[i].toLowerCase(), px);
+    }
+    const nativePriceData = results[priceStartIdx + priceTokens.length] ?? null;
+    nativePriceUsd = Number(decodeU256Word(nativePriceData)) / 1e8;
   }
   let idx = 0;
   const tokens = [];
@@ -10489,8 +11352,20 @@ async function takeSnapshot(chainName, wallet, registry) {
     const balance = decodeU256Word(results[idx] ?? null);
     const balF64 = Number(balance) / 10 ** entry.decimals;
     const symbolUpper = entry.symbol.toUpperCase();
-    const priceUsd = symbolUpper.includes("USD") ? 1 : nativePriceUsd;
-    const valueUsd = balF64 * priceUsd;
+    const tokenAddrLower = entry.address.toLowerCase();
+    let priceUsd;
+    let valueUsd;
+    if (symbolUpper.includes("USD")) {
+      priceUsd = 1;
+      valueUsd = balF64;
+    } else if (tokenAddrLower === wrappedNative.toLowerCase()) {
+      priceUsd = nativePriceUsd;
+      valueUsd = balF64 * nativePriceUsd;
+    } else {
+      const px = priceByToken.get(tokenAddrLower);
+      priceUsd = px ?? 0;
+      valueUsd = px && px > 0 ? balF64 * px : 0;
+    }
     totalValueUsd += valueUsd;
     tokens.push({
       token: entry.address,
@@ -10531,6 +11406,23 @@ async function takeSnapshot(chainName, wallet, registry) {
     }
     idx++;
   }
+  try {
+    const client = createPublicClient24({ transport: http24(rpc) });
+    const nativeBalance = await client.getBalance({ address: user });
+    if (nativeBalance > 0n) {
+      const nativeF64 = Number(nativeBalance) / 1e18;
+      const nativeValueUsd = nativeF64 * nativePriceUsd;
+      totalValueUsd += nativeValueUsd;
+      tokens.push({
+        token: wrappedNative,
+        symbol: chain.native_token ?? "NATIVE",
+        balance: nativeBalance,
+        value_usd: nativeValueUsd,
+        price_usd: nativePriceUsd
+      });
+    }
+  } catch {
+  }
   return {
     timestamp: Date.now(),
     chain: chainName,
@@ -10648,6 +11540,10 @@ function registerPortfolio(parent, getOpts) {
     const calls = [];
     const callLabels = [];
     const tokenSymbols = (registry.tokens.get(chainName) ?? []).map((t) => t.symbol);
+    const tokenAddrsByCallIdx = [];
+    const oracleEntry = registry.getProtocolsForChain(chainName).find((p) => p.interface === "aave_v3" && p.contracts?.["oracle"]);
+    const oracleAddr = oracleEntry?.contracts?.["oracle"];
+    const wrappedNative = chain.wrapped_native ?? "0x5555555555555555555555555555555555555555";
     for (const symbol of tokenSymbols) {
       let entry;
       try {
@@ -10661,6 +11557,7 @@ function registerPortfolio(parent, getOpts) {
         encodeFunctionData29({ abi: ERC20_ABI5, functionName: "balanceOf", args: [user] })
       ]);
       callLabels.push(`balance:${symbol}`);
+      tokenAddrsByCallIdx.push(entry.address);
     }
     const lendingProtocols = registry.getProtocolsForChain(chainName).filter((p) => p.category === ProtocolCategory.Lending && p.interface === "aave_v3").filter((p) => p.contracts?.["pool"]);
     for (const p of lendingProtocols) {
@@ -10670,10 +11567,16 @@ function registerPortfolio(parent, getOpts) {
       ]);
       callLabels.push(`lending:${p.name}`);
     }
-    const oracleEntry = registry.getProtocolsForChain(chainName).find((p) => p.interface === "aave_v3" && p.contracts?.["oracle"]);
-    const oracleAddr = oracleEntry?.contracts?.["oracle"];
-    const wrappedNative = chain.wrapped_native ?? "0x5555555555555555555555555555555555555555";
+    const priceTokens = [];
     if (oracleAddr) {
+      for (const tokenAddr of tokenAddrsByCallIdx) {
+        calls.push([
+          oracleAddr,
+          encodeFunctionData29({ abi: ORACLE_ABI5, functionName: "getAssetPrice", args: [tokenAddr] })
+        ]);
+        callLabels.push(`price:${tokenAddr}`);
+        priceTokens.push(tokenAddr);
+      }
       calls.push([
         oracleAddr,
         encodeFunctionData29({ abi: ORACLE_ABI5, functionName: "getAssetPrice", args: [wrappedNative] })
@@ -10698,10 +11601,19 @@ function registerPortfolio(parent, getOpts) {
       printOutput({ error: `Multicall failed: ${errMsg(e)}` }, mode);
       return;
     }
+    const balanceCallCount = tokenAddrsByCallIdx.length;
+    const lendingCallCount = lendingProtocols.length;
+    const priceStartIdx = balanceCallCount + lendingCallCount;
     let nativePriceUsd = 0;
+    const priceByToken = /* @__PURE__ */ new Map();
     if (oracleAddr) {
-      const priceData = results[results.length - 1] ?? null;
-      nativePriceUsd = Number(decodeU2562(priceData)) / 1e8;
+      for (let i = 0; i < priceTokens.length; i++) {
+        const priceData = results[priceStartIdx + i] ?? null;
+        const px = Number(decodeU2562(priceData)) / 1e8;
+        if (px > 0) priceByToken.set(priceTokens[i].toLowerCase(), px);
+      }
+      const nativePriceData = results[priceStartIdx + priceTokens.length] ?? null;
+      nativePriceUsd = Number(decodeU2562(nativePriceData)) / 1e8;
     }
     let totalValueUsd = 0;
     let idx = 0;
@@ -10720,12 +11632,21 @@ function registerPortfolio(parent, getOpts) {
         const decimals = entry.decimals;
         const balF64 = Number(balance) / 10 ** decimals;
         const symbolUpper = symbol.toUpperCase();
-        const valueUsd = symbolUpper.includes("USD") || symbolUpper.includes("usd") ? balF64 : balF64 * nativePriceUsd;
-        totalValueUsd += valueUsd;
+        const tokenAddrLower = entry.address.toLowerCase();
+        let valueUsd;
+        if (symbolUpper.includes("USD")) {
+          valueUsd = balF64;
+        } else if (tokenAddrLower === wrappedNative.toLowerCase()) {
+          valueUsd = balF64 * nativePriceUsd;
+        } else {
+          const px = priceByToken.get(tokenAddrLower);
+          valueUsd = px && px > 0 ? balF64 * px : null;
+        }
+        if (valueUsd !== null) totalValueUsd += valueUsd;
         tokenBalances.push({
           symbol,
           balance: balF64.toFixed(4),
-          value_usd: valueUsd.toFixed(2)
+          value_usd: valueUsd !== null ? valueUsd.toFixed(2) : null
         });
       }
       idx++;
@@ -10755,11 +11676,23 @@ function registerPortfolio(parent, getOpts) {
       }
       idx++;
     }
+    let nativeBalance = 0n;
+    let nativeValueUsd = 0;
+    try {
+      const client = createPublicClient25({ transport: http25(rpc) });
+      nativeBalance = await client.getBalance({ address: user });
+      const nativeF64 = Number(nativeBalance) / 1e18;
+      nativeValueUsd = nativeF64 * nativePriceUsd;
+      if (nativeBalance > 0n) totalValueUsd += nativeValueUsd;
+    } catch {
+    }
     printOutput(
       {
         address: user,
         chain: chain.name,
         native_price_usd: nativePriceUsd.toFixed(2),
+        native_balance: (Number(nativeBalance) / 1e18).toFixed(6),
+        native_value_usd: nativeValueUsd.toFixed(2),
         total_value_usd: totalValueUsd.toFixed(2),
         token_balances: tokenBalances,
         lending_positions: lendingPositions
@@ -11025,38 +11958,50 @@ function registerPrice(parent, getOpts) {
 
 // src/commands/wallet.ts
 init_dist();
-import { createPublicClient as createPublicClient24, http as http24, formatEther } from "viem";
+import { createPublicClient as createPublicClient26, http as http26, formatEther } from "viem";
+function resolveCurrentAddress(override) {
+  if (override) return { address: override, source: "flag" };
+  try {
+    const { address, signer } = resolveWalletWithSigner();
+    return { address, source: signer ? "ows" : process.env["DEFI_PRIVATE_KEY"] ? "private_key" : "env" };
+  } catch {
+    return { address: null, source: "none" };
+  }
+}
 function registerWallet(parent, getOpts) {
   const wallet = parent.command("wallet").description("Wallet management");
-  wallet.command("balance").description("Show native token balance").option("--address <address>", "Wallet address (defaults to DEFI_WALLET_ADDRESS)").action(async (opts) => {
+  wallet.command("balance").description("Show native token balance").option("--address <address>", "Wallet address (defaults to OWS vault, DEFI_PRIVATE_KEY, or DEFI_WALLET_ADDRESS)").action(async (opts) => {
     const chainName = requireChain(parent, getOpts);
     if (!chainName) return;
-    const addr = opts.address ?? process.env["DEFI_WALLET_ADDRESS"];
+    const { address: addr, source } = resolveCurrentAddress(opts.address);
     if (!addr) {
-      printOutput({ error: "--address required (or set DEFI_WALLET_ADDRESS)" }, getOpts());
+      printOutput({
+        error: "No wallet configured. Set DEFI_WALLET_ADDRESS, set DEFI_PRIVATE_KEY, or pass --address."
+      }, getOpts());
       return;
     }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
-    const client = createPublicClient24({ transport: http24(chain.effectiveRpcUrl()) });
+    const client = createPublicClient26({ transport: http26(chain.effectiveRpcUrl()) });
     const balance = await client.getBalance({ address: addr });
     printOutput({
       chain: chain.name,
       address: addr,
+      wallet_source: source,
       native_token: chain.native_token,
       balance_wei: balance,
       balance_formatted: formatEther(balance)
     }, getOpts());
   });
   wallet.command("address").description("Show configured wallet address").action(async () => {
-    const addr = process.env.DEFI_WALLET_ADDRESS ?? "(not set)";
-    printOutput({ address: addr }, getOpts());
+    const { address, source } = resolveCurrentAddress();
+    printOutput({ address, source }, getOpts());
   });
 }
 
 // src/commands/token.ts
 init_dist();
-import { createPublicClient as createPublicClient25, http as http25, maxUint256 } from "viem";
+import { createPublicClient as createPublicClient27, encodeFunctionData as encodeFunctionData30, http as http27, maxUint256 as maxUint2562, parseAbi as parseAbi34 } from "viem";
 function registerToken(parent, getOpts, makeExecutor2) {
   const token = parent.command("token").description("Token operations: approve, allowance, transfer, balance");
   token.command("balance").description("Query token balance for an address").requiredOption("--token <token>", "Token symbol or address").option("--owner <address>", "Wallet address (defaults to DEFI_WALLET_ADDRESS)").action(async (opts) => {
@@ -11069,7 +12014,7 @@ function registerToken(parent, getOpts, makeExecutor2) {
     }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
-    const client = createPublicClient25({ transport: http25(chain.effectiveRpcUrl()) });
+    const client = createPublicClient27({ transport: http27(chain.effectiveRpcUrl()) });
     const tokenAddr = resolveTokenAddress(registry, chainName, opts.token);
     const [balance, symbol, decimals] = await Promise.all([
       client.readContract({ address: tokenAddr, abi: erc20Abi, functionName: "balanceOf", args: [owner] }),
@@ -11090,7 +12035,7 @@ function registerToken(parent, getOpts, makeExecutor2) {
     if (!chainName) return;
     const registry = Registry.loadEmbedded();
     const tokenAddr = resolveTokenAddress(registry, chainName, opts.token);
-    const amount = opts.amount === "max" ? maxUint256 : BigInt(opts.amount);
+    const amount = opts.amount === "max" ? maxUint2562 : BigInt(opts.amount);
     const tx = buildApprove(tokenAddr, opts.spender, amount);
     const result = await executor.execute(tx);
     printOutput(result, getOpts());
@@ -11105,7 +12050,7 @@ function registerToken(parent, getOpts, makeExecutor2) {
     }
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
-    const client = createPublicClient25({ transport: http25(chain.effectiveRpcUrl()) });
+    const client = createPublicClient27({ transport: http27(chain.effectiveRpcUrl()) });
     const tokenAddr = resolveTokenAddress(registry, chainName, opts.token);
     const allowance = await client.readContract({
       address: tokenAddr,
@@ -11115,6 +12060,52 @@ function registerToken(parent, getOpts, makeExecutor2) {
     });
     printOutput({ token: tokenAddr, owner, spender: opts.spender, allowance }, getOpts());
   });
+  const WETH9_ABI = parseAbi34([
+    "function deposit() payable",
+    "function withdraw(uint256 amount)"
+  ]);
+  token.command("wrap").description("Wrap native gas token into its ERC-20 wrapped form (WrappedNative.deposit())").requiredOption("--amount <amount>", "Amount of native token to wrap (in wei)").action(async (opts) => {
+    const executor = makeExecutor2();
+    const chainName = requireChain(parent, getOpts);
+    if (!chainName) return;
+    const registry = Registry.loadEmbedded();
+    const chain = registry.getChain(chainName);
+    if (!chain.wrapped_native) {
+      printOutput({ error: `[${chainName}] no wrapped_native registered in chains.toml` }, getOpts());
+      return;
+    }
+    const amount = BigInt(opts.amount);
+    const data = encodeFunctionData30({ abi: WETH9_ABI, functionName: "deposit" });
+    const result = await executor.execute({
+      description: `[${chainName}] Wrap ${opts.amount} ${chain.native_token} \u2192 W${chain.native_token}`,
+      to: chain.wrapped_native,
+      data,
+      value: amount,
+      gas_estimate: 8e4
+    });
+    printOutput(result, getOpts());
+  });
+  token.command("unwrap").description("Unwrap wrapped-native ERC-20 back into native gas token (WrappedNative.withdraw(amount))").requiredOption("--amount <amount>", "Amount of wrapped token to unwrap (in wei)").action(async (opts) => {
+    const executor = makeExecutor2();
+    const chainName = requireChain(parent, getOpts);
+    if (!chainName) return;
+    const registry = Registry.loadEmbedded();
+    const chain = registry.getChain(chainName);
+    if (!chain.wrapped_native) {
+      printOutput({ error: `[${chainName}] no wrapped_native registered in chains.toml` }, getOpts());
+      return;
+    }
+    const amount = BigInt(opts.amount);
+    const data = encodeFunctionData30({ abi: WETH9_ABI, functionName: "withdraw", args: [amount] });
+    const result = await executor.execute({
+      description: `[${chainName}] Unwrap ${opts.amount} W${chain.native_token} \u2192 ${chain.native_token}`,
+      to: chain.wrapped_native,
+      data,
+      value: 0n,
+      gas_estimate: 8e4
+    });
+    printOutput(result, getOpts());
+  });
   token.command("transfer").description("Transfer tokens to an address").requiredOption("--token <token>", "Token symbol or address").requiredOption("--to <address>", "Recipient address").requiredOption("--amount <amount>", "Amount to transfer (in wei)").action(async (opts) => {
     const executor = makeExecutor2();
     const chainName = requireChain(parent, getOpts);
@@ -11129,9 +12120,50 @@ function registerToken(parent, getOpts, makeExecutor2) {
 
 // src/commands/bridge.ts
 init_dist();
+function resolveDestExecutor(slug, broadcast) {
+  const registry = Registry.loadEmbedded();
+  try {
+    const c = registry.getChain(slug);
+    return new Executor(broadcast, c.effectiveRpcUrl(), c.explorer_url, c.viemChain());
+  } catch {
+    const envKey = `${slug.toUpperCase()}_RPC_URL`;
+    const envVal = process.env[envKey];
+    const meta = DEST_CHAIN_META[slug];
+    if (!meta) throw new Error(`Cannot resolve destination chain: ${slug}`);
+    const rpc = envVal ?? DEST_RPC_FALLBACKS[slug];
+    if (!rpc) throw new Error(`No RPC URL for ${slug}. Set ${envKey} or use a registered chain.`);
+    const minimal = {
+      id: meta.chain_id,
+      name: meta.name,
+      nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+      rpcUrls: { default: { http: [rpc] } }
+    };
+    return new Executor(broadcast, rpc, void 0, minimal);
+  }
+}
+async function pollCctpAttestation(srcDomain, burnTxHash, maxSeconds) {
+  const intervalMs = 5e3;
+  const deadline = Date.now() + maxSeconds * 1e3;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`https://iris-api.circle.com/v2/messages/${srcDomain}?transactionHash=${burnTxHash}`);
+      if (res.ok) {
+        const data = await res.json();
+        const m = data.messages?.[0];
+        if (m && m.status === "complete" && m.attestation && m.attestation !== "PENDING") {
+          return { message: m.message, attestation: m.attestation };
+        }
+      }
+    } catch {
+    }
+    await new Promise((resolve6) => setTimeout(resolve6, intervalMs));
+  }
+  throw new Error(`CCTP attestation timeout after ${maxSeconds}s for tx ${burnTxHash}`);
+}
 var LIFI_API = "https://li.quest/v1";
 var DLN_API = "https://dln.debridge.finance/v1.0/dln/order";
 var CCTP_FEE_API = "https://iris-api.circle.com/v2/burn/USDC/fees";
+var RELAY_API = "https://api.relay.link";
 var DEST_CHAIN_META = {
   ethereum: { chain_id: 1, name: "Ethereum" },
   optimism: { chain_id: 10, name: "Optimism" },
@@ -11203,6 +12235,63 @@ async function getDebridgeQuote(srcChainId, dstChainId, srcToken, dstToken, amou
     raw: createData
   };
 }
+async function getRelayBridgeQuote(srcChainId, dstChainId, srcToken, dstToken, amountRaw, user, recipient) {
+  const body = {
+    user,
+    recipient,
+    originChainId: srcChainId,
+    destinationChainId: dstChainId,
+    originCurrency: srcToken,
+    destinationCurrency: dstToken,
+    tradeType: "EXACT_INPUT",
+    amount: amountRaw
+  };
+  const res = await fetch(`${RELAY_API}/quote`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    let code = "";
+    let msg = text;
+    try {
+      const j = JSON.parse(text);
+      code = String(j.errorCode ?? j.code ?? "");
+      msg = String(j.message ?? text);
+    } catch {
+    }
+    const hints = {
+      AMOUNT_TOO_LOW: "Try a larger amount or use --provider lifi (Relay enforces a per-route fee floor)",
+      INVALID_INPUT_CURRENCY: "Source token unsupported by Relay on this chain \u2014 try --provider lifi",
+      INVALID_OUTPUT_CURRENCY: "Destination token unsupported by Relay on this chain \u2014 try --provider lifi or change --token",
+      NO_QUOTES: "No Relay liquidity for this route right now \u2014 try --provider lifi or retry later",
+      AMOUNT_TOO_HIGH: "Amount exceeds Relay per-tx cap \u2014 split into smaller amounts",
+      UNSUPPORTED_CHAIN: "Relay does not support this origin/destination chain \u2014 use --provider lifi"
+    };
+    const hint = hints[code];
+    const detail = code ? `${code}: ${msg}` : msg;
+    throw new Error(`Relay quote failed (${res.status}): ${detail}${hint ? ` \u2014 ${hint}` : ""}`);
+  }
+  const json = await res.json();
+  const steps = json.steps;
+  const swapStep = steps?.find((s) => s.id !== "approve") ?? steps?.[steps?.length ?? 1 - 1];
+  const items = swapStep?.items;
+  const txData = items?.[0]?.data;
+  if (!txData) throw new Error("Relay: no executable step in cross-chain quote");
+  const details = json.details;
+  const currencyOut = details?.currencyOut;
+  const timeEst = details?.timeEstimate ?? 30;
+  return {
+    to: String(txData.to),
+    data: String(txData.data),
+    value: String(txData.value ?? "0x0"),
+    amountOut: String(currencyOut?.amount ?? "0"),
+    estimatedTime: timeEst,
+    tool: String(swapStep?.id ?? "relay"),
+    raw: json
+  };
+}
 var CCTP_DOMAINS = {
   ethereum: 0,
   avalanche: 1,
@@ -11215,6 +12304,16 @@ var CCTP_DOMAINS = {
   aptos: 9
 };
 var CCTP_TOKEN_MESSENGER_V2 = "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d";
+var CCTP_MESSAGE_TRANSMITTER_V2 = "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64";
+var DEST_RPC_FALLBACKS = {
+  ethereum: "https://eth.merkle.io",
+  arbitrum: "https://arbitrum.drpc.org",
+  optimism: "https://optimism.drpc.org",
+  polygon: "https://polygon.drpc.org",
+  avalanche: "https://avalanche.drpc.org",
+  linea: "https://linea.drpc.org",
+  zksync: "https://zksync.drpc.org"
+};
 var CCTP_USDC_ADDRESSES = {
   ethereum: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
   avalanche: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
@@ -11223,6 +12322,17 @@ var CCTP_USDC_ADDRESSES = {
   base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
   polygon: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"
 };
+function cctpMinFeeGuard(amountWei, maxFeeSubunits, feeUsdc) {
+  if (amountWei <= maxFeeSubunits) {
+    const amountUsdc = Number(amountWei) / 1e6;
+    return {
+      error: `CCTP: amount ${amountWei.toString()} (${amountUsdc} USDC) is below the minimum bridge fee of ${maxFeeSubunits} (${feeUsdc} USDC). Increase --amount.`,
+      minimum_amount_wei: maxFeeSubunits.toString(),
+      minimum_amount_usdc: feeUsdc
+    };
+  }
+  return null;
+}
 async function getCctpFeeEstimate(srcDomain, dstDomain, amountUsdc) {
   try {
     const res = await fetch(`${CCTP_FEE_API}/${srcDomain}/${dstDomain}`);
@@ -11247,8 +12357,8 @@ async function getCctpFeeEstimate(srcDomain, dstDomain, amountUsdc) {
   }
   return { fee: 0.25, maxFeeSubunits: 250000n };
 }
-function registerBridge(parent, getOpts) {
-  parent.command("bridge").description("Cross-chain bridge: move assets between chains").requiredOption("--token <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount in wei").requiredOption("--to-chain <chain>", "Destination chain name").option("--recipient <address>", "Recipient address on destination chain").option("--slippage <bps>", "Slippage in bps (LI.FI only)", "50").option("--provider <name>", "Bridge provider: lifi, debridge, cctp", "lifi").action(async (opts) => {
+function registerBridge(parent, getOpts, makeExecutor2) {
+  parent.command("bridge").description("Cross-chain bridge: move assets between chains").requiredOption("--token <token>", "Token symbol or address").requiredOption("--amount <amount>", "Amount in wei").requiredOption("--to-chain <chain>", "Destination chain name").option("--recipient <address>", "Recipient address on destination chain").option("--slippage <bps>", "Slippage in bps (LI.FI only)", "50").option("--provider <name>", "Bridge provider: lifi, relay, debridge, cctp", "lifi").option("--auto-receive", "(CCTP only) After burn, poll Circle attestation and auto-call MessageTransmitter.receiveMessage on destination", false).option("--receive-timeout <seconds>", "(CCTP --auto-receive) max seconds to wait for attestation", "1200").action(async (opts) => {
     const chainName = requireChain(parent, getOpts);
     if (!chainName) return;
     const registry = Registry.loadEmbedded();
@@ -11261,8 +12371,55 @@ function registerBridge(parent, getOpts) {
       return;
     }
     const tokenAddr = opts.token.startsWith("0x") ? opts.token : registry.resolveToken(chainName, opts.token).address;
+    let dstTokenAddr = tokenAddr;
+    if (!opts.token.startsWith("0x")) {
+      try {
+        dstTokenAddr = registry.resolveToken(opts.toChain, opts.token).address;
+      } catch {
+      }
+    }
     const recipient = resolveWallet(opts.recipient);
     const provider = opts.provider.toLowerCase();
+    if (provider === "relay") {
+      try {
+        const result = await getRelayBridgeQuote(
+          fromChain.chain_id,
+          toChain.chain_id,
+          tokenAddr,
+          dstTokenAddr,
+          opts.amount,
+          recipient,
+          recipient
+        );
+        const isNative = tokenAddr.toLowerCase() === "0x0000000000000000000000000000000000000000";
+        const executor = makeExecutor2();
+        const approvals = isNative ? [] : [{
+          token: tokenAddr,
+          spender: result.to,
+          amount: BigInt(opts.amount)
+        }];
+        const action = await executor.execute({
+          to: result.to,
+          data: result.data,
+          value: BigInt(result.value || "0"),
+          description: `Relay bridge ${fromChain.name} \u2192 ${toChain.name}`,
+          approvals
+        });
+        printOutput({
+          from_chain: fromChain.name,
+          to_chain: toChain.name,
+          token: tokenAddr,
+          amount: opts.amount,
+          bridge: `Relay (${result.tool})`,
+          estimated_output: result.amountOut,
+          estimated_time_seconds: result.estimatedTime,
+          action
+        }, getOpts());
+      } catch (e) {
+        printOutput({ error: `Relay API error: ${errMsg(e)}` }, getOpts());
+      }
+      return;
+    }
     if (provider === "debridge") {
       try {
         const srcId = DLN_CHAIN_IDS[chainName] ?? fromChain.chain_id;
@@ -11271,11 +12428,29 @@ function registerBridge(parent, getOpts) {
           srcId,
           dstId,
           tokenAddr,
-          tokenAddr,
+          dstTokenAddr,
           opts.amount,
           recipient
         );
         const tx = result.raw.tx;
+        if (!tx?.to || !tx?.data) {
+          printOutput({ error: "deBridge: API did not return a tx envelope" }, getOpts());
+          return;
+        }
+        const isNative = tokenAddr.toLowerCase() === "0x0000000000000000000000000000000000000000";
+        const executor = makeExecutor2();
+        const approvals = isNative ? [] : [{
+          token: tokenAddr,
+          spender: tx.to,
+          amount: BigInt(opts.amount)
+        }];
+        const action = await executor.execute({
+          to: tx.to,
+          data: tx.data,
+          value: BigInt(tx.value ?? "0"),
+          description: `deBridge DLN ${fromChain.name} \u2192 ${toChain.name}`,
+          approvals
+        });
         printOutput({
           from_chain: fromChain.name,
           to_chain: toChain.name,
@@ -11284,7 +12459,7 @@ function registerBridge(parent, getOpts) {
           bridge: "deBridge DLN",
           estimated_output: result.amountOut,
           estimated_time_seconds: result.estimatedTime,
-          tx: tx ? { to: tx.to, data: tx.data, value: tx.value } : void 0
+          action
         }, getOpts());
       } catch (e) {
         printOutput({ error: `deBridge API error: ${errMsg(e)}` }, getOpts());
@@ -11311,20 +12486,17 @@ function registerBridge(parent, getOpts) {
         }
         const amountUsdc = Number(BigInt(opts.amount)) / 1e6;
         const { fee, maxFeeSubunits } = await getCctpFeeEstimate(srcDomain, dstDomain, amountUsdc);
-        if (BigInt(opts.amount) <= maxFeeSubunits) {
-          printOutput({
-            error: `CCTP: amount ${opts.amount} (${amountUsdc} USDC) is below the minimum bridge fee of ${maxFeeSubunits} (${fee} USDC). Increase --amount.`,
-            minimum_amount_wei: maxFeeSubunits.toString(),
-            minimum_amount_usdc: fee
-          }, getOpts());
+        const guardErr = cctpMinFeeGuard(BigInt(opts.amount), maxFeeSubunits, fee);
+        if (guardErr) {
+          printOutput(guardErr, getOpts());
           return;
         }
         const recipientPadded = `0x${"0".repeat(24)}${recipient.replace("0x", "").toLowerCase()}`;
-        const { encodeFunctionData: encodeFunctionData31, parseAbi: parseAbi35 } = await import("viem");
-        const tokenMessengerAbi = parseAbi35([
+        const { encodeFunctionData: encodeFunctionData33, parseAbi: parseAbi36 } = await import("viem");
+        const tokenMessengerAbi = parseAbi36([
           "function depositForBurn(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken, bytes32 destinationCaller, uint256 maxFee, uint32 minFinalityThreshold) external returns (uint64 nonce)"
         ]);
-        const data = encodeFunctionData31({
+        const data = encodeFunctionData33({
           abi: tokenMessengerAbi,
           functionName: "depositForBurn",
           args: [
@@ -11339,6 +12511,48 @@ function registerBridge(parent, getOpts) {
             // standard finality
           ]
         });
+        const executor = makeExecutor2();
+        const burnAction = await executor.execute({
+          to: CCTP_TOKEN_MESSENGER_V2,
+          data,
+          value: 0n,
+          description: `CCTP burn ${fromChain.name} \u2192 ${toChain.name}`,
+          approvals: [{
+            token: usdcSrc,
+            spender: CCTP_TOKEN_MESSENGER_V2,
+            amount: BigInt(opts.amount)
+          }]
+        });
+        let receiveAction = void 0;
+        if (opts.autoReceive && burnAction.tx_hash && burnAction.status === "confirmed") {
+          try {
+            const timeoutSec = parseInt(opts.receiveTimeout) || 1200;
+            process.stderr.write(`Polling Circle attestation for ${burnAction.tx_hash} (max ${timeoutSec}s)...
+`);
+            const { message, attestation } = await pollCctpAttestation(srcDomain, burnAction.tx_hash, timeoutSec);
+            process.stderr.write(`Attestation ready. Calling receiveMessage on ${opts.toChain}...
+`);
+            const { encodeFunctionData: encReceive, parseAbi: parseAbiReceive } = await import("viem");
+            const receiveAbi = parseAbiReceive([
+              "function receiveMessage(bytes message, bytes attestation) external"
+            ]);
+            const receiveData = encReceive({
+              abi: receiveAbi,
+              functionName: "receiveMessage",
+              args: [message, attestation]
+            });
+            const destExecutor = resolveDestExecutor(opts.toChain, !!parent.opts().broadcast);
+            receiveAction = await destExecutor.execute({
+              to: CCTP_MESSAGE_TRANSMITTER_V2,
+              data: receiveData,
+              value: 0n,
+              description: `CCTP receive on ${toChain.name}`,
+              approvals: []
+            });
+          } catch (e) {
+            receiveAction = { error: `auto-receive failed: ${errMsg(e)}` };
+          }
+        }
         printOutput({
           from_chain: fromChain.name,
           to_chain: toChain.name,
@@ -11348,12 +12562,9 @@ function registerBridge(parent, getOpts) {
           bridge: "Circle CCTP V2",
           estimated_fee_usdc: fee,
           estimated_output: String(BigInt(opts.amount) - maxFeeSubunits),
-          note: "After burn, poll https://iris-api.circle.com/v2/messages/{srcDomain} for attestation, then call MessageTransmitter.receiveMessage() on destination",
-          tx: {
-            to: CCTP_TOKEN_MESSENGER_V2,
-            data,
-            value: "0x0"
-          }
+          burn: burnAction,
+          receive: receiveAction,
+          note: opts.autoReceive ? void 0 : "Pass --auto-receive to poll Circle attestation and auto-call MessageTransmitter.receiveMessage on the destination chain."
         }, getOpts());
       } catch (e) {
         printOutput({ error: `CCTP error: ${errMsg(e)}` }, getOpts());
@@ -11365,26 +12576,41 @@ function registerBridge(parent, getOpts) {
         fromChain: String(fromChain.chain_id),
         toChain: String(toChain.chain_id),
         fromToken: tokenAddr,
-        toToken: tokenAddr,
+        toToken: dstTokenAddr,
         fromAmount: opts.amount,
         fromAddress: recipient,
         slippage: String(parseInt(opts.slippage) / 1e4)
       });
       const res = await fetch(`${LIFI_API}/quote?${params}`);
       const quote = await res.json();
-      if (quote.transactionRequest) {
-        printOutput({
-          from_chain: fromChain.name,
-          to_chain: toChain.name,
-          token: tokenAddr,
-          amount: opts.amount,
-          bridge: quote.toolDetails?.name ?? "LI.FI",
-          estimated_output: quote.estimate?.toAmount,
-          tx: { to: quote.transactionRequest.to, data: quote.transactionRequest.data, value: quote.transactionRequest.value }
-        }, getOpts());
-      } else {
+      if (!quote.transactionRequest) {
         printOutput({ error: "No LI.FI route found", details: quote }, getOpts());
+        return;
       }
+      const isNative = tokenAddr.toLowerCase() === "0x0000000000000000000000000000000000000000";
+      const spender = quote.estimate?.approvalAddress ?? quote.transactionRequest.to;
+      const executor = makeExecutor2();
+      const approvals = isNative ? [] : [{
+        token: tokenAddr,
+        spender,
+        amount: BigInt(opts.amount)
+      }];
+      const action = await executor.execute({
+        to: quote.transactionRequest.to,
+        data: quote.transactionRequest.data,
+        value: BigInt(quote.transactionRequest.value ?? "0"),
+        description: `LI.FI ${fromChain.name} \u2192 ${toChain.name}`,
+        approvals
+      });
+      printOutput({
+        from_chain: fromChain.name,
+        to_chain: toChain.name,
+        token: tokenAddr,
+        amount: opts.amount,
+        bridge: quote.toolDetails?.name ?? "LI.FI",
+        estimated_output: quote.estimate?.toAmount,
+        action
+      }, getOpts());
     } catch (e) {
       printOutput({ error: `LI.FI API error: ${errMsg(e)}` }, getOpts());
     }
@@ -11472,7 +12698,7 @@ async function lifiQuote(chainId, fromToken, toToken, fromAmount, fromAddress, s
     outAmount: String(estimate?.toAmount ?? "0")
   };
 }
-var RELAY_API = "https://api.relay.link";
+var RELAY_API2 = "https://api.relay.link";
 async function relayQuote(chainId, fromToken, toToken, amount, user) {
   const body = {
     user,
@@ -11484,7 +12710,7 @@ async function relayQuote(chainId, fromToken, toToken, amount, user) {
     tradeType: "EXACT_INPUT",
     amount
   };
-  const res = await fetch(`${RELAY_API}/quote`, {
+  const res = await fetch(`${RELAY_API2}/quote`, {
     method: "POST",
     headers: { "content-type": "application/json" },
     body: JSON.stringify(body)
@@ -11524,7 +12750,7 @@ async function liquidSwapRoute(tokenIn, tokenOut, amountIn, slippagePct) {
   };
 }
 function registerSwap(parent, getOpts, makeExecutor2) {
-  parent.command("swap").description("Swap tokens via DEX aggregator (KyberSwap, OpenOcean, LiquidSwap, LI.FI, Relay)").requiredOption("--from <token>", "Input token symbol or address").requiredOption("--to <token>", "Output token symbol or address").requiredOption("--amount <amount>", "Amount of input token in wei").option("--provider <name>", "Aggregator: kyber, openocean, liquid, lifi, relay", "kyber").option("--slippage <bps>", "Slippage tolerance in bps", "50").action(async (opts) => {
+  parent.command("swap").description("Swap tokens via DEX aggregator (KyberSwap, OpenOcean, LiquidSwap, LI.FI, Relay)").requiredOption("--from <token>", "Input token symbol or address").requiredOption("--to <token>", "Output token symbol or address").requiredOption("--amount <amount>", "Amount of input token in wei").option("--provider <name>", "Aggregator: kyber, openocean, liquid, lifi, relay", "kyber").option("--slippage <bps>", "Slippage tolerance in bps", "100").action(async (opts) => {
     const executor = makeExecutor2();
     const chainName = requireChain(parent, getOpts);
     if (!chainName) return;
@@ -11553,12 +12779,14 @@ function registerSwap(parent, getOpts, makeExecutor2) {
           wallet,
           slippageBps
         );
+        const fromLowerKyber = fromAddr.toLowerCase();
+        const isNativeInputKyber = fromLowerKyber === "0x0000000000000000000000000000000000000000" || fromLowerKyber === "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
         const tx = {
           description: `KyberSwap: swap ${opts.amount} of ${fromAddr} -> ${toAddr}`,
           to: txData.to,
           data: txData.data,
-          value: parseBigIntValue(txData.value),
-          approvals: [{ token: fromAddr, spender: txData.to, amount: BigInt(opts.amount) }]
+          value: isNativeInputKyber ? BigInt(opts.amount) : parseBigIntValue(txData.value),
+          ...isNativeInputKyber ? {} : { approvals: [{ token: fromAddr, spender: txData.to, amount: BigInt(opts.amount) }] }
         };
         const result = await executor.execute(tx);
         printOutput({
@@ -11597,12 +12825,14 @@ function registerSwap(parent, getOpts, makeExecutor2) {
           slippagePct,
           wallet
         );
+        const fromLower = fromAddr.toLowerCase();
+        const isNativeInput = fromLower === "0x0000000000000000000000000000000000000000" || fromLower === "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
         const tx = {
           description: `OpenOcean: swap ${opts.amount} of ${fromAddr} -> ${toAddr}`,
           to: swap.to,
           data: swap.data,
           value: parseBigIntValue(swap.value),
-          approvals: [{ token: fromAddr, spender: swap.to, amount: BigInt(opts.amount) }]
+          ...isNativeInput ? {} : { approvals: [{ token: fromAddr, spender: swap.to, amount: BigInt(opts.amount) }] }
         };
         const result = await executor.execute(tx);
         printOutput({
@@ -11694,7 +12924,8 @@ import pc2 from "picocolors";
 import { createInterface } from "readline";
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
 import { resolve as resolve4 } from "path";
-var DEFI_DIR = resolve4(process.env.HOME || "~", ".defi");
+import { homedir as homedir2 } from "os";
+var DEFI_DIR = resolve4(homedir2(), ".defi");
 var ENV_FILE = resolve4(DEFI_DIR, ".env");
 function ensureDefiDir() {
   if (!existsSync3(DEFI_DIR)) mkdirSync2(DEFI_DIR, { recursive: true, mode: 448 });
@@ -11729,6 +12960,44 @@ function writeEnvFile(env) {
 function ask(rl, question) {
   return new Promise((res) => rl.question(question, (answer) => res(answer.trim())));
 }
+function askSecret(rl, question) {
+  const stdin = process.stdin;
+  if (!stdin.isTTY) return ask(rl, question);
+  process.stdout.write(question);
+  const rlAny = rl;
+  const original = rlAny._writeToOutput;
+  rlAny._writeToOutput = (s) => {
+    if (s.includes("\n") || s.includes("\r")) {
+      original?.call(rl, s);
+    }
+  };
+  return new Promise((res) => {
+    rl.question("", (answer) => {
+      rlAny._writeToOutput = original;
+      process.stdout.write("\n");
+      res(answer.trim());
+    });
+  });
+}
+function maskRpcUrl(s) {
+  try {
+    const u = new URL(s);
+    if (u.pathname && u.pathname !== "/" && u.pathname.length > 1) {
+      return `${u.protocol}//${u.host}/***`;
+    }
+    return `${u.protocol}//${u.host}`;
+  } catch {
+    return "***";
+  }
+}
+function isValidRpcUrl(s) {
+  try {
+    const u = new URL(s);
+    return u.protocol === "http:" || u.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
 function isValidAddress(s) {
   return /^0x[0-9a-fA-F]{40}$/.test(s);
 }
@@ -11753,7 +13022,14 @@ function registerSetup(program2) {
       if (Object.keys(existing).length > 0) {
         console.log(pc2.white("  Current configuration:"));
         for (const [key, value] of Object.entries(existing)) {
-          const masked = key.toLowerCase().includes("key") ? value.slice(0, 6) + "..." + value.slice(-4) : value;
+          let masked;
+          if (key.toLowerCase().includes("key")) {
+            masked = value.slice(0, 6) + "..." + value.slice(-4);
+          } else if (key.endsWith("RPC_URL")) {
+            masked = maskRpcUrl(value);
+          } else {
+            masked = value;
+          }
           console.log(`    ${pc2.cyan(key.padEnd(24))} ${pc2.gray(masked)}`);
         }
         console.log();
@@ -11767,7 +13043,7 @@ function registerSetup(program2) {
       }
       const newEnv = {};
       console.log(pc2.cyan(pc2.bold("  Wallet")));
-      const privateKey = await ask(rl, "  Private key (optional, for --broadcast, 0x...): ");
+      const privateKey = await askSecret(rl, "  Private key (optional, for --broadcast, 0x... \u2014 input hidden): ");
       if (privateKey) {
         const normalized = privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
         if (!isValidPrivateKey(normalized)) {
@@ -11803,6 +13079,10 @@ function registerSetup(program2) {
       for (const { env, label } of rpcPrompts) {
         const value = await ask(rl, `  ${label} RPC URL: `);
         if (value) {
+          if (!isValidRpcUrl(value)) {
+            console.log(pc2.yellow(`  Invalid URL (${value}). Skipped \u2014 re-run setup to retry.`));
+            continue;
+          }
           newEnv[env] = value;
           console.log(`  ${pc2.green("OK")} ${label} RPC set`);
         }
@@ -11826,7 +13106,7 @@ function registerSetup(program2) {
       ];
       for (const [k, label] of rpcSummary) {
         const v = finalEnv[k];
-        if (v) console.log(`  ${label}: ${pc2.gray(v)}`);
+        if (v) console.log(`  ${label}: ${pc2.gray(maskRpcUrl(v))}`);
       }
       console.log(pc2.bold(pc2.white("\n  Next steps:")));
       console.log(`    ${pc2.green("defi portfolio")}          view balances & positions`);
@@ -11845,11 +13125,11 @@ function registerSetup(program2) {
 // src/commands/ows.ts
 import pc3 from "picocolors";
 init_dist();
-import { createPublicClient as createPublicClient26, http as http26, formatEther as formatEther2 } from "viem";
+import { createPublicClient as createPublicClient28, http as http28, formatEther as formatEther2 } from "viem";
 async function getEvmBalance(address, chainName) {
   const registry = Registry.loadEmbedded();
   const chain = registry.getChain(chainName);
-  const client = createPublicClient26({ transport: http26(chain.effectiveRpcUrl()) });
+  const client = createPublicClient28({ transport: http28(chain.effectiveRpcUrl()) });
   const balance = await client.getBalance({ address });
   return {
     native_token: chain.native_token,
@@ -12073,7 +13353,8 @@ function makeExecutor() {
     process.exit(1);
   }
   const chain = registry.getChain(opts.chain);
-  return new Executor(!!opts.broadcast, chain.effectiveRpcUrl(), chain.explorer_url);
+  const viemChain = chain.viemChain();
+  return new Executor(!!opts.broadcast, chain.effectiveRpcUrl(), chain.explorer_url, viemChain);
 }
 registerStatus(program, getOutputMode);
 registerSchema(program, getOutputMode);
@@ -12084,7 +13365,7 @@ registerPortfolio(program, getOutputMode);
 registerPrice(program, getOutputMode);
 registerWallet(program, getOutputMode);
 registerToken(program, getOutputMode, makeExecutor);
-registerBridge(program, getOutputMode);
+registerBridge(program, getOutputMode, makeExecutor);
 registerSwap(program, getOutputMode, makeExecutor);
 registerSetup(program);
 registerOws(program, getOutputMode);
@@ -12092,7 +13373,7 @@ registerOws(program, getOutputMode);
 // src/landing.ts
 init_dist();
 import pc4 from "picocolors";
-import { encodeFunctionData as encodeFunctionData30, parseAbi as parseAbi34, formatUnits } from "viem";
+import { encodeFunctionData as encodeFunctionData31, parseAbi as parseAbi35, formatUnits } from "viem";
 var DASHBOARD_CHAINS = [
   { slug: "hyperevm", tokens: ["HYPE", "WHYPE", "USDC", "USDT0", "USDe", "kHYPE", "wstHYPE"] },
   { slug: "mantle", tokens: ["MNT", "WMNT", "USDC", "USDT", "WETH", "mETH"] },
@@ -12100,10 +13381,10 @@ var DASHBOARD_CHAINS = [
   { slug: "bnb", tokens: ["BNB", "WBNB", "USDT", "USDC", "BUSD", "CAKE"] },
   { slug: "monad", tokens: ["MON", "WMON", "USDC", "USDT0", "WETH", "WBTC"] }
 ];
-var balanceOfAbi = parseAbi34([
+var balanceOfAbi = parseAbi35([
   "function balanceOf(address account) view returns (uint256)"
 ]);
-var getEthBalanceAbi = parseAbi34([
+var getEthBalanceAbi = parseAbi35([
   "function getEthBalance(address addr) view returns (uint256)"
 ]);
 async function fetchBalances(rpcUrl, wallet, tokens) {
@@ -12112,12 +13393,12 @@ async function fetchBalances(rpcUrl, wallet, tokens) {
     if (isNative) {
       return [
         MULTICALL3_ADDRESS,
-        encodeFunctionData30({ abi: getEthBalanceAbi, functionName: "getEthBalance", args: [wallet] })
+        encodeFunctionData31({ abi: getEthBalanceAbi, functionName: "getEthBalance", args: [wallet] })
       ];
     }
     return [
       t.address,
-      encodeFunctionData30({ abi: balanceOfAbi, functionName: "balanceOf", args: [wallet] })
+      encodeFunctionData31({ abi: balanceOfAbi, functionName: "balanceOf", args: [wallet] })
     ];
   });
   let results;