@hypurrquant/defi-cli 0.2.5 → 0.3.1

package/dist/mcp-server.js

@@ -986,6 +986,7 @@ var init_dist2 = __esm({
       TxStatus2["DryRun"] = "dry_run";
       TxStatus2["Simulated"] = "simulated";
       TxStatus2["SimulationFailed"] = "simulation_failed";
+      TxStatus2["NeedsApproval"] = "needs_approval";
       TxStatus2["Pending"] = "pending";
       TxStatus2["Confirmed"] = "confirmed";
       TxStatus2["Failed"] = "failed";
@@ -1207,6 +1208,24 @@ var init_dist2 = __esm({
         if (!token) throw new Error(`Token not found: ${symbol}`);
         return token;
       }
+      /**
+       * Resolve a pool by name (e.g. "WHYPE/USDC") from a protocol's pool list.
+       * Returns the pool info or throws if not found.
+       */
+      resolvePool(protocolSlug, poolName) {
+        const protocol = this.getProtocol(protocolSlug);
+        if (!protocol.pools || protocol.pools.length === 0) {
+          throw new Error(`Protocol ${protocol.name} has no pools configured`);
+        }
+        const pool = protocol.pools.find(
+          (p) => p.name.toLowerCase() === poolName.toLowerCase()
+        );
+        if (!pool) {
+          const available = protocol.pools.map((p) => p.name).join(", ");
+          throw new Error(`Pool '${poolName}' not found in ${protocol.name}. Available: ${available}`);
+        }
+        return pool;
+      }
     };
   }
 });
@@ -1233,14 +1252,18 @@ __export(dist_exports2, {
   GenericOptionsAdapter: () => GenericOptionsAdapter,
   GenericYieldAdapter: () => GenericYieldAdapter,
   HlpVaultAdapter: () => HlpVaultAdapter,
+  HybraGaugeAdapter: () => HybraGaugeAdapter,
   KinetiqAdapter: () => KinetiqAdapter,
+  KittenSwapFarmingAdapter: () => KittenSwapFarmingAdapter,
   MasterChefAdapter: () => MasterChefAdapter,
+  MerchantMoeLBAdapter: () => MerchantMoeLBAdapter,
   MorphoBlueAdapter: () => MorphoBlueAdapter,
   PendleAdapter: () => PendleAdapter,
   RyskAdapter: () => RyskAdapter,
   SolidlyAdapter: () => SolidlyAdapter,
   SolidlyGaugeAdapter: () => SolidlyGaugeAdapter,
   StHypeAdapter: () => StHypeAdapter,
+  ThenaCLAdapter: () => ThenaCLAdapter,
   UniswapV2Adapter: () => UniswapV2Adapter,
   UniswapV3Adapter: () => UniswapV3Adapter,
   WooFiAdapter: () => WooFiAdapter,
@@ -1248,9 +1271,11 @@ __export(dist_exports2, {
   createDerivatives: () => createDerivatives,
   createDex: () => createDex,
   createGauge: () => createGauge,
+  createKittenSwapFarming: () => createKittenSwapFarming,
   createLending: () => createLending,
   createLiquidStaking: () => createLiquidStaking,
   createMasterChef: () => createMasterChef,
+  createMerchantMoeLB: () => createMerchantMoeLB,
   createNft: () => createNft,
   createOptions: () => createOptions,
   createOracleFromCdp: () => createOracleFromCdp,
@@ -1263,45 +1288,332 @@ import { encodeFunctionData as encodeFunctionData22, parseAbi as parseAbi22, cre
 import { encodeFunctionData as encodeFunctionData32, parseAbi as parseAbi32, createPublicClient as createPublicClient3, http as http3, decodeAbiParameters as decodeAbiParameters3, concatHex, zeroAddress } from "viem";
 import { encodeFunctionData as encodeFunctionData4, parseAbi as parseAbi4, zeroAddress as zeroAddress2 } from "viem";
 import { encodeFunctionData as encodeFunctionData5, parseAbi as parseAbi5 } from "viem";
-import { encodeFunctionData as encodeFunctionData6, parseAbi as parseAbi6, createPublicClient as createPublicClient4, http as http4, decodeAbiParameters as decodeAbiParameters4 } from "viem";
-import { encodeFunctionData as encodeFunctionData7, parseAbi as parseAbi7, zeroAddress as zeroAddress3 } from "viem";
-import { createPublicClient as createPublicClient5, encodeFunctionData as encodeFunctionData8, http as http5, parseAbi as parseAbi8, zeroAddress as zeroAddress4 } from "viem";
-import { encodeFunctionData as encodeFunctionData9, parseAbi as parseAbi9, createPublicClient as createPublicClient6, http as http6 } from "viem";
-import { createPublicClient as createPublicClient7, http as http7, parseAbi as parseAbi10, encodeFunctionData as encodeFunctionData10, zeroAddress as zeroAddress5 } from "viem";
-import { createPublicClient as createPublicClient8, http as http8, parseAbi as parseAbi11, encodeFunctionData as encodeFunctionData11, zeroAddress as zeroAddress6 } from "viem";
-import { createPublicClient as createPublicClient9, http as http9, parseAbi as parseAbi12 } from "viem";
-import { createPublicClient as createPublicClient10, http as http10, parseAbi as parseAbi13, encodeFunctionData as encodeFunctionData12 } from "viem";
-import { createPublicClient as createPublicClient11, http as http11, parseAbi as parseAbi14, encodeFunctionData as encodeFunctionData13 } from "viem";
-import { createPublicClient as createPublicClient12, http as http12, parseAbi as parseAbi15, encodeFunctionData as encodeFunctionData14 } from "viem";
-import { createPublicClient as createPublicClient13, http as http13, parseAbi as parseAbi16, encodeFunctionData as encodeFunctionData15, zeroAddress as zeroAddress7 } from "viem";
-import { createPublicClient as createPublicClient14, http as http14, parseAbi as parseAbi17, encodeFunctionData as encodeFunctionData16, zeroAddress as zeroAddress8 } from "viem";
-import { createPublicClient as createPublicClient15, http as http15, parseAbi as parseAbi18 } from "viem";
-import { createPublicClient as createPublicClient16, http as http16, parseAbi as parseAbi19, encodeFunctionData as encodeFunctionData17 } from "viem";
-import { parseAbi as parseAbi20, encodeFunctionData as encodeFunctionData18 } from "viem";
-import { createPublicClient as createPublicClient17, http as http17, parseAbi as parseAbi21, encodeFunctionData as encodeFunctionData19, zeroAddress as zeroAddress9 } from "viem";
-import { createPublicClient as createPublicClient18, http as http18, parseAbi as parseAbi222, encodeFunctionData as encodeFunctionData20, zeroAddress as zeroAddress10 } from "viem";
-import { parseAbi as parseAbi23, encodeFunctionData as encodeFunctionData21 } from "viem";
+import { encodeFunctionData as encodeFunctionData6, parseAbi as parseAbi6, decodeAbiParameters as decodeAbiParameters4 } from "viem";
+import { encodeFunctionData as encodeFunctionData7, parseAbi as parseAbi7, createPublicClient as createPublicClient4, http as http4, 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 encodeFunctionData11, parseAbi as parseAbi11, createPublicClient as createPublicClient7, http as http7 } from "viem";
+import {
+  encodeFunctionData as encodeFunctionData12,
+  decodeFunctionResult as decodeFunctionResult4,
+  parseAbi as parseAbi12,
+  createPublicClient as createPublicClient8,
+  http as http8
+} from "viem";
+import {
+  decodeAbiParameters as decodeAbiParameters5,
+  encodeFunctionData as encodeFunctionData13,
+  encodeAbiParameters,
+  http as http9,
+  createPublicClient as createPublicClient9,
+  keccak256,
+  parseAbi as parseAbi13,
+  decodeFunctionResult as decodeFunctionResult5,
+  zeroAddress as zeroAddress7
+} 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 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 parseAbi24, encodeFunctionData as encodeFunctionData222 } from "viem";
-import { createPublicClient as createPublicClient19, http as http19, parseAbi as parseAbi25 } 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 { 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";
+function pctToTickDelta(pct) {
+  return Math.round(Math.log(1 + pct / 100) / Math.log(1.0001));
+}
+function alignTickDown(tick, tickSpacing) {
+  return Math.floor(tick / tickSpacing) * tickSpacing;
+}
+function alignTickUp(tick, tickSpacing) {
+  return Math.ceil(tick / tickSpacing) * tickSpacing;
+}
+function rangeToTicks(currentTick, rangePct, tickSpacing) {
+  const delta = pctToTickDelta(rangePct);
+  return {
+    tickLower: alignTickDown(currentTick - delta, tickSpacing),
+    tickUpper: alignTickUp(currentTick + delta, tickSpacing)
+  };
+}
+function decodeAddress(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult22({ abi: _addressDecodeAbi, functionName: "f", data });
+  } catch {
+    return null;
+  }
+}
+function decodeSymbol(data) {
+  if (!data) return "?";
+  try {
+    return decodeFunctionResult22({ abi: _symbolDecodeAbi, functionName: "symbol", data });
+  } catch {
+    return "?";
+  }
+}
+function decodeAddress2(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult3({ abi: _addressDecodeAbi2, functionName: "f", data });
+  } catch {
+    return null;
+  }
+}
+function decodeSymbol2(data) {
+  if (!data) return "?";
+  try {
+    return decodeFunctionResult3({ abi: _symbolDecodeAbi2, functionName: "symbol", data });
+  } catch {
+    return "?";
+  }
+}
+function decodeBoolean(data) {
+  try {
+    return decodeFunctionResult3({ abi: _boolDecodeAbi, functionName: "f", data });
+  } catch {
+    return false;
+  }
+}
+function decodeAddressResult(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult4({ abi: _addressAbi, functionName: "f", data });
+  } catch {
+    return null;
+  }
+}
+function decodeUint256Result(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult4({ abi: _uint256Abi, functionName: "f", data });
+  } catch {
+    return null;
+  }
+}
+function decodeBoolResult(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult4({ abi: _boolAbi, functionName: "f", data });
+  } catch {
+    return null;
+  }
+}
+function decodeStringResult(data) {
+  if (!data) return "?";
+  try {
+    return decodeFunctionResult4({ abi: erc20Abi2, functionName: "symbol", data });
+  } catch {
+    return "?";
+  }
+}
+function decodeRangeResult(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult4({ abi: _rangeAbi, functionName: "f", data });
+  } catch {
+    return null;
+  }
+}
+function decodeBinResult(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult4({ abi: _binAbi, functionName: "f", data });
+  } catch {
+    return null;
+  }
+}
+function decodeUint256ArrayResult(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult4({ abi: _uint256ArrayAbi, functionName: "f", data });
+  } catch {
+    return null;
+  }
+}
+function extractRewarderAddress(hooksParams) {
+  if (!hooksParams || hooksParams === "0x0000000000000000000000000000000000000000000000000000000000000000") {
+    return null;
+  }
+  const hex = hooksParams.slice(2);
+  if (hex.length < 64) return null;
+  const addrHex = hex.slice(24, 64);
+  if (addrHex === "0000000000000000000000000000000000000000") return null;
+  return `0x${addrHex}`;
+}
+function buildUniformDistribution(deltaIds) {
+  const PRECISION = 10n ** 18n;
+  const n = deltaIds.length;
+  const xBins = deltaIds.filter((d) => d >= 0).length;
+  const yBins = deltaIds.filter((d) => d <= 0).length;
+  const distributionX = [];
+  const distributionY = [];
+  for (const delta of deltaIds) {
+    const xShare = delta >= 0 && xBins > 0 ? PRECISION / BigInt(xBins) : 0n;
+    const yShare = delta <= 0 && yBins > 0 ? PRECISION / BigInt(yBins) : 0n;
+    distributionX.push(xShare);
+    distributionY.push(yShare);
+  }
+  const xSum = distributionX.reduce((a, b) => a + b, 0n);
+  const ySum = distributionY.reduce((a, b) => a + b, 0n);
+  if (xSum > 0n && xSum !== PRECISION) {
+    const firstX = distributionX.findIndex((v) => v > 0n);
+    if (firstX !== -1) distributionX[firstX] += PRECISION - xSum;
+  }
+  if (ySum > 0n && ySum !== PRECISION) {
+    const firstY = distributionY.findIndex((v) => v > 0n);
+    if (firstY !== -1) distributionY[firstY] += PRECISION - ySum;
+  }
+  return { distributionX, distributionY };
+}
+function decodeAddress3(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult5({ abi: _addressDecodeAbi3, functionName: "f", data });
+  } catch {
+    return null;
+  }
+}
+function incentiveId(key) {
+  return keccak256(
+    encodeAbiParameters(
+      [
+        { name: "rewardToken", type: "address" },
+        { name: "bonusRewardToken", type: "address" },
+        { name: "pool", type: "address" },
+        { name: "nonce", type: "uint256" }
+      ],
+      [key.rewardToken, key.bonusRewardToken, key.pool, key.nonce]
+    )
+  );
+}
+function encodeEnterFarming(key, tokenId) {
+  return encodeFunctionData13({
+    abi: farmingCenterAbi,
+    functionName: "enterFarming",
+    args: [key, tokenId]
+  });
+}
+function encodeExitFarming(key, tokenId) {
+  return encodeFunctionData13({
+    abi: farmingCenterAbi,
+    functionName: "exitFarming",
+    args: [key, tokenId]
+  });
+}
+function encodeCollectRewards(key, tokenId) {
+  return encodeFunctionData13({
+    abi: farmingCenterAbi,
+    functionName: "collectRewards",
+    args: [key, tokenId]
+  });
+}
+function encodeClaimReward(rewardToken, to) {
+  return encodeFunctionData13({
+    abi: farmingCenterAbi,
+    functionName: "claimReward",
+    args: [rewardToken, to, 2n ** 128n - 1n]
+    // max uint128
+  });
+}
+function encodeMulticall(calls) {
+  return encodeFunctionData13({
+    abi: farmingCenterAbi,
+    functionName: "multicall",
+    args: [calls]
+  });
+}
 function u256ToF64(v) {
   const MAX_U128 = (1n << 128n) - 1n;
   if (v > MAX_U128) return Infinity;
   return Number(v);
 }
+function decodeAddress4(data) {
+  if (!data || data.length < 66) return null;
+  return `0x${data.slice(26, 66)}`;
+}
+function decodeAddressArray(data) {
+  if (!data) return [];
+  try {
+    return decodeFunctionResult6({
+      abi: REWARDS_CONTROLLER_ABI,
+      functionName: "getRewardsByAsset",
+      data
+    });
+  } catch {
+    return [];
+  }
+}
+function decodeReserveData(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult6({
+      abi: POOL_ABI,
+      functionName: "getReserveData",
+      data
+    });
+  } catch {
+    return null;
+  }
+}
+function decodeRewardsData(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult6({
+      abi: REWARDS_CONTROLLER_ABI,
+      functionName: "getRewardsData",
+      data
+    });
+  } catch {
+    return null;
+  }
+}
 function u256ToF642(v) {
   const MAX_U128 = (1n << 128n) - 1n;
   if (v > MAX_U128) return Infinity;
   return Number(v);
 }
-function defaultMarketParams(loanToken = zeroAddress7) {
+function defaultMarketParams(loanToken = zeroAddress10) {
   return {
     loanToken,
-    collateralToken: zeroAddress7,
-    oracle: zeroAddress7,
-    irm: zeroAddress7,
+    collateralToken: zeroAddress10,
+    oracle: zeroAddress10,
+    irm: zeroAddress10,
     lltv: 0n
   };
 }
+function decodeMarket(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult7({
+      abi: MORPHO_ABI,
+      functionName: "market",
+      data
+    });
+  } catch {
+    return null;
+  }
+}
+function decodeMarketParams(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult7({
+      abi: MORPHO_ABI,
+      functionName: "idToMarketParams",
+      data
+    });
+  } catch {
+    return null;
+  }
+}
 function createDex(entry, rpcUrl) {
   switch (entry.interface) {
     case "uniswap_v3":
@@ -1317,6 +1629,8 @@ function createDex(entry, rpcUrl) {
     case "solidly_v2":
     case "solidly_cl":
       return new SolidlyAdapter(entry, rpcUrl);
+    case "hybra":
+      return new ThenaCLAdapter(entry, rpcUrl);
     case "curve_stableswap":
       return new CurveStableSwapAdapter(entry);
     case "balancer_v3":
@@ -1377,11 +1691,13 @@ function createLiquidStaking(entry, rpcUrl) {
   }
 }
 function createGauge(entry, rpcUrl) {
+  if (entry.interface === "hybra" || entry.contracts?.["gauge_manager"]) {
+    return new HybraGaugeAdapter(entry, rpcUrl);
+  }
   switch (entry.interface) {
     case "solidly_v2":
     case "solidly_cl":
     case "algebra_v3":
-    case "hybra":
       return new SolidlyGaugeAdapter(entry, rpcUrl);
     default:
       throw DefiError.unsupported(`Gauge interface '${entry.interface}' not supported`);
@@ -1441,7 +1757,26 @@ function createOracleFromCdp(entry, _asset, rpcUrl) {
       throw DefiError.unsupported(`Oracle not available for CDP interface '${entry.interface}'`);
   }
 }
-var DEFAULT_FEE, swapRouterAbi, quoterAbi, ramsesQuoterAbi, positionManagerAbi, UniswapV3Adapter, abi, lbQuoterAbi, UniswapV2Adapter, abi2, algebraQuoterAbi, algebraSingleQuoterAbi, algebraPositionManagerAbi, AlgebraV3Adapter, abi3, BalancerV3Adapter, poolAbi, CurveStableSwapAdapter, abi4, abiV2, SolidlyAdapter, abi5, WooFiAdapter, gaugeAbi, veAbi, voterAbi, SolidlyGaugeAdapter, masterchefAbi, MasterChefAdapter, POOL_ABI, ERC20_ABI, INCENTIVES_ABI, REWARDS_CONTROLLER_ABI, POOL_PROVIDER_ABI, ADDRESSES_PROVIDER_ABI, ORACLE_ABI, ERC20_DECIMALS_ABI, AaveV3Adapter, POOL_ABI2, ERC20_ABI2, 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, IRM_ABI, SECONDS_PER_YEAR3, MorphoBlueAdapter, BORROWER_OPS_ABI, TROVE_MANAGER_ABI, HINT_HELPERS_ABI, SORTED_TROVES_ABI, FelixCdpAdapter, PRICE_FEED_ABI, FelixOracleAdapter, ERC4626_ABI, 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;
+function createMerchantMoeLB(entry, rpcUrl) {
+  return new MerchantMoeLBAdapter(entry, rpcUrl);
+}
+function createKittenSwapFarming(entry, rpcUrl) {
+  const farmingCenter = entry.contracts?.["farming_center"];
+  if (!farmingCenter) {
+    throw new DefiError("CONTRACT_ERROR", `[${entry.name}] Missing 'farming_center' contract address`);
+  }
+  const eternalFarming = entry.contracts?.["eternal_farming"];
+  if (!eternalFarming) {
+    throw new DefiError("CONTRACT_ERROR", `[${entry.name}] Missing 'eternal_farming' contract address`);
+  }
+  const positionManager = entry.contracts?.["position_manager"];
+  if (!positionManager) {
+    throw new DefiError("CONTRACT_ERROR", `[${entry.name}] Missing 'position_manager' contract address`);
+  }
+  const factory = entry.contracts?.["factory"];
+  return new KittenSwapFarmingAdapter(entry.name, farmingCenter, eternalFarming, positionManager, rpcUrl, factory);
+}
+var DEFAULT_FEE, swapRouterAbi, quoterAbi, ramsesQuoterAbi, positionManagerAbi, UniswapV3Adapter, abi, lbQuoterAbi, UniswapV2Adapter, abi2, algebraQuoterAbi, algebraSingleQuoterAbi, algebraIntegralPmAbi, algebraV2PmAbi, 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, POOL_ABI, ERC20_ABI, INCENTIVES_ABI, REWARDS_CONTROLLER_ABI, POOL_PROVIDER_ABI, ADDRESSES_PROVIDER_ABI, ORACLE_ABI, ERC20_DECIMALS_ABI, AaveV3Adapter, POOL_ABI2, ERC20_ABI2, 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, IRM_ABI, SECONDS_PER_YEAR3, MorphoBlueAdapter, BORROWER_OPS_ABI, TROVE_MANAGER_ABI, HINT_HELPERS_ABI, SORTED_TROVES_ABI, FelixCdpAdapter, PRICE_FEED_ABI, FelixOracleAdapter, ERC4626_ABI, 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_dist3 = __esm({
   "../defi-protocols/dist/index.js"() {
     "use strict";
@@ -1475,6 +1810,10 @@ var init_dist3 = __esm({
     init_dist2();
     init_dist2();
     init_dist2();
+    init_dist2();
+    init_dist2();
+    init_dist2();
+    init_dist2();
     DEFAULT_FEE = 3e3;
     swapRouterAbi = parseAbi3([
       "struct ExactInputSingleParams { address tokenIn; address tokenOut; uint24 fee; address recipient; uint256 deadline; uint256 amountIn; uint256 amountOutMinimum; uint160 sqrtPriceLimitX96; }",
@@ -1936,7 +2275,11 @@ var init_dist3 = __esm({
     algebraSingleQuoterAbi = parseAbi32([
       "function quoteExactInputSingle((address tokenIn, address tokenOut, uint256 amountIn, uint160 limitSqrtPrice) params) external returns (uint256 amountOut, uint256 amountIn, uint160 sqrtPriceX96After)"
     ]);
-    algebraPositionManagerAbi = parseAbi32([
+    algebraIntegralPmAbi = parseAbi32([
+      "struct MintParams { address token0; address token1; address deployer; int24 tickLower; int24 tickUpper; uint256 amount0Desired; uint256 amount1Desired; uint256 amount0Min; uint256 amount1Min; address recipient; uint256 deadline; }",
+      "function mint(MintParams calldata params) external payable returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1)"
+    ]);
+    algebraV2PmAbi = parseAbi32([
       "struct MintParams { address token0; address token1; int24 tickLower; int24 tickUpper; uint256 amount0Desired; uint256 amount1Desired; uint256 amount0Min; uint256 amount1Min; address recipient; uint256 deadline; }",
       "function mint(MintParams calldata params) external payable returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1)"
     ]);
@@ -2081,36 +2424,58 @@ var init_dist3 = __esm({
           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 amount0 = rawAmount0 === 0n && rawAmount1 > 0n ? 1n : rawAmount0;
-        const amount1 = rawAmount1 === 0n && rawAmount0 > 0n ? 1n : rawAmount1;
-        const data = encodeFunctionData32({
-          abi: algebraPositionManagerAbi,
+        let tickLower = params.tick_lower ?? -887220;
+        let tickUpper = params.tick_upper ?? 887220;
+        const isSingleSide = rawAmount0 === 0n || rawAmount1 === 0n;
+        const needsAutoTick = params.range_pct !== void 0 || isSingleSide && !params.tick_lower && !params.tick_upper;
+        if (needsAutoTick) {
+          if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required for auto tick detection");
+          const poolAddr = params.pool;
+          if (!poolAddr) throw new DefiError("CONTRACT_ERROR", "Pool address required (use --pool)");
+          const client = createPublicClient3({ transport: http3(this.rpcUrl) });
+          const algebraPoolAbi = parseAbi32([
+            "function globalState() view returns (uint160 price, int24 tick, uint16 lastFee, uint8 pluginConfig, uint16 communityFee, bool unlocked)",
+            "function tickSpacing() view returns (int24)"
+          ]);
+          const [globalState, spacing] = await Promise.all([
+            client.readContract({ address: poolAddr, abi: algebraPoolAbi, functionName: "globalState" }),
+            client.readContract({ address: poolAddr, abi: algebraPoolAbi, functionName: "tickSpacing" })
+          ]);
+          const currentTick = Number(globalState[1]);
+          const tickSpace = Number(spacing);
+          if (params.range_pct !== void 0) {
+            const range = rangeToTicks(currentTick, params.range_pct, tickSpace);
+            tickLower = range.tickLower;
+            tickUpper = range.tickUpper;
+          } else if (rawAmount0 > 0n && rawAmount1 === 0n) {
+            tickLower = alignTickUp(currentTick + tickSpace, tickSpace);
+            tickUpper = 887220;
+          } else {
+            tickLower = -887220;
+            tickUpper = alignTickDown(currentTick - tickSpace, tickSpace);
+          }
+        }
+        const amount0 = rawAmount0;
+        const amount1 = rawAmount1;
+        const data = this.useSingleQuoter ? encodeFunctionData32({
+          abi: algebraV2PmAbi,
           functionName: "mint",
-          args: [
-            {
-              token0,
-              token1,
-              tickLower: -887220,
-              tickUpper: 887220,
-              amount0Desired: amount0,
-              amount1Desired: amount1,
-              amount0Min: 0n,
-              amount1Min: 0n,
-              recipient: params.recipient,
-              deadline: BigInt("18446744073709551615")
-            }
-          ]
+          args: [{ token0, token1, tickLower, tickUpper, amount0Desired: amount0, amount1Desired: amount1, amount0Min: 0n, amount1Min: 0n, 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") }]
         });
+        const approvals = [];
+        if (amount0 > 0n) approvals.push({ token: token0, spender: pm, amount: amount0 });
+        if (amount1 > 0n) approvals.push({ token: token1, spender: pm, amount: amount1 });
         return {
-          description: `[${this.protocolName}] Add liquidity`,
+          description: `[${this.protocolName}] Add liquidity [${tickLower}, ${tickUpper}]`,
           to: pm,
           data,
           value: 0n,
           gas_estimate: 5e5,
-          approvals: [
-            { token: token0, spender: pm, amount: amount0 },
-            { token: token1, spender: pm, amount: amount1 }
-          ]
+          approvals
         };
       }
       async buildRemoveLiquidity(_params) {
@@ -2291,15 +2656,6 @@ var init_dist3 = __esm({
           approvals: [{ token: params.token_in, spender: this.router, amount: params.amount_in }]
         };
       }
-      async callGetAmountsOut(client, callData) {
-        const result = await client.call({ to: this.router, data: callData });
-        if (!result.data) return 0n;
-        const [amounts] = decodeAbiParameters4(
-          [{ name: "amounts", type: "uint256[]" }],
-          result.data
-        );
-        return amounts.length >= 2 ? amounts[amounts.length - 1] : 0n;
-      }
       encodeV1(params, stable) {
         return encodeFunctionData6({
           abi: abi4,
@@ -2316,7 +2672,6 @@ var init_dist3 = __esm({
       }
       async quote(params) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient4({ transport: http4(this.rpcUrl) });
         const candidates = [
           { callData: this.encodeV1(params, false), stable: false },
           { callData: this.encodeV1(params, true), stable: true }
@@ -2327,16 +2682,26 @@ var init_dist3 = __esm({
             { callData: this.encodeV2(params, true), stable: true }
           );
         }
-        const results = await Promise.allSettled(
-          candidates.map((c) => this.callGetAmountsOut(client, c.callData))
+        const rawResults = await multicallRead(
+          this.rpcUrl,
+          candidates.map((c) => [this.router, c.callData])
         );
         let bestOut = 0n;
         let bestStable = false;
-        for (let i = 0; i < results.length; i++) {
-          const r = results[i];
-          if (r.status === "fulfilled" && r.value > bestOut) {
-            bestOut = r.value;
-            bestStable = candidates[i].stable;
+        for (let i = 0; i < rawResults.length; i++) {
+          const raw = rawResults[i];
+          if (!raw) continue;
+          try {
+            const [amounts] = decodeAbiParameters4(
+              [{ name: "amounts", type: "uint256[]" }],
+              raw
+            );
+            const out = amounts.length >= 2 ? amounts[amounts.length - 1] : 0n;
+            if (out > bestOut) {
+              bestOut = out;
+              bestStable = candidates[i].stable;
+            }
+          } catch {
           }
         }
         if (bestOut === 0n) {
@@ -2402,347 +2767,1185 @@ var init_dist3 = __esm({
         };
       }
     };
-    abi5 = parseAbi7([
-      "function swap(address fromToken, address toToken, uint256 fromAmount, uint256 minToAmount, address to, address rebateTo) external payable returns (uint256 realToAmount)"
+    thenaPmAbi = parseAbi7([
+      "struct MintParams { 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(MintParams calldata params) external payable returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1)"
     ]);
-    WooFiAdapter = class {
+    thenaRouterAbi = parseAbi7([
+      "struct ExactInputSingleParams { address tokenIn; address tokenOut; int24 tickSpacing; address recipient; uint256 deadline; uint256 amountIn; uint256 amountOutMinimum; uint160 sqrtPriceLimitX96; }",
+      "function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut)"
+    ]);
+    thenaPoolAbi = parseAbi7([
+      "function slot0() view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, bool unlocked)",
+      "function tickSpacing() view returns (int24)",
+      "function token0() view returns (address)",
+      "function token1() view returns (address)"
+    ]);
+    thenaFactoryAbi = parseAbi7([
+      "function getPool(address tokenA, address tokenB, int24 tickSpacing) view returns (address)"
+    ]);
+    ThenaCLAdapter = class {
       protocolName;
       router;
-      constructor(entry, _rpcUrl) {
+      positionManager;
+      factory;
+      rpcUrl;
+      defaultTickSpacing;
+      constructor(entry, rpcUrl) {
         this.protocolName = entry.name;
         const router = entry.contracts?.["router"];
-        if (!router) {
-          throw new DefiError("CONTRACT_ERROR", "Missing 'router' contract");
-        }
+        if (!router) throw new DefiError("CONTRACT_ERROR", "Missing 'router' contract address");
         this.router = router;
+        this.positionManager = entry.contracts?.["position_manager"];
+        this.factory = entry.contracts?.["pool_factory"];
+        this.rpcUrl = rpcUrl;
+        this.defaultTickSpacing = 50;
       }
       name() {
         return this.protocolName;
       }
       async buildSwap(params) {
-        const minToAmount = 0n;
         const data = encodeFunctionData7({
-          abi: abi5,
-          functionName: "swap",
-          args: [
-            params.token_in,
-            params.token_out,
-            params.amount_in,
-            minToAmount,
-            params.recipient,
-            zeroAddress3
-          ]
+          abi: thenaRouterAbi,
+          functionName: "exactInputSingle",
+          args: [{
+            tokenIn: params.token_in,
+            tokenOut: params.token_out,
+            tickSpacing: this.defaultTickSpacing,
+            recipient: params.recipient,
+            deadline: BigInt(params.deadline ?? 18446744073709551615n),
+            amountIn: params.amount_in,
+            amountOutMinimum: 0n,
+            sqrtPriceLimitX96: 0n
+          }]
         });
         return {
-          description: `[${this.protocolName}] Swap ${params.amount_in} via WOOFi`,
+          description: `[${this.protocolName}] Swap`,
           to: this.router,
           data,
           value: 0n,
-          gas_estimate: 2e5
+          gas_estimate: 3e5,
+          approvals: [{ token: params.token_in, spender: this.router, amount: params.amount_in }]
         };
       }
       async quote(_params) {
-        throw DefiError.unsupported(`[${this.protocolName}] quote requires RPC`);
+        throw DefiError.unsupported(`[${this.protocolName}] quote not yet implemented \u2014 use swap router`);
       }
-      async buildAddLiquidity(_params) {
-        throw DefiError.unsupported(`[${this.protocolName}] WOOFi does not support LP positions via router`);
+      async buildAddLiquidity(params) {
+        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 client = createPublicClient4({ transport: http4(this.rpcUrl) });
+        const poolAddr = params.pool;
+        let tickSpacing = this.defaultTickSpacing;
+        let tickLower = params.tick_lower ?? 0;
+        let tickUpper = params.tick_upper ?? 0;
+        if (poolAddr || !params.tick_lower || !params.tick_upper) {
+          let pool = poolAddr;
+          if (!pool && this.factory) {
+            pool = await client.readContract({
+              address: this.factory,
+              abi: thenaFactoryAbi,
+              functionName: "getPool",
+              args: [token0, token1, tickSpacing]
+            });
+            if (pool === zeroAddress3) throw new DefiError("CONTRACT_ERROR", "Pool not found");
+          }
+          if (pool) {
+            const [slot0, ts] = await Promise.all([
+              client.readContract({ address: pool, abi: thenaPoolAbi, functionName: "slot0" }),
+              client.readContract({ address: pool, abi: thenaPoolAbi, functionName: "tickSpacing" })
+            ]);
+            const currentTick = Number(slot0[1]);
+            tickSpacing = Number(ts);
+            if (params.range_pct !== void 0) {
+              const range = rangeToTicks(currentTick, params.range_pct, tickSpacing);
+              tickLower = range.tickLower;
+              tickUpper = range.tickUpper;
+            } else if (!params.tick_lower && !params.tick_upper) {
+              const isSingleSide = rawAmount0 === 0n || rawAmount1 === 0n;
+              if (isSingleSide) {
+                if (rawAmount0 > 0n) {
+                  tickLower = alignTickUp(currentTick + tickSpacing, tickSpacing);
+                  tickUpper = Math.floor(887272 / tickSpacing) * tickSpacing;
+                } else {
+                  tickLower = Math.ceil(-887272 / tickSpacing) * tickSpacing;
+                  tickUpper = alignTickDown(currentTick - tickSpacing, tickSpacing);
+                }
+              } else {
+                tickLower = Math.ceil(-887272 / tickSpacing) * tickSpacing;
+                tickUpper = Math.floor(887272 / tickSpacing) * tickSpacing;
+              }
+            }
+          }
+        }
+        if (params.tick_lower !== void 0) tickLower = params.tick_lower;
+        if (params.tick_upper !== void 0) tickUpper = params.tick_upper;
+        const data = encodeFunctionData7({
+          abi: thenaPmAbi,
+          functionName: "mint",
+          args: [{
+            token0,
+            token1,
+            tickSpacing,
+            tickLower,
+            tickUpper,
+            amount0Desired: rawAmount0,
+            amount1Desired: rawAmount1,
+            amount0Min: 0n,
+            amount1Min: 0n,
+            recipient: params.recipient,
+            deadline: BigInt("18446744073709551615"),
+            sqrtPriceX96: 0n
+          }]
+        });
+        const approvals = [];
+        if (rawAmount0 > 0n) approvals.push({ token: token0, spender: pm, amount: rawAmount0 });
+        if (rawAmount1 > 0n) approvals.push({ token: token1, spender: pm, amount: rawAmount1 });
+        return {
+          description: `[${this.protocolName}] Add liquidity [${tickLower}, ${tickUpper}]`,
+          to: pm,
+          data,
+          value: 0n,
+          gas_estimate: 7e5,
+          approvals
+        };
       }
       async buildRemoveLiquidity(_params) {
-        throw DefiError.unsupported(`[${this.protocolName}] WOOFi does not support LP positions via router`);
+        throw DefiError.unsupported(`[${this.protocolName}] remove_liquidity requires tokenId`);
       }
     };
-    gaugeAbi = parseAbi8([
-      "function deposit(uint256 amount) external",
-      "function depositFor(uint256 amount, uint256 tokenId) external",
-      "function withdraw(uint256 amount) external",
-      "function getReward(address account) external",
-      "function getReward(address account, address[] tokens) external",
-      "function earned(address account) external view returns (uint256)",
-      "function earned(address token, address account) external view returns (uint256)",
-      "function rewardRate() external view returns (uint256)",
-      "function totalSupply() external view returns (uint256)",
-      "function rewardsListLength() external view returns (uint256)",
-      "function isReward(address token) external view returns (bool)"
+    _addressDecodeAbi = parseAbi8(["function f() external view returns (address)"]);
+    _symbolDecodeAbi = parseAbi8(["function symbol() external view returns (string)"]);
+    gaugeManagerAbi = parseAbi8([
+      "function gauges(address pool) view returns (address gauge)",
+      "function isGauge(address gauge) view returns (bool)",
+      "function isAlive(address gauge) view returns (bool)",
+      "function claimRewards(address gauge, uint256[] tokenIds, uint8 redeemType) external"
+    ]);
+    gaugeCLAbi = parseAbi8([
+      "function deposit(uint256 tokenId) external",
+      "function withdraw(uint256 tokenId, uint8 redeemType) external",
+      "function earned(uint256 tokenId) view returns (uint256)",
+      "function balanceOf(uint256 tokenId) view returns (uint256)",
+      "function rewardToken() view returns (address)"
+    ]);
+    nfpmAbi = parseAbi8([
+      "function approve(address to, uint256 tokenId) external",
+      "function getApproved(uint256 tokenId) view returns (address)"
     ]);
     veAbi = parseAbi8([
       "function create_lock(uint256 value, uint256 lock_duration) external returns (uint256)",
       "function increase_amount(uint256 tokenId, uint256 value) external",
       "function increase_unlock_time(uint256 tokenId, uint256 lock_duration) external",
-      "function withdraw(uint256 tokenId) external",
-      "function balanceOfNFT(uint256 tokenId) external view returns (uint256)",
-      "function locked(uint256 tokenId) external view returns (uint256 amount, uint256 end)"
+      "function withdraw(uint256 tokenId) external"
     ]);
     voterAbi = parseAbi8([
-      "function vote(uint256 tokenId, address[] calldata pools, uint256[] calldata weights) external",
-      "function claimBribes(address[] calldata bribes, address[][] calldata tokens, uint256 tokenId) external",
-      "function claimFees(address[] calldata fees, address[][] calldata tokens, uint256 tokenId) external",
-      "function gauges(address pool) external view returns (address)"
+      "function vote(uint256 tokenId, address[] pools, uint256[] weights) external",
+      "function claimBribes(address[] bribes, address[][] tokens, uint256 tokenId) external",
+      "function claimFees(address[] fees, address[][] tokens, uint256 tokenId) external"
     ]);
-    SolidlyGaugeAdapter = class {
+    HybraGaugeAdapter = class {
       protocolName;
-      voter;
+      gaugeManager;
       veToken;
+      voter;
+      positionManager;
+      poolFactory;
       rpcUrl;
       constructor(entry, rpcUrl) {
         this.protocolName = entry.name;
-        const voter = entry.contracts?.["voter"];
-        if (!voter) {
-          throw new DefiError("CONTRACT_ERROR", "Missing 'voter' contract");
-        }
-        const veToken = entry.contracts?.["ve_token"];
-        if (!veToken) {
-          throw new DefiError("CONTRACT_ERROR", "Missing 've_token' contract");
-        }
-        this.voter = voter;
-        this.veToken = veToken;
+        const gm = entry.contracts?.["gauge_manager"];
+        if (!gm) throw new DefiError("CONTRACT_ERROR", "Missing 'gauge_manager' contract");
+        this.gaugeManager = gm;
+        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.poolFactory = entry.contracts?.["pool_factory"];
         this.rpcUrl = rpcUrl;
       }
       name() {
         return this.protocolName;
       }
-      // IGauge
-      async buildDeposit(gauge, amount, tokenId, lpToken) {
-        if (tokenId !== void 0) {
-          const data2 = encodeFunctionData8({
-            abi: gaugeAbi,
-            functionName: "depositFor",
-            args: [amount, tokenId]
+      // ─── Gauge Discovery ──────────────────────────────────────
+      async discoverGaugedPools() {
+        if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required for gauge discovery");
+        if (!this.poolFactory) throw new DefiError("CONTRACT_ERROR", "Missing 'pool_factory' contract");
+        const factoryAbi = parseAbi8([
+          "function allPoolsLength() external view returns (uint256)",
+          "function allPools(uint256) external view returns (address)"
+        ]);
+        const poolAbi2 = parseAbi8([
+          "function token0() external view returns (address)",
+          "function token1() external view returns (address)"
+        ]);
+        const erc20SymbolAbi = parseAbi8(["function symbol() external view returns (string)"]);
+        const gaugesAbi = parseAbi8(["function gauges(address pool) view returns (address gauge)"]);
+        const client = createPublicClient5({ transport: http5(this.rpcUrl) });
+        let poolCount;
+        try {
+          poolCount = await client.readContract({
+            address: this.poolFactory,
+            abi: factoryAbi,
+            functionName: "allPoolsLength"
           });
-          return {
-            description: `[${this.protocolName}] Deposit ${amount} LP to gauge (boost veNFT #${tokenId})`,
-            to: gauge,
-            data: data2,
-            value: 0n,
-            gas_estimate: 2e5,
-            approvals: lpToken ? [{ token: lpToken, spender: gauge, amount }] : void 0
-          };
+        } catch {
+          return [];
         }
-        const data = encodeFunctionData8({
-          abi: gaugeAbi,
-          functionName: "deposit",
-          args: [amount]
+        const count = Number(poolCount);
+        if (count === 0) return [];
+        const poolAddressCalls = [];
+        for (let i = 0; i < count; i++) {
+          poolAddressCalls.push([
+            this.poolFactory,
+            encodeFunctionData8({ abi: factoryAbi, functionName: "allPools", args: [BigInt(i)] })
+          ]);
+        }
+        const poolAddressResults = await multicallRead(this.rpcUrl, poolAddressCalls);
+        const pools = poolAddressResults.map((r) => decodeAddress(r)).filter((a) => a !== null && a !== zeroAddress4);
+        if (pools.length === 0) return [];
+        const gaugeCalls = pools.map((pool) => [
+          this.gaugeManager,
+          encodeFunctionData8({ abi: gaugesAbi, functionName: "gauges", args: [pool] })
+        ]);
+        const gaugeResults = await multicallRead(this.rpcUrl, gaugeCalls);
+        const gaugedPools = [];
+        for (let i = 0; i < pools.length; i++) {
+          const gauge = decodeAddress(gaugeResults[i] ?? null);
+          if (gauge && gauge !== zeroAddress4) {
+            gaugedPools.push({ pool: pools[i], gauge });
+          }
+        }
+        if (gaugedPools.length === 0) return [];
+        const tokenCalls = [];
+        for (const { pool } of gaugedPools) {
+          tokenCalls.push([pool, encodeFunctionData8({ abi: poolAbi2, functionName: "token0" })]);
+          tokenCalls.push([pool, encodeFunctionData8({ abi: poolAbi2, functionName: "token1" })]);
+        }
+        const tokenResults = await multicallRead(this.rpcUrl, tokenCalls);
+        const tokenAddrs = /* @__PURE__ */ new Set();
+        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);
+        }
+        const uniqueTokens = Array.from(tokenAddrs);
+        const symbolCalls = uniqueTokens.map((t) => [
+          t,
+          encodeFunctionData8({ abi: erc20SymbolAbi, functionName: "symbol" })
+        ]);
+        const symbolResults = await multicallRead(this.rpcUrl, symbolCalls);
+        const symbolMap = /* @__PURE__ */ new Map();
+        for (let i = 0; i < uniqueTokens.length; i++) {
+          symbolMap.set(uniqueTokens[i], decodeSymbol(symbolResults[i] ?? null));
+        }
+        const out = [];
+        for (let i = 0; i < gaugedPools.length; i++) {
+          const { pool, gauge } = gaugedPools[i];
+          const t0 = decodeAddress(tokenResults[i * 2] ?? null);
+          const t1 = decodeAddress(tokenResults[i * 2 + 1] ?? null);
+          out.push({
+            pool,
+            gauge,
+            token0: t0 ? symbolMap.get(t0) ?? t0.slice(0, 10) : "?",
+            token1: t1 ? symbolMap.get(t1) ?? t1.slice(0, 10) : "?",
+            type: "CL"
+          });
+        }
+        return out;
+      }
+      // ─── Gauge Lookup ──────────────────────────────────────────
+      async resolveGauge(pool) {
+        if (!this.rpcUrl) throw DefiError.rpcError("RPC required");
+        const client = createPublicClient5({ transport: http5(this.rpcUrl) });
+        const gauge = await client.readContract({
+          address: this.gaugeManager,
+          abi: gaugeManagerAbi,
+          functionName: "gauges",
+          args: [pool]
         });
-        return {
-          description: `[${this.protocolName}] Deposit ${amount} LP to gauge`,
+        if (gauge === zeroAddress4) throw new DefiError("CONTRACT_ERROR", `No gauge for pool ${pool}`);
+        return gauge;
+      }
+      // ─── CL Gauge: NFT Deposit/Withdraw ──────────────────────────
+      async buildDeposit(gauge, _amount, tokenId) {
+        if (tokenId === void 0) throw new DefiError("CONTRACT_ERROR", "tokenId required for CL gauge deposit");
+        const approveTx = {
+          description: `[${this.protocolName}] Approve NFT #${tokenId} to gauge`,
+          to: this.positionManager,
+          data: encodeFunctionData8({ abi: nfpmAbi, functionName: "approve", args: [gauge, tokenId] }),
+          value: 0n,
+          gas_estimate: 8e4
+        };
+        return {
+          description: `[${this.protocolName}] Deposit NFT #${tokenId} to gauge`,
           to: gauge,
-          data,
+          data: encodeFunctionData8({ abi: gaugeCLAbi, functionName: "deposit", args: [tokenId] }),
           value: 0n,
-          gas_estimate: 2e5,
-          approvals: lpToken ? [{ token: lpToken, spender: gauge, amount }] : void 0
+          gas_estimate: 5e5,
+          pre_txs: [approveTx]
         };
       }
-      async buildWithdraw(gauge, amount) {
-        const data = encodeFunctionData8({
-          abi: gaugeAbi,
-          functionName: "withdraw",
-          args: [amount]
-        });
+      async buildWithdraw(gauge, _amount, tokenId) {
+        if (tokenId === void 0) throw new DefiError("CONTRACT_ERROR", "tokenId required for CL gauge withdraw");
         return {
-          description: `[${this.protocolName}] Withdraw ${amount} LP from gauge`,
+          description: `[${this.protocolName}] Withdraw NFT #${tokenId} from gauge`,
           to: gauge,
-          data,
+          data: encodeFunctionData8({ abi: gaugeCLAbi, functionName: "withdraw", args: [tokenId, 1] }),
           value: 0n,
-          gas_estimate: 2e5
+          gas_estimate: 1e6
         };
       }
-      async buildClaimRewards(gauge, account) {
-        if (account && this.rpcUrl) {
-          try {
-            const client = createPublicClient5({ transport: http5(this.rpcUrl) });
-            const listLen = await client.readContract({
-              address: gauge,
-              abi: gaugeAbi,
-              functionName: "rewardsListLength"
-            });
-            if (listLen > 0n) {
-              const data2 = encodeFunctionData8({
-                abi: gaugeAbi,
-                functionName: "getReward",
-                args: [account, []]
-              });
-              return {
-                description: `[${this.protocolName}] Claim gauge rewards`,
-                to: gauge,
-                data: data2,
-                value: 0n,
-                gas_estimate: 3e5
-              };
-            }
-          } catch {
-          }
-        }
-        const data = encodeFunctionData8({
-          abi: gaugeAbi,
-          functionName: "getReward",
-          args: [account ?? zeroAddress4]
-        });
+      // ─── Claim: via GaugeManager ──────────────────────────────────
+      async buildClaimRewards(gauge, _account) {
+        throw DefiError.unsupported(`[${this.protocolName}] Use buildClaimRewardsByTokenId for CL gauges`);
+      }
+      async buildClaimRewardsByTokenId(gauge, tokenId) {
         return {
-          description: `[${this.protocolName}] Claim gauge rewards`,
-          to: gauge,
-          data,
+          description: `[${this.protocolName}] Claim rewards for NFT #${tokenId}`,
+          to: this.gaugeManager,
+          data: encodeFunctionData8({
+            abi: gaugeManagerAbi,
+            functionName: "claimRewards",
+            args: [gauge, [tokenId], 1]
+            // redeemType=1
+          }),
           value: 0n,
-          gas_estimate: 2e5
+          gas_estimate: 1e6
         };
       }
-      async getPendingRewards(_gauge, _user) {
-        throw DefiError.unsupported(`[${this.protocolName}] get_pending_rewards requires RPC`);
+      // ─── Pending Rewards ──────────────────────────────────────────
+      async getPendingRewards(gauge, _user) {
+        throw DefiError.unsupported(`[${this.protocolName}] Use getPendingRewardsByTokenId for CL gauges`);
+      }
+      async getPendingRewardsByTokenId(gauge, tokenId) {
+        if (!this.rpcUrl) throw DefiError.rpcError("RPC required");
+        const client = createPublicClient5({ transport: http5(this.rpcUrl) });
+        return await client.readContract({
+          address: gauge,
+          abi: gaugeCLAbi,
+          functionName: "earned",
+          args: [tokenId]
+        });
       }
-      // IVoteEscrow
+      // ─── VoteEscrow ──────────────────────────────────────────────
       async buildCreateLock(amount, lockDuration) {
-        const data = encodeFunctionData8({
-          abi: veAbi,
-          functionName: "create_lock",
-          args: [amount, BigInt(lockDuration)]
-        });
         return {
-          description: `[${this.protocolName}] Create veNFT lock: ${amount} tokens for ${lockDuration}s`,
+          description: `[${this.protocolName}] Create veNFT lock`,
           to: this.veToken,
-          data,
+          data: encodeFunctionData8({ abi: veAbi, functionName: "create_lock", args: [amount, BigInt(lockDuration)] }),
           value: 0n,
           gas_estimate: 3e5
         };
       }
       async buildIncreaseAmount(tokenId, amount) {
-        const data = encodeFunctionData8({
-          abi: veAbi,
-          functionName: "increase_amount",
-          args: [tokenId, amount]
-        });
         return {
-          description: `[${this.protocolName}] Increase veNFT #${tokenId} by ${amount}`,
+          description: `[${this.protocolName}] Increase veNFT #${tokenId}`,
           to: this.veToken,
-          data,
+          data: encodeFunctionData8({ abi: veAbi, functionName: "increase_amount", args: [tokenId, amount] }),
           value: 0n,
           gas_estimate: 2e5
         };
       }
       async buildIncreaseUnlockTime(tokenId, lockDuration) {
-        const data = encodeFunctionData8({
-          abi: veAbi,
-          functionName: "increase_unlock_time",
-          args: [tokenId, BigInt(lockDuration)]
-        });
         return {
-          description: `[${this.protocolName}] Extend veNFT #${tokenId} lock by ${lockDuration}s`,
+          description: `[${this.protocolName}] Extend veNFT #${tokenId} lock`,
           to: this.veToken,
-          data,
+          data: encodeFunctionData8({ abi: veAbi, functionName: "increase_unlock_time", args: [tokenId, BigInt(lockDuration)] }),
           value: 0n,
           gas_estimate: 2e5
         };
       }
       async buildWithdrawExpired(tokenId) {
-        const data = encodeFunctionData8({
-          abi: veAbi,
-          functionName: "withdraw",
-          args: [tokenId]
-        });
         return {
           description: `[${this.protocolName}] Withdraw expired veNFT #${tokenId}`,
           to: this.veToken,
-          data,
+          data: encodeFunctionData8({ abi: veAbi, functionName: "withdraw", args: [tokenId] }),
           value: 0n,
           gas_estimate: 2e5
         };
       }
-      // IVoter
+      // ─── Voter ──────────────────────────────────────────────────
       async buildVote(tokenId, pools, weights) {
-        const data = encodeFunctionData8({
-          abi: voterAbi,
-          functionName: "vote",
-          args: [tokenId, pools, weights]
-        });
         return {
           description: `[${this.protocolName}] Vote with veNFT #${tokenId}`,
           to: this.voter,
-          data,
+          data: encodeFunctionData8({ abi: voterAbi, functionName: "vote", args: [tokenId, pools, weights] }),
           value: 0n,
           gas_estimate: 5e5
         };
       }
       async buildClaimBribes(bribes, tokenId) {
         const tokensPerBribe = bribes.map(() => []);
-        const data = encodeFunctionData8({
-          abi: voterAbi,
-          functionName: "claimBribes",
-          args: [bribes, tokensPerBribe, tokenId]
-        });
         return {
           description: `[${this.protocolName}] Claim bribes for veNFT #${tokenId}`,
           to: this.voter,
-          data,
+          data: encodeFunctionData8({ abi: voterAbi, functionName: "claimBribes", args: [bribes, tokensPerBribe, tokenId] }),
           value: 0n,
           gas_estimate: 3e5
         };
       }
       async buildClaimFees(fees, tokenId) {
         const tokensPerFee = fees.map(() => []);
-        const data = encodeFunctionData8({
-          abi: voterAbi,
-          functionName: "claimFees",
-          args: [fees, tokensPerFee, tokenId]
-        });
         return {
-          description: `[${this.protocolName}] Claim trading fees for veNFT #${tokenId}`,
+          description: `[${this.protocolName}] Claim fees for veNFT #${tokenId}`,
           to: this.voter,
-          data,
+          data: encodeFunctionData8({ abi: voterAbi, functionName: "claimFees", args: [fees, tokensPerFee, tokenId] }),
           value: 0n,
           gas_estimate: 3e5
         };
       }
     };
-    masterchefAbi = parseAbi9([
-      "function deposit(uint256 pid, uint256 amount) external",
-      "function withdraw(uint256 pid, uint256 amount) external",
-      "function claim(uint256[] calldata pids) external",
-      "function pendingRewards(address account, uint256[] calldata pids) view returns (uint256[] memory moeRewards)",
-      "function getNumberOfFarms() view returns (uint256)",
-      "function getPidByPool(address pool) view returns (uint256)"
+    abi5 = parseAbi9([
+      "function swap(address fromToken, address toToken, uint256 fromAmount, uint256 minToAmount, address to, address rebateTo) external payable returns (uint256 realToAmount)"
     ]);
-    MasterChefAdapter = class {
+    WooFiAdapter = class {
       protocolName;
-      masterchef;
+      router;
+      constructor(entry, _rpcUrl) {
+        this.protocolName = entry.name;
+        const router = entry.contracts?.["router"];
+        if (!router) {
+          throw new DefiError("CONTRACT_ERROR", "Missing 'router' contract");
+        }
+        this.router = router;
+      }
+      name() {
+        return this.protocolName;
+      }
+      async buildSwap(params) {
+        const minToAmount = 0n;
+        const data = encodeFunctionData9({
+          abi: abi5,
+          functionName: "swap",
+          args: [
+            params.token_in,
+            params.token_out,
+            params.amount_in,
+            minToAmount,
+            params.recipient,
+            zeroAddress5
+          ]
+        });
+        return {
+          description: `[${this.protocolName}] Swap ${params.amount_in} via WOOFi`,
+          to: this.router,
+          data,
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      async quote(_params) {
+        throw DefiError.unsupported(`[${this.protocolName}] quote requires RPC`);
+      }
+      async buildAddLiquidity(_params) {
+        throw DefiError.unsupported(`[${this.protocolName}] WOOFi does not support LP positions via router`);
+      }
+      async buildRemoveLiquidity(_params) {
+        throw DefiError.unsupported(`[${this.protocolName}] WOOFi does not support LP positions via router`);
+      }
+    };
+    gaugeAbi = parseAbi10([
+      "function deposit(uint256 amount) external",
+      "function depositFor(uint256 amount, uint256 tokenId) external",
+      "function withdraw(uint256 amount) external",
+      "function getReward() external",
+      "function getReward(address account) external",
+      "function getReward(address account, address[] tokens) external",
+      "function getReward(uint256 tokenId) external",
+      "function earned(address account) external view returns (uint256)",
+      "function earned(address token, address account) external view returns (uint256)",
+      "function earned(uint256 tokenId) external view returns (uint256)",
+      "function rewardRate() external view returns (uint256)",
+      "function rewardToken() external view returns (address)",
+      "function totalSupply() external view returns (uint256)",
+      "function rewardsListLength() external view returns (uint256)",
+      "function rewardData(address token) external view returns (uint256 periodFinish, uint256 rewardRate, uint256 lastUpdateTime, uint256 rewardPerTokenStored)",
+      "function nonfungiblePositionManager() external view returns (address)"
+    ]);
+    veAbi2 = parseAbi10([
+      "function create_lock(uint256 value, uint256 lock_duration) external returns (uint256)",
+      "function increase_amount(uint256 tokenId, uint256 value) external",
+      "function increase_unlock_time(uint256 tokenId, uint256 lock_duration) external",
+      "function withdraw(uint256 tokenId) external",
+      "function balanceOfNFT(uint256 tokenId) external view returns (uint256)",
+      "function locked(uint256 tokenId) external view returns (uint256 amount, uint256 end)"
+    ]);
+    voterAbi2 = parseAbi10([
+      "function vote(uint256 tokenId, address[] calldata pools, uint256[] calldata weights) external",
+      "function claimBribes(address[] calldata bribes, address[][] calldata tokens, uint256 tokenId) external",
+      "function claimFees(address[] calldata fees, address[][] calldata tokens, uint256 tokenId) external",
+      "function gauges(address pool) external view returns (address)",
+      "function gaugeForPool(address pool) external view returns (address)",
+      "function poolToGauge(address pool) external view returns (address)"
+    ]);
+    _addressDecodeAbi2 = parseAbi10(["function f() external view returns (address)"]);
+    _symbolDecodeAbi2 = parseAbi10(["function symbol() external view returns (string)"]);
+    _boolDecodeAbi = parseAbi10(["function f() external view returns (bool)"]);
+    HYPEREVM_TOKENS = {
+      WHYPE: "0x5555555555555555555555555555555555555555",
+      USDC: "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
+      USDT0: "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
+      UETH: "0xBe6727B535545C67d5cAa73dEa54865B92CF7907",
+      UBTC: "0x9FDBdA0A5e284c32744D2f17Ee5c74B284993463",
+      USDH: "0x111111a1a0667d36bD57c0A9f569b98057111111",
+      USDe: "0x5d3a1Ff2b6BAb83b63cd9AD0787074081a52ef34",
+      sUSDe: "0x211Cc4DD073734dA055fbF44a2b4667d5E5fE5d2",
+      XAUt0: "0xf4D9235269a96aaDaFc9aDAe454a0618eBE37949",
+      kHYPE: "0xfD739d4e423301CE9385c1fb8850539D657C296D",
+      RAM: "0x555570a286F15EbDFE42B66eDE2f724Aa1AB5555",
+      hyperRAM: "0xAAAE8378809bb8815c08D3C59Eb0c7D1529aD769"
+    };
+    CL_TICK_SPACINGS = [1, 5, 10, 50, 100, 200];
+    SolidlyGaugeAdapter = class {
+      protocolName;
+      voter;
+      veToken;
       rpcUrl;
+      clFactory;
+      v2Factory;
       constructor(entry, rpcUrl) {
         this.protocolName = entry.name;
-        const masterchef = entry.contracts?.["masterchef"];
-        if (!masterchef) {
-          throw new DefiError("CONTRACT_ERROR", "Missing 'masterchef' contract");
+        const voter = entry.contracts?.["voter"];
+        if (!voter) {
+          throw new DefiError("CONTRACT_ERROR", "Missing 'voter' contract");
         }
-        this.masterchef = masterchef;
+        const veToken = entry.contracts?.["ve_token"];
+        if (!veToken) {
+          throw new DefiError("CONTRACT_ERROR", "Missing 've_token' contract");
+        }
+        this.voter = voter;
+        this.veToken = veToken;
         this.rpcUrl = rpcUrl;
+        this.clFactory = entry.contracts?.["cl_factory"] ?? entry.contracts?.["factory"];
+        this.v2Factory = entry.contracts?.["pair_factory"] ?? entry.contracts?.["factory"];
       }
       name() {
         return this.protocolName;
       }
-      /**
-       * Deposit LP tokens into a MasterChef farm.
-       * `gauge` is the pool address (unused for calldata — MasterChef is the target).
-       * `tokenId` carries the farm pid.
-       */
-      async buildDeposit(gauge, amount, tokenId) {
-        const pid = tokenId ?? 0n;
-        const data = encodeFunctionData9({
-          abi: masterchefAbi,
+      /** Scan V2 and CL factories for pools that have active emission gauges. */
+      async discoverGaugedPools() {
+        if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required for gauge discovery");
+        const results = [];
+        await Promise.all([
+          this._discoverV2GaugedPools(results),
+          this._discoverCLGaugedPools(results)
+        ]);
+        return results;
+      }
+      async _discoverV2GaugedPools(out) {
+        if (!this.rpcUrl || !this.v2Factory) return;
+        const v2FactoryAbi = parseAbi10([
+          "function allPairsLength() external view returns (uint256)",
+          "function allPairs(uint256) external view returns (address)"
+        ]);
+        const pairAbi = parseAbi10([
+          "function token0() external view returns (address)",
+          "function token1() external view returns (address)",
+          "function stable() external view returns (bool)"
+        ]);
+        const erc20SymbolAbi = parseAbi10(["function symbol() external view returns (string)"]);
+        const client = createPublicClient6({ transport: http6(this.rpcUrl) });
+        let pairCount;
+        try {
+          pairCount = await client.readContract({
+            address: this.v2Factory,
+            abi: v2FactoryAbi,
+            functionName: "allPairsLength"
+          });
+        } catch {
+          return;
+        }
+        const count = Number(pairCount);
+        if (count === 0) return;
+        const pairAddressCalls = [];
+        for (let i = 0; i < count; i++) {
+          pairAddressCalls.push([
+            this.v2Factory,
+            encodeFunctionData10({ abi: v2FactoryAbi, functionName: "allPairs", args: [BigInt(i)] })
+          ]);
+        }
+        const pairAddressResults = await multicallRead(this.rpcUrl, pairAddressCalls);
+        const pairs = pairAddressResults.map((r) => decodeAddress2(r)).filter((a) => a !== null && a !== zeroAddress6);
+        if (pairs.length === 0) return;
+        const gaugeForPoolAbi = parseAbi10(["function gaugeForPool(address) external view returns (address)"]);
+        const poolToGaugeAbi = parseAbi10(["function poolToGauge(address) external view returns (address)"]);
+        const gaugeCalls = pairs.map((pair) => [
+          this.voter,
+          encodeFunctionData10({ abi: gaugeForPoolAbi, functionName: "gaugeForPool", args: [pair] })
+        ]);
+        let gaugeResults = await multicallRead(this.rpcUrl, gaugeCalls);
+        const allNullV2 = gaugeResults.every((r) => !r || decodeAddress2(r) === zeroAddress6 || decodeAddress2(r) === null);
+        if (allNullV2) {
+          const fallbackCalls = pairs.map((pair) => [
+            this.voter,
+            encodeFunctionData10({ abi: poolToGaugeAbi, functionName: "poolToGauge", args: [pair] })
+          ]);
+          gaugeResults = await multicallRead(this.rpcUrl, fallbackCalls);
+        }
+        const gaugedPairs = [];
+        for (let i = 0; i < pairs.length; i++) {
+          const gauge = decodeAddress2(gaugeResults[i] ?? null);
+          if (gauge && gauge !== zeroAddress6) {
+            gaugedPairs.push({ pair: pairs[i], gauge });
+          }
+        }
+        if (gaugedPairs.length === 0) return;
+        const metaCalls = [];
+        for (const { pair } of gaugedPairs) {
+          metaCalls.push([pair, encodeFunctionData10({ abi: pairAbi, functionName: "token0" })]);
+          metaCalls.push([pair, encodeFunctionData10({ abi: pairAbi, functionName: "token1" })]);
+          metaCalls.push([pair, encodeFunctionData10({ abi: pairAbi, functionName: "stable" })]);
+        }
+        const metaResults = await multicallRead(this.rpcUrl, metaCalls);
+        const tokenAddrs = /* @__PURE__ */ new Set();
+        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);
+        }
+        const uniqueTokens = Array.from(tokenAddrs);
+        const symbolCalls = uniqueTokens.map((t) => [
+          t,
+          encodeFunctionData10({ abi: erc20SymbolAbi, functionName: "symbol" })
+        ]);
+        const symbolResults = await multicallRead(this.rpcUrl, symbolCalls);
+        const symbolMap = /* @__PURE__ */ new Map();
+        for (let i = 0; i < uniqueTokens.length; i++) {
+          symbolMap.set(uniqueTokens[i], decodeSymbol2(symbolResults[i] ?? null));
+        }
+        for (let i = 0; i < gaugedPairs.length; i++) {
+          const { pair, gauge } = gaugedPairs[i];
+          const t0 = decodeAddress2(metaResults[i * 3] ?? null);
+          const t1 = decodeAddress2(metaResults[i * 3 + 1] ?? null);
+          const stableRaw = metaResults[i * 3 + 2];
+          const stable = stableRaw ? decodeBoolean(stableRaw) : false;
+          out.push({
+            pool: pair,
+            gauge,
+            token0: t0 ? symbolMap.get(t0) ?? t0.slice(0, 10) : "?",
+            token1: t1 ? symbolMap.get(t1) ?? t1.slice(0, 10) : "?",
+            type: "V2",
+            stable
+          });
+        }
+      }
+      async _discoverCLGaugedPools(out) {
+        if (!this.rpcUrl || !this.clFactory) return;
+        const clFactoryAbi = parseAbi10([
+          "function getPool(address tokenA, address tokenB, int24 tickSpacing) external view returns (address pool)"
+        ]);
+        const algebraFactoryAbi2 = parseAbi10([
+          "function poolByPair(address tokenA, address tokenB) external view returns (address pool)"
+        ]);
+        const poolAbi2 = parseAbi10([
+          "function token0() external view returns (address)",
+          "function token1() external view returns (address)"
+        ]);
+        const erc20SymbolAbi = parseAbi10(["function symbol() external view returns (string)"]);
+        const gaugeForPoolAbi = parseAbi10(["function gaugeForPool(address) external view returns (address)"]);
+        const poolToGaugeAbi = parseAbi10(["function poolToGauge(address) external view returns (address)"]);
+        const tokenEntries = Object.entries(HYPEREVM_TOKENS);
+        const tokenAddresses = tokenEntries.map(([, addr]) => addr);
+        const pairs = [];
+        for (let i = 0; i < tokenAddresses.length; i++) {
+          for (let j = i + 1; j < tokenAddresses.length; j++) {
+            pairs.push([tokenAddresses[i], tokenAddresses[j]]);
+          }
+        }
+        const isAlgebra = await (async () => {
+          try {
+            const [result] = await multicallRead(this.rpcUrl, [[
+              this.clFactory,
+              encodeFunctionData10({ abi: algebraFactoryAbi2, functionName: "poolByPair", args: [tokenAddresses[0], tokenAddresses[1]] })
+            ]]);
+            return result !== null && result.length >= 66;
+          } catch {
+            return false;
+          }
+        })();
+        const getPoolCalls = [];
+        const callMeta = [];
+        if (isAlgebra) {
+          for (let p = 0; p < pairs.length; p++) {
+            const [tokenA, tokenB] = pairs[p];
+            getPoolCalls.push([
+              this.clFactory,
+              encodeFunctionData10({ abi: algebraFactoryAbi2, functionName: "poolByPair", args: [tokenA, tokenB] })
+            ]);
+            callMeta.push({ pairIdx: p, tickSpacing: 0 });
+          }
+        } else {
+          for (let p = 0; p < pairs.length; p++) {
+            const [tokenA, tokenB] = pairs[p];
+            for (const ts of CL_TICK_SPACINGS) {
+              getPoolCalls.push([
+                this.clFactory,
+                encodeFunctionData10({ abi: clFactoryAbi, functionName: "getPool", args: [tokenA, tokenB, ts] })
+              ]);
+              callMeta.push({ pairIdx: p, tickSpacing: ts });
+            }
+          }
+        }
+        const getPoolResults = await multicallRead(this.rpcUrl, getPoolCalls);
+        const candidatePools = [];
+        for (let i = 0; i < getPoolCalls.length; i++) {
+          const pool = decodeAddress2(getPoolResults[i] ?? null);
+          if (pool && pool !== zeroAddress6) {
+            const { pairIdx, tickSpacing } = callMeta[i];
+            const [tokenA, tokenB] = pairs[pairIdx];
+            candidatePools.push({ pool, tokenA, tokenB, tickSpacing });
+          }
+        }
+        if (candidatePools.length === 0) return;
+        const gaugeCalls = candidatePools.map(({ pool }) => [
+          this.voter,
+          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);
+        if (allNull) {
+          const fallbackCalls = candidatePools.map(({ pool }) => [
+            this.voter,
+            encodeFunctionData10({ abi: poolToGaugeAbi, functionName: "poolToGauge", args: [pool] })
+          ]);
+          gaugeResults = await multicallRead(this.rpcUrl, fallbackCalls);
+        }
+        const gaugedCL = [];
+        for (let i = 0; i < candidatePools.length; i++) {
+          const gauge = decodeAddress2(gaugeResults[i] ?? null);
+          if (gauge && gauge !== zeroAddress6) {
+            gaugedCL.push({ ...candidatePools[i], gauge });
+          }
+        }
+        if (gaugedCL.length === 0) return;
+        const tokenAddrsInPools = /* @__PURE__ */ new Set();
+        for (const { tokenA, tokenB } of gaugedCL) {
+          tokenAddrsInPools.add(tokenA);
+          tokenAddrsInPools.add(tokenB);
+        }
+        const uniqueTokens = Array.from(tokenAddrsInPools);
+        const symbolCalls = uniqueTokens.map((t) => [
+          t,
+          encodeFunctionData10({ abi: erc20SymbolAbi, functionName: "symbol" })
+        ]);
+        const symbolResults = await multicallRead(this.rpcUrl, symbolCalls);
+        const symbolMap = /* @__PURE__ */ new Map();
+        for (let i = 0; i < uniqueTokens.length; i++) {
+          symbolMap.set(uniqueTokens[i], decodeSymbol2(symbolResults[i] ?? null));
+        }
+        const poolTokenCalls = [];
+        for (const { pool } of gaugedCL) {
+          poolTokenCalls.push([pool, encodeFunctionData10({ abi: poolAbi2, functionName: "token0" })]);
+          poolTokenCalls.push([pool, encodeFunctionData10({ abi: poolAbi2, functionName: "token1" })]);
+        }
+        const poolTokenResults = await multicallRead(this.rpcUrl, poolTokenCalls);
+        for (let i = 0; i < gaugedCL.length; i++) {
+          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;
+          out.push({
+            pool,
+            gauge,
+            token0: symbolMap.get(t0) ?? t0.slice(0, 10),
+            token1: symbolMap.get(t1) ?? t1.slice(0, 10),
+            type: "CL",
+            tickSpacing
+          });
+        }
+      }
+      // IGauge
+      async buildDeposit(gauge, amount, tokenId, lpToken) {
+        if (tokenId !== void 0) {
+          const data2 = encodeFunctionData10({
+            abi: gaugeAbi,
+            functionName: "depositFor",
+            args: [amount, tokenId]
+          });
+          return {
+            description: `[${this.protocolName}] Deposit ${amount} LP to gauge (boost veNFT #${tokenId})`,
+            to: gauge,
+            data: data2,
+            value: 0n,
+            gas_estimate: 2e5,
+            approvals: lpToken ? [{ token: lpToken, spender: gauge, amount }] : void 0
+          };
+        }
+        const data = encodeFunctionData10({
+          abi: gaugeAbi,
           functionName: "deposit",
-          args: [pid, amount]
+          args: [amount]
         });
         return {
-          description: `[${this.protocolName}] Deposit ${amount} LP to farm pid=${pid} (pool ${gauge})`,
-          to: this.masterchef,
+          description: `[${this.protocolName}] Deposit ${amount} LP to gauge`,
+          to: gauge,
           data,
           value: 0n,
-          gas_estimate: 2e5
+          gas_estimate: 2e5,
+          approvals: lpToken ? [{ token: lpToken, spender: gauge, amount }] : void 0
         };
       }
-      /**
-       * Withdraw LP tokens from a MasterChef farm.
-       * `gauge` is used to look up the pid description only; call site should pass pid via tokenId
+      async buildWithdraw(gauge, amount) {
+        const data = encodeFunctionData10({
+          abi: gaugeAbi,
+          functionName: "withdraw",
+          args: [amount]
+        });
+        return {
+          description: `[${this.protocolName}] Withdraw ${amount} LP from gauge`,
+          to: gauge,
+          data,
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      /**
+       * Resolve gauge address from a pool address via voter contract.
+       * Tries gaugeForPool (Ramses), poolToGauge (NEST), gauges (classic Solidly).
+       */
+      async resolveGauge(pool) {
+        if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required for gauge lookup");
+        const client = createPublicClient6({ transport: http6(this.rpcUrl) });
+        for (const fn of ["gaugeForPool", "poolToGauge", "gauges"]) {
+          try {
+            const gauge = await client.readContract({
+              address: this.voter,
+              abi: voterAbi2,
+              functionName: fn,
+              args: [pool]
+            });
+            if (gauge !== zeroAddress6) return gauge;
+          } catch {
+          }
+        }
+        throw new DefiError("CONTRACT_ERROR", `[${this.protocolName}] No gauge found for pool ${pool}`);
+      }
+      /**
+       * Discover reward tokens for a gauge.
+       * Returns { tokens, multiToken } where multiToken indicates getReward(account, tokens[]) support.
+       */
+      async discoverRewardTokens(gauge) {
+        if (!this.rpcUrl) return { tokens: [], multiToken: false };
+        const client = createPublicClient6({ transport: http6(this.rpcUrl) });
+        try {
+          const len = await client.readContract({
+            address: gauge,
+            abi: gaugeAbi,
+            functionName: "rewardsListLength"
+          });
+          if (Number(len) > 0) {
+            const candidates = [
+              "0x5555555555555555555555555555555555555555",
+              // WHYPE
+              "0x555570a286F15EbDFE42B66eDE2f724Aa1AB5555",
+              // xRAM
+              "0x067b0C72aa4C6Bd3BFEFfF443c536DCd6a25a9C8",
+              // HYBR
+              "0x07c57E32a3C29D5659bda1d3EFC2E7BF004E3035"
+              // NEST token
+            ];
+            const found = [];
+            for (const token of candidates) {
+              try {
+                const rd = await client.readContract({
+                  address: gauge,
+                  abi: gaugeAbi,
+                  functionName: "rewardData",
+                  args: [token]
+                });
+                if (rd[0] > 0n || rd[1] > 0n) found.push(token);
+              } catch {
+              }
+            }
+            if (found.length > 0) return { tokens: found, multiToken: true };
+            return { tokens: [], multiToken: true };
+          }
+        } catch {
+        }
+        try {
+          const rt = await client.readContract({
+            address: gauge,
+            abi: gaugeAbi,
+            functionName: "rewardToken"
+          });
+          if (rt !== zeroAddress6) return { tokens: [rt], multiToken: false };
+        } catch {
+        }
+        return { tokens: [], multiToken: false };
+      }
+      async buildClaimRewards(gauge, account) {
+        if (!this.rpcUrl || !account) {
+          const data2 = encodeFunctionData10({
+            abi: gaugeAbi,
+            functionName: "getReward",
+            args: [account ?? zeroAddress6]
+          });
+          return { description: `[${this.protocolName}] Claim gauge rewards`, to: gauge, data: data2, value: 0n, gas_estimate: 2e5 };
+        }
+        const { tokens, multiToken } = await this.discoverRewardTokens(gauge);
+        if (multiToken && tokens.length > 0) {
+          const data2 = encodeFunctionData10({
+            abi: gaugeAbi,
+            functionName: "getReward",
+            args: [account, tokens]
+          });
+          return {
+            description: `[${this.protocolName}] Claim gauge rewards (${tokens.length} tokens)`,
+            to: gauge,
+            data: data2,
+            value: 0n,
+            gas_estimate: 3e5
+          };
+        }
+        const data = encodeFunctionData10({
+          abi: gaugeAbi,
+          functionName: "getReward",
+          args: []
+        });
+        return {
+          description: `[${this.protocolName}] Claim gauge rewards`,
+          to: gauge,
+          data,
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      /**
+       * Claim rewards for a CL gauge by NFT tokenId (Hybra V4 style).
+       */
+      async buildClaimRewardsByTokenId(gauge, tokenId) {
+        const data = encodeFunctionData10({
+          abi: gaugeAbi,
+          functionName: "getReward",
+          args: [tokenId]
+        });
+        return {
+          description: `[${this.protocolName}] Claim gauge rewards for NFT #${tokenId}`,
+          to: gauge,
+          data,
+          value: 0n,
+          gas_estimate: 3e5
+        };
+      }
+      async getPendingRewards(gauge, user) {
+        if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required");
+        const client = createPublicClient6({ transport: http6(this.rpcUrl) });
+        const results = [];
+        const { tokens, multiToken } = await this.discoverRewardTokens(gauge);
+        if (multiToken && tokens.length > 0) {
+          for (const token of tokens) {
+            try {
+              const earned = await client.readContract({
+                address: gauge,
+                abi: gaugeAbi,
+                functionName: "earned",
+                args: [token, user]
+              });
+              results.push({ token, symbol: token.slice(0, 10), amount: earned });
+            } catch {
+            }
+          }
+        } else if (tokens.length > 0) {
+          try {
+            const earned = await client.readContract({
+              address: gauge,
+              abi: gaugeAbi,
+              functionName: "earned",
+              args: [user]
+            });
+            results.push({ token: tokens[0], symbol: tokens[0].slice(0, 10), amount: earned });
+          } catch {
+          }
+        } else {
+          try {
+            const earned = await client.readContract({
+              address: gauge,
+              abi: gaugeAbi,
+              functionName: "earned",
+              args: [user]
+            });
+            results.push({ token: zeroAddress6, symbol: "unknown", amount: earned });
+          } catch {
+          }
+        }
+        return results;
+      }
+      /**
+       * Get pending rewards for a CL gauge NFT position (Hybra V4 style).
+       */
+      async getPendingRewardsByTokenId(gauge, tokenId) {
+        if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required");
+        const client = createPublicClient6({ transport: http6(this.rpcUrl) });
+        return await client.readContract({
+          address: gauge,
+          abi: gaugeAbi,
+          functionName: "earned",
+          args: [tokenId]
+        });
+      }
+      // IVoteEscrow
+      async buildCreateLock(amount, lockDuration) {
+        const data = encodeFunctionData10({
+          abi: veAbi2,
+          functionName: "create_lock",
+          args: [amount, BigInt(lockDuration)]
+        });
+        return {
+          description: `[${this.protocolName}] Create veNFT lock: ${amount} tokens for ${lockDuration}s`,
+          to: this.veToken,
+          data,
+          value: 0n,
+          gas_estimate: 3e5
+        };
+      }
+      async buildIncreaseAmount(tokenId, amount) {
+        const data = encodeFunctionData10({
+          abi: veAbi2,
+          functionName: "increase_amount",
+          args: [tokenId, amount]
+        });
+        return {
+          description: `[${this.protocolName}] Increase veNFT #${tokenId} by ${amount}`,
+          to: this.veToken,
+          data,
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      async buildIncreaseUnlockTime(tokenId, lockDuration) {
+        const data = encodeFunctionData10({
+          abi: veAbi2,
+          functionName: "increase_unlock_time",
+          args: [tokenId, BigInt(lockDuration)]
+        });
+        return {
+          description: `[${this.protocolName}] Extend veNFT #${tokenId} lock by ${lockDuration}s`,
+          to: this.veToken,
+          data,
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      async buildWithdrawExpired(tokenId) {
+        const data = encodeFunctionData10({
+          abi: veAbi2,
+          functionName: "withdraw",
+          args: [tokenId]
+        });
+        return {
+          description: `[${this.protocolName}] Withdraw expired veNFT #${tokenId}`,
+          to: this.veToken,
+          data,
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      // IVoter
+      async buildVote(tokenId, pools, weights) {
+        const data = encodeFunctionData10({
+          abi: voterAbi2,
+          functionName: "vote",
+          args: [tokenId, pools, weights]
+        });
+        return {
+          description: `[${this.protocolName}] Vote with veNFT #${tokenId}`,
+          to: this.voter,
+          data,
+          value: 0n,
+          gas_estimate: 5e5
+        };
+      }
+      async buildClaimBribes(bribes, tokenId) {
+        const tokensPerBribe = bribes.map(() => []);
+        const data = encodeFunctionData10({
+          abi: voterAbi2,
+          functionName: "claimBribes",
+          args: [bribes, tokensPerBribe, tokenId]
+        });
+        return {
+          description: `[${this.protocolName}] Claim bribes for veNFT #${tokenId}`,
+          to: this.voter,
+          data,
+          value: 0n,
+          gas_estimate: 3e5
+        };
+      }
+      async buildClaimFees(fees, tokenId) {
+        const tokensPerFee = fees.map(() => []);
+        const data = encodeFunctionData10({
+          abi: voterAbi2,
+          functionName: "claimFees",
+          args: [fees, tokensPerFee, tokenId]
+        });
+        return {
+          description: `[${this.protocolName}] Claim trading fees for veNFT #${tokenId}`,
+          to: this.voter,
+          data,
+          value: 0n,
+          gas_estimate: 3e5
+        };
+      }
+    };
+    masterchefAbi = parseAbi11([
+      "function deposit(uint256 pid, uint256 amount) external",
+      "function withdraw(uint256 pid, uint256 amount) external",
+      "function claim(uint256[] calldata pids) external",
+      "function pendingRewards(address account, uint256[] calldata pids) view returns (uint256[] memory moeRewards)",
+      "function getNumberOfFarms() view returns (uint256)",
+      "function getPidByPool(address pool) view returns (uint256)"
+    ]);
+    MasterChefAdapter = class {
+      protocolName;
+      masterchef;
+      rpcUrl;
+      constructor(entry, rpcUrl) {
+        this.protocolName = entry.name;
+        const masterchef = entry.contracts?.["masterchef"];
+        if (!masterchef) {
+          throw new DefiError("CONTRACT_ERROR", "Missing 'masterchef' contract");
+        }
+        this.masterchef = masterchef;
+        this.rpcUrl = rpcUrl;
+      }
+      name() {
+        return this.protocolName;
+      }
+      /**
+       * Deposit LP tokens into a MasterChef farm.
+       * `gauge` is the pool address (unused for calldata — MasterChef is the target).
+       * `tokenId` carries the farm pid.
+       */
+      async buildDeposit(gauge, amount, tokenId) {
+        const pid = tokenId ?? 0n;
+        const data = encodeFunctionData11({
+          abi: masterchefAbi,
+          functionName: "deposit",
+          args: [pid, amount]
+        });
+        return {
+          description: `[${this.protocolName}] Deposit ${amount} LP to farm pid=${pid} (pool ${gauge})`,
+          to: this.masterchef,
+          data,
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      /**
+       * Withdraw LP tokens from a MasterChef farm.
+       * `gauge` is used to look up the pid description only; call site should pass pid via tokenId
        * on the deposit flow. Here pid defaults to 0 — callers should encode the pid in the gauge
        * address slot or wrap this adapter with a pid-aware helper.
        */
       async buildWithdraw(gauge, amount) {
         const pid = 0n;
-        const data = encodeFunctionData9({
+        const data = encodeFunctionData11({
           abi: masterchefAbi,
           functionName: "withdraw",
           args: [pid, amount]
@@ -2757,7 +3960,7 @@ var init_dist3 = __esm({
       }
       /** Withdraw LP tokens specifying a pid explicitly (MasterChef extension beyond IGauge). */
       async buildWithdrawPid(pid, amount) {
-        const data = encodeFunctionData9({
+        const data = encodeFunctionData11({
           abi: masterchefAbi,
           functionName: "withdraw",
           args: [pid, amount]
@@ -2770,57 +3973,1018 @@ var init_dist3 = __esm({
           gas_estimate: 2e5
         };
       }
-      /** Claim pending MOE rewards. IGauge interface provides no pid — defaults to pid=0. */
-      async buildClaimRewards(gauge) {
-        const pid = 0n;
-        const data = encodeFunctionData9({
-          abi: masterchefAbi,
-          functionName: "claim",
-          args: [[pid]]
-        });
+      /** Claim pending MOE rewards. IGauge interface provides no pid — defaults to pid=0. */
+      async buildClaimRewards(gauge) {
+        const pid = 0n;
+        const data = encodeFunctionData11({
+          abi: masterchefAbi,
+          functionName: "claim",
+          args: [[pid]]
+        });
+        return {
+          description: `[${this.protocolName}] Claim MOE rewards for farm pid=${pid} (pool ${gauge})`,
+          to: this.masterchef,
+          data,
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      /** Claim pending MOE rewards for a specific pid (MasterChef extension beyond IGauge). */
+      async buildClaimRewardsPid(pid) {
+        const data = encodeFunctionData11({
+          abi: masterchefAbi,
+          functionName: "claim",
+          args: [[pid]]
+        });
+        return {
+          description: `[${this.protocolName}] Claim MOE rewards for farm pid=${pid}`,
+          to: this.masterchef,
+          data,
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      /** Get pending MOE rewards for a user. Requires rpcUrl. */
+      async getPendingRewards(_gauge, user) {
+        if (!this.rpcUrl) {
+          throw DefiError.unsupported(`[${this.protocolName}] getPendingRewards requires RPC`);
+        }
+        const client = createPublicClient7({ transport: http7(this.rpcUrl) });
+        const rewards = await client.readContract({
+          address: this.masterchef,
+          abi: masterchefAbi,
+          functionName: "pendingRewards",
+          args: [user, [0n]]
+        });
+        return rewards.map((amount) => ({
+          token: this.masterchef,
+          symbol: "MOE",
+          amount
+        }));
+      }
+    };
+    lbRouterAbi = parseAbi12([
+      "struct LiquidityParameters { address tokenX; address tokenY; uint256 binStep; uint256 amountX; uint256 amountY; uint256 amountXMin; uint256 amountYMin; uint256 activeIdDesired; uint256 idSlippage; int256[] deltaIds; uint256[] distributionX; uint256[] distributionY; address to; address refundTo; uint256 deadline; }",
+      "function addLiquidity(LiquidityParameters calldata liquidityParameters) external returns (uint256 amountXAdded, uint256 amountYAdded, uint256 amountXLeft, uint256 amountYLeft, uint256[] memory depositIds, uint256[] memory liquidityMinted)",
+      "function removeLiquidity(address tokenX, address tokenY, uint16 binStep, uint256 amountXMin, uint256 amountYMin, uint256[] memory ids, uint256[] memory amounts, address to, uint256 deadline) external returns (uint256 amountX, uint256 amountY)"
+    ]);
+    lbFactoryAbi = parseAbi12([
+      "function getNumberOfLBPairs() external view returns (uint256)",
+      "function getLBPairAtIndex(uint256 index) external view returns (address)"
+    ]);
+    lbPairAbi = parseAbi12([
+      "function getLBHooksParameters() external view returns (bytes32)",
+      "function getActiveId() external view returns (uint24)",
+      "function getBinStep() external view returns (uint16)",
+      "function getTokenX() external view returns (address)",
+      "function getTokenY() external view returns (address)",
+      "function balanceOf(address account, uint256 id) external view returns (uint256)",
+      "function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory)"
+    ]);
+    lbRewarderAbi = parseAbi12([
+      "function getRewardToken() external view returns (address)",
+      "function getRewardedRange() external view returns (uint256 minBinId, uint256 maxBinId)",
+      "function getPendingRewards(address user, uint256[] calldata ids) external view returns (uint256 pendingRewards)",
+      "function claim(address user, uint256[] calldata ids) external",
+      "function getPid() external view returns (uint256)",
+      "function isStopped() external view returns (bool)",
+      "function getLBPair() external view returns (address)",
+      "function getMasterChef() external view returns (address)"
+    ]);
+    masterChefAbi = parseAbi12([
+      "function getMoePerSecond() external view returns (uint256)",
+      "function getTreasuryShare() external view returns (uint256)",
+      "function getStaticShare() external view returns (uint256)",
+      "function getVeMoe() external view returns (address)"
+    ]);
+    veMoeAbi = parseAbi12([
+      "function getWeight(uint256 pid) external view returns (uint256)",
+      "function getTotalWeight() external view returns (uint256)",
+      "function getTopPoolIds() external view returns (uint256[] memory)"
+    ]);
+    lbPairBinAbi = parseAbi12([
+      "function getBin(uint24 id) external view returns (uint128 reserveX, uint128 reserveY)",
+      "function getActiveId() external view returns (uint24)"
+    ]);
+    lbQuoterAbi2 = parseAbi12([
+      "function findBestPathFromAmountIn(address[] calldata route, uint128 amountIn) external view returns ((address[] route, address[] pairs, uint256[] binSteps, uint256[] versions, uint128[] amounts, uint128[] virtualAmountsWithoutSlippage, uint128[] fees))"
+    ]);
+    erc20Abi2 = parseAbi12([
+      "function symbol() external view returns (string)"
+    ]);
+    _addressAbi = parseAbi12(["function f() external view returns (address)"]);
+    _uint256Abi = parseAbi12(["function f() external view returns (uint256)"]);
+    _boolAbi = parseAbi12(["function f() external view returns (bool)"]);
+    _rangeAbi = parseAbi12(["function f() external view returns (uint256 minBinId, uint256 maxBinId)"]);
+    _binAbi = parseAbi12(["function f() external view returns (uint128 reserveX, uint128 reserveY)"]);
+    _uint256ArrayAbi = parseAbi12(["function f() external view returns (uint256[] memory)"]);
+    MerchantMoeLBAdapter = class {
+      protocolName;
+      lbRouter;
+      lbFactory;
+      lbQuoter;
+      rpcUrl;
+      /** WMNT address (lb_mid_wmnt in config) used for MOE price routing */
+      wmnt;
+      /** USDT address (lb_mid_usdt in config) used for MNT/USD price routing */
+      usdt;
+      constructor(entry, rpcUrl) {
+        this.protocolName = entry.name;
+        const lbRouter = entry.contracts?.["lb_router"];
+        if (!lbRouter) {
+          throw new DefiError("CONTRACT_ERROR", "Missing 'lb_router' contract address");
+        }
+        const lbFactory = entry.contracts?.["lb_factory"];
+        if (!lbFactory) {
+          throw new DefiError("CONTRACT_ERROR", "Missing 'lb_factory' contract address");
+        }
+        this.lbRouter = lbRouter;
+        this.lbFactory = lbFactory;
+        this.lbQuoter = entry.contracts?.["lb_quoter"];
+        this.wmnt = entry.contracts?.["lb_mid_wmnt"];
+        this.usdt = entry.contracts?.["lb_mid_usdt"];
+        this.rpcUrl = rpcUrl;
+      }
+      name() {
+        return this.protocolName;
+      }
+      requireRpc() {
+        if (!this.rpcUrl) {
+          throw DefiError.rpcError(`[${this.protocolName}] RPC URL required`);
+        }
+        return this.rpcUrl;
+      }
+      /**
+       * Build an addLiquidity transaction for a Liquidity Book pair.
+       * Distributes tokenX/tokenY uniformly across active bin ± numBins.
+       */
+      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 deltaIds = [];
+        for (let d = -numBins; d <= numBins; d++) {
+          deltaIds.push(d);
+        }
+        const { distributionX, distributionY } = buildUniformDistribution(deltaIds);
+        const data = encodeFunctionData12({
+          abi: lbRouterAbi,
+          functionName: "addLiquidity",
+          args: [
+            {
+              tokenX: params.tokenX,
+              tokenY: params.tokenY,
+              binStep: BigInt(params.binStep),
+              amountX: params.amountX,
+              amountY: params.amountY,
+              amountXMin: 0n,
+              amountYMin: 0n,
+              activeIdDesired: BigInt(activeIdDesired),
+              idSlippage: BigInt(numBins + 2),
+              deltaIds: deltaIds.map(BigInt),
+              distributionX,
+              distributionY,
+              to: params.recipient,
+              refundTo: params.recipient,
+              deadline
+            }
+          ]
+        });
+        return {
+          description: `[${this.protocolName}] LB addLiquidity ${params.amountX} tokenX + ${params.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 }
+          ]
+        };
+      }
+      /**
+       * Build a removeLiquidity transaction for specific LB bins.
+       */
+      async buildRemoveLiquidity(params) {
+        const deadline = params.deadline ?? BigInt("18446744073709551615");
+        const data = encodeFunctionData12({
+          abi: lbRouterAbi,
+          functionName: "removeLiquidity",
+          args: [
+            params.tokenX,
+            params.tokenY,
+            params.binStep,
+            params.amountXMin ?? 0n,
+            params.amountYMin ?? 0n,
+            params.binIds.map(BigInt),
+            params.amounts,
+            params.recipient,
+            deadline
+          ]
+        });
+        return {
+          description: `[${this.protocolName}] LB removeLiquidity from ${params.binIds.length} bins`,
+          to: this.lbRouter,
+          data,
+          value: 0n,
+          gas_estimate: 6e5
+        };
+      }
+      /**
+       * Auto-detect bin IDs for a pool from the rewarder's rewarded range.
+       * Falls back to active bin ± 50 scan if no rewarder exists.
+       */
+      async autoDetectBins(pool) {
+        const rpcUrl = this.requireRpc();
+        const client = createPublicClient8({ transport: http8(rpcUrl) });
+        const hooksParams = await client.readContract({
+          address: pool,
+          abi: lbPairAbi,
+          functionName: "getLBHooksParameters"
+        });
+        const rewarder = extractRewarderAddress(hooksParams);
+        if (rewarder) {
+          const range = await client.readContract({
+            address: rewarder,
+            abi: lbRewarderAbi,
+            functionName: "getRewardedRange"
+          });
+          const min = Number(range[0]);
+          const max = Number(range[1]);
+          const ids2 = [];
+          for (let b = min; b <= max; b++) ids2.push(b);
+          return ids2;
+        }
+        const activeId = await client.readContract({
+          address: pool,
+          abi: lbPairAbi,
+          functionName: "getActiveId"
+        });
+        const ids = [];
+        for (let b = activeId - 50; b <= activeId + 50; b++) ids.push(b);
+        return ids;
+      }
+      /**
+       * Get pending MOE rewards for a user across specified bin IDs.
+       * If binIds is omitted, auto-detects from the rewarder's rewarded range.
+       * Reads the rewarder address from the pool's hooks parameters.
+       */
+      async getPendingRewards(user, pool, binIds) {
+        const rpcUrl = this.requireRpc();
+        const client = createPublicClient8({ transport: http8(rpcUrl) });
+        const hooksParams = await client.readContract({
+          address: pool,
+          abi: lbPairAbi,
+          functionName: "getLBHooksParameters"
+        });
+        const rewarder = extractRewarderAddress(hooksParams);
+        if (!rewarder) {
+          return [];
+        }
+        let resolvedBinIds = binIds;
+        if (!resolvedBinIds || resolvedBinIds.length === 0) {
+          const range = await client.readContract({
+            address: rewarder,
+            abi: lbRewarderAbi,
+            functionName: "getRewardedRange"
+          });
+          const min = Number(range[0]);
+          const max = Number(range[1]);
+          resolvedBinIds = [];
+          for (let b = min; b <= max; b++) resolvedBinIds.push(b);
+        }
+        const [pending, rewardToken] = await Promise.all([
+          client.readContract({
+            address: rewarder,
+            abi: lbRewarderAbi,
+            functionName: "getPendingRewards",
+            args: [user, resolvedBinIds.map(BigInt)]
+          }),
+          client.readContract({
+            address: rewarder,
+            abi: lbRewarderAbi,
+            functionName: "getRewardToken"
+          })
+        ]);
+        return [
+          {
+            token: rewardToken,
+            symbol: "MOE",
+            amount: pending
+          }
+        ];
+      }
+      /**
+       * Build a claim rewards transaction for specific LB bins.
+       * If binIds is omitted, auto-detects from the rewarder's rewarded range.
+       */
+      async buildClaimRewards(user, pool, binIds) {
+        const rpcUrl = this.requireRpc();
+        const client = createPublicClient8({ transport: http8(rpcUrl) });
+        const hooksParams = await client.readContract({
+          address: pool,
+          abi: lbPairAbi,
+          functionName: "getLBHooksParameters"
+        });
+        const rewarder = extractRewarderAddress(hooksParams);
+        if (!rewarder) {
+          throw new DefiError("CONTRACT_ERROR", `[${this.protocolName}] Pool ${pool} has no active rewarder`);
+        }
+        let resolvedBinIds = binIds;
+        if (!resolvedBinIds || resolvedBinIds.length === 0) {
+          const range = await client.readContract({
+            address: rewarder,
+            abi: lbRewarderAbi,
+            functionName: "getRewardedRange"
+          });
+          const min = Number(range[0]);
+          const max = Number(range[1]);
+          resolvedBinIds = [];
+          for (let b = min; b <= max; b++) resolvedBinIds.push(b);
+        }
+        const data = encodeFunctionData12({
+          abi: lbRewarderAbi,
+          functionName: "claim",
+          args: [user, resolvedBinIds.map(BigInt)]
+        });
+        return {
+          description: `[${this.protocolName}] LB claim rewards for ${resolvedBinIds.length} bins`,
+          to: rewarder,
+          data,
+          value: 0n,
+          gas_estimate: 3e5
+        };
+      }
+      /**
+       * Discover all active rewarded LB pools by iterating the factory.
+       * Uses 7 multicall batches to minimise RPC round-trips and avoid 429s.
+       *
+       * Batch 1: getNumberOfLBPairs(), then getLBPairAtIndex(i) for all i
+       * Batch 2: getLBHooksParameters() for all pairs → extract rewarder addresses
+       * Batch 3: isStopped/getRewardedRange/getRewardToken/getPid/getMasterChef for each rewarder
+       * Batch 4: getTokenX/getTokenY for each rewarded pair, then symbol() for unique tokens
+       * Batch 5: Bootstrap MasterChef→VeMoe, then getMoePerSecond/getTreasuryShare/getStaticShare/getTotalWeight/getTopPoolIds
+       * Batch 6: VeMoe.getWeight(pid) for each rewarded pool
+       * Batch 7: Pool.getBin(binId) for all bins in rewarded range of each pool
+       * Price: LB Quoter findBestPathFromAmountIn for MOE/WMNT and WMNT/USDT prices
+       */
+      async discoverRewardedPools() {
+        const rpcUrl = this.requireRpc();
+        const client = createPublicClient8({ transport: http8(rpcUrl) });
+        const pairCount = await client.readContract({
+          address: this.lbFactory,
+          abi: lbFactoryAbi,
+          functionName: "getNumberOfLBPairs"
+        });
+        const count = Number(pairCount);
+        if (count === 0) return [];
+        const batch1Calls = Array.from({ length: count }, (_, i) => [
+          this.lbFactory,
+          encodeFunctionData12({ abi: lbFactoryAbi, functionName: "getLBPairAtIndex", args: [BigInt(i)] })
+        ]);
+        const batch1Results = await multicallRead(rpcUrl, batch1Calls);
+        const pairAddresses = batch1Results.map((r) => decodeAddressResult(r)).filter((a) => a !== null);
+        if (pairAddresses.length === 0) return [];
+        const batch2Calls = pairAddresses.map((pair) => [
+          pair,
+          encodeFunctionData12({ abi: lbPairAbi, functionName: "getLBHooksParameters" })
+        ]);
+        const batch2Results = await multicallRead(rpcUrl, batch2Calls);
+        const rewardedPairs = [];
+        for (let i = 0; i < pairAddresses.length; i++) {
+          const raw = batch2Results[i];
+          if (!raw) continue;
+          let hooksBytes;
+          try {
+            const _bytes32Abi = parseAbi12(["function f() external view returns (bytes32)"]);
+            hooksBytes = decodeFunctionResult4({ abi: _bytes32Abi, functionName: "f", data: raw });
+          } catch {
+            continue;
+          }
+          const rewarder = extractRewarderAddress(hooksBytes);
+          if (rewarder) {
+            rewardedPairs.push({ pool: pairAddresses[i], rewarder });
+          }
+        }
+        if (rewardedPairs.length === 0) return [];
+        const batch3Calls = [];
+        for (const { rewarder } of rewardedPairs) {
+          batch3Calls.push([rewarder, encodeFunctionData12({ abi: lbRewarderAbi, functionName: "isStopped" })]);
+          batch3Calls.push([rewarder, encodeFunctionData12({ abi: lbRewarderAbi, functionName: "getRewardedRange" })]);
+          batch3Calls.push([rewarder, encodeFunctionData12({ abi: lbRewarderAbi, functionName: "getRewardToken" })]);
+          batch3Calls.push([rewarder, encodeFunctionData12({ abi: lbRewarderAbi, functionName: "getPid" })]);
+          batch3Calls.push([rewarder, encodeFunctionData12({ abi: lbRewarderAbi, functionName: "getMasterChef" })]);
+        }
+        const batch3Results = await multicallRead(rpcUrl, batch3Calls);
+        const batch4aCalls = [];
+        for (const { pool } of rewardedPairs) {
+          batch4aCalls.push([pool, encodeFunctionData12({ abi: lbPairAbi, functionName: "getTokenX" })]);
+          batch4aCalls.push([pool, encodeFunctionData12({ abi: lbPairAbi, functionName: "getTokenY" })]);
+        }
+        const batch4aResults = await multicallRead(rpcUrl, batch4aCalls);
+        const tokenXAddresses = [];
+        const tokenYAddresses = [];
+        for (let i = 0; i < rewardedPairs.length; i++) {
+          tokenXAddresses.push(decodeAddressResult(batch4aResults[i * 2] ?? null));
+          tokenYAddresses.push(decodeAddressResult(batch4aResults[i * 2 + 1] ?? null));
+        }
+        const uniqueTokens = Array.from(
+          new Set([...tokenXAddresses, ...tokenYAddresses].filter((a) => a !== null))
+        );
+        const batch4bCalls = uniqueTokens.map((token) => [
+          token,
+          encodeFunctionData12({ abi: erc20Abi2, functionName: "symbol" })
+        ]);
+        const batch4bResults = await multicallRead(rpcUrl, batch4bCalls);
+        const symbolMap = /* @__PURE__ */ new Map();
+        for (let i = 0; i < uniqueTokens.length; i++) {
+          symbolMap.set(uniqueTokens[i], decodeStringResult(batch4bResults[i] ?? null));
+        }
+        const STRIDE3 = 5;
+        const poolData = [];
+        for (let i = 0; i < rewardedPairs.length; i++) {
+          const base = i * STRIDE3;
+          poolData.push({
+            stopped: decodeBoolResult(batch3Results[base] ?? null) ?? false,
+            range: decodeRangeResult(batch3Results[base + 1] ?? null),
+            rewardToken: decodeAddressResult(batch3Results[base + 2] ?? null),
+            pid: Number(decodeUint256Result(batch3Results[base + 3] ?? null) ?? 0n),
+            masterChef: decodeAddressResult(batch3Results[base + 4] ?? null)
+          });
+        }
+        const masterChefAddr = poolData.map((d) => d.masterChef).find((a) => a !== null) ?? null;
+        let moePerDay = 0;
+        let topPoolIds = /* @__PURE__ */ new Set();
+        let totalWeightRaw = 0n;
+        let veMoeAddr = null;
+        if (masterChefAddr) {
+          veMoeAddr = await client.readContract({
+            address: masterChefAddr,
+            abi: masterChefAbi,
+            functionName: "getVeMoe"
+          });
+          const batch5Calls = [
+            [masterChefAddr, encodeFunctionData12({ abi: masterChefAbi, functionName: "getMoePerSecond" })],
+            [masterChefAddr, encodeFunctionData12({ abi: masterChefAbi, functionName: "getTreasuryShare" })],
+            [masterChefAddr, encodeFunctionData12({ abi: masterChefAbi, functionName: "getStaticShare" })],
+            [veMoeAddr, encodeFunctionData12({ abi: veMoeAbi, functionName: "getTotalWeight" })],
+            [veMoeAddr, encodeFunctionData12({ abi: veMoeAbi, functionName: "getTopPoolIds" })]
+          ];
+          const batch5Results = await multicallRead(rpcUrl, batch5Calls);
+          const moePerSecRaw = decodeUint256Result(batch5Results[0] ?? null) ?? 0n;
+          const treasuryShareRaw = decodeUint256Result(batch5Results[1] ?? null) ?? 0n;
+          const staticShareRaw = decodeUint256Result(batch5Results[2] ?? null) ?? 0n;
+          totalWeightRaw = decodeUint256Result(batch5Results[3] ?? null) ?? 0n;
+          const topPoolIdsRaw = decodeUint256ArrayResult(batch5Results[4] ?? null) ?? [];
+          topPoolIds = new Set(topPoolIdsRaw.map(Number));
+          const PRECISION = 10n ** 18n;
+          const netPerSec = moePerSecRaw * (PRECISION - treasuryShareRaw) / PRECISION * (PRECISION - staticShareRaw) / PRECISION;
+          moePerDay = Number(netPerSec * 86400n) / 1e18;
+        }
+        const weightByPid = /* @__PURE__ */ new Map();
+        if (veMoeAddr && rewardedPairs.length > 0) {
+          const batch6Calls = poolData.map((d) => [
+            veMoeAddr,
+            encodeFunctionData12({ abi: veMoeAbi, functionName: "getWeight", args: [BigInt(d.pid)] })
+          ]);
+          const batch6Results = await multicallRead(rpcUrl, batch6Calls);
+          for (let i = 0; i < poolData.length; i++) {
+            weightByPid.set(poolData[i].pid, decodeUint256Result(batch6Results[i] ?? null) ?? 0n);
+          }
+        }
+        let moePriceUsd = 0;
+        let wmntPriceUsd = 0;
+        const MOE_ADDR = "0x4515A45337F461A11Ff0FE8aBF3c606AE5dC00c9";
+        if (this.lbQuoter && this.wmnt && this.usdt) {
+          try {
+            const [moeWmntQuote, wmntUsdtQuote] = await Promise.all([
+              client.readContract({
+                address: this.lbQuoter,
+                abi: lbQuoterAbi2,
+                functionName: "findBestPathFromAmountIn",
+                args: [[MOE_ADDR, this.wmnt], 10n ** 18n]
+              }),
+              client.readContract({
+                address: this.lbQuoter,
+                abi: lbQuoterAbi2,
+                functionName: "findBestPathFromAmountIn",
+                args: [[this.wmnt, this.usdt], 10n ** 18n]
+              })
+            ]);
+            const moeInWmnt = Number(moeWmntQuote.amounts.at(-1) ?? 0n) / 1e18;
+            wmntPriceUsd = Number(wmntUsdtQuote.amounts.at(-1) ?? 0n) / 1e6;
+            moePriceUsd = moeInWmnt * wmntPriceUsd;
+          } catch {
+          }
+        }
+        const binRequests = [];
+        for (let i = 0; i < rewardedPairs.length; i++) {
+          const range = poolData[i].range;
+          if (!range) continue;
+          const minBin = Number(range[0]);
+          const maxBin = Number(range[1]);
+          for (let b = minBin; b <= maxBin; b++) {
+            binRequests.push({ poolIdx: i, binId: b });
+          }
+        }
+        const binReservesX = /* @__PURE__ */ new Map();
+        const binReservesY = /* @__PURE__ */ new Map();
+        if (binRequests.length > 0) {
+          const batch7Calls = binRequests.map(({ poolIdx, binId }) => [
+            rewardedPairs[poolIdx].pool,
+            encodeFunctionData12({ abi: lbPairBinAbi, functionName: "getBin", args: [binId] })
+          ]);
+          const batch7Results = await multicallRead(rpcUrl, batch7Calls);
+          for (let j = 0; j < binRequests.length; j++) {
+            const { poolIdx, binId } = binRequests[j];
+            const decoded = decodeBinResult(batch7Results[j] ?? null);
+            if (!decoded) continue;
+            if (!binReservesX.has(poolIdx)) {
+              binReservesX.set(poolIdx, /* @__PURE__ */ new Map());
+              binReservesY.set(poolIdx, /* @__PURE__ */ new Map());
+            }
+            binReservesX.get(poolIdx).set(binId, decoded[0]);
+            binReservesY.get(poolIdx).set(binId, decoded[1]);
+          }
+        }
+        const stableSymbols = /* @__PURE__ */ new Set(["USDT", "USDC", "MUSD", "AUSD", "USDY", "FDUSD"]);
+        const mntSymbols = /* @__PURE__ */ new Set(["WMNT", "MNT"]);
+        const moeSymbols = /* @__PURE__ */ new Set(["MOE"]);
+        const sixDecimalStables = /* @__PURE__ */ new Set(["USDT", "USDC", "FDUSD"]);
+        const getTokenPriceUsd = (sym) => {
+          if (stableSymbols.has(sym)) return 1;
+          if (mntSymbols.has(sym)) return wmntPriceUsd;
+          if (moeSymbols.has(sym)) return moePriceUsd;
+          return 0;
+        };
+        const getTokenDecimals = (sym) => {
+          return sixDecimalStables.has(sym) ? 6 : 18;
+        };
+        const results = [];
+        for (let i = 0; i < rewardedPairs.length; i++) {
+          const { pool, rewarder } = rewardedPairs[i];
+          const data = poolData[i];
+          const tokenX = tokenXAddresses[i] ?? "0x0000000000000000000000000000000000000000";
+          const tokenY = tokenYAddresses[i] ?? "0x0000000000000000000000000000000000000000";
+          const symX = symbolMap.get(tokenX) ?? "?";
+          const symY = symbolMap.get(tokenY) ?? "?";
+          const isTopPool = topPoolIds.has(data.pid);
+          const weight = weightByPid.get(data.pid) ?? 0n;
+          let poolMoePerDay = 0;
+          if (isTopPool && totalWeightRaw > 0n && weight > 0n) {
+            poolMoePerDay = moePerDay * (Number(weight) / Number(totalWeightRaw));
+          }
+          const rxMap = binReservesX.get(i);
+          const ryMap = binReservesY.get(i);
+          const range = data.range;
+          let rangeTvlUsd = 0;
+          let rewardedBins = 0;
+          if (range) {
+            const minBin = Number(range[0]);
+            const maxBin = Number(range[1]);
+            rewardedBins = maxBin - minBin + 1;
+            if (rxMap && ryMap) {
+              const priceX = getTokenPriceUsd(symX);
+              const priceY = getTokenPriceUsd(symY);
+              const decX = getTokenDecimals(symX);
+              const decY = getTokenDecimals(symY);
+              for (let b = minBin; b <= maxBin; b++) {
+                const rx = rxMap.get(b) ?? 0n;
+                const ry = ryMap.get(b) ?? 0n;
+                rangeTvlUsd += Number(rx) / 10 ** decX * priceX;
+                rangeTvlUsd += Number(ry) / 10 ** decY * priceY;
+              }
+            }
+          }
+          const aprPercent = rangeTvlUsd > 0 && moePriceUsd > 0 ? poolMoePerDay * moePriceUsd * 365 / rangeTvlUsd * 100 : 0;
+          results.push({
+            pool,
+            rewarder,
+            rewardToken: data.rewardToken ?? "0x0000000000000000000000000000000000000000",
+            minBinId: range ? Number(range[0]) : 0,
+            maxBinId: range ? Number(range[1]) : 0,
+            pid: data.pid,
+            stopped: data.stopped,
+            tokenX,
+            tokenY,
+            symbolX: symX,
+            symbolY: symY,
+            isTopPool,
+            moePerDay: poolMoePerDay,
+            rangeTvlUsd,
+            aprPercent,
+            rewardedBins
+          });
+        }
+        return results;
+      }
+      /**
+       * Get a user's LB positions (bin balances) across a range of bin IDs.
+       * If binIds is omitted, auto-detects from the rewarder's rewarded range (or active ± 50).
+       */
+      async getUserPositions(user, pool, binIds) {
+        const rpcUrl = this.requireRpc();
+        const client = createPublicClient8({ transport: http8(rpcUrl) });
+        const resolvedBinIds = binIds && binIds.length > 0 ? binIds : await this.autoDetectBins(pool);
+        const accounts = resolvedBinIds.map(() => user);
+        const ids = resolvedBinIds.map(BigInt);
+        const balances = await client.readContract({
+          address: pool,
+          abi: lbPairAbi,
+          functionName: "balanceOfBatch",
+          args: [accounts, ids]
+        });
+        return resolvedBinIds.map((binId, i) => ({ binId, balance: balances[i] ?? 0n })).filter((p) => p.balance > 0n);
+      }
+    };
+    KITTEN_TOKEN = "0x618275f8efe54c2afa87bfb9f210a52f0ff89364";
+    WHYPE_TOKEN = "0x5555555555555555555555555555555555555555";
+    MAX_NONCE_SCAN = 60;
+    HYPEREVM_TOKENS2 = [
+      "0x5555555555555555555555555555555555555555",
+      // WHYPE
+      "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
+      // USDC
+      "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
+      // USDT0
+      "0xBe6727B535545C67d5cAa73dEa54865B92CF7907",
+      // UETH
+      "0x9FDBdA0A5e284c32744D2f17Ee5c74B284993463",
+      // UBTC
+      "0x111111a1a0667d36bD57c0A9f569b98057111111",
+      // USDH
+      "0x5d3a1Ff2b6BAb83b63cd9AD0787074081a52ef34",
+      // USDe
+      "0x211Cc4DD073734dA055fbF44a2b4667d5E5fE5d2",
+      // sUSDe
+      "0xf4D9235269a96aaDaFc9aDAe454a0618eBE37949",
+      // XAUt0
+      "0xfD739d4e423301CE9385c1fb8850539D657C296D",
+      // kHYPE
+      KITTEN_TOKEN
+      // KITTEN
+    ];
+    farmingCenterAbi = parseAbi13([
+      "function multicall(bytes[] calldata data) external payable returns (bytes[] memory results)",
+      "function enterFarming((address rewardToken, address bonusRewardToken, address pool, uint256 nonce) key, uint256 tokenId) external",
+      "function exitFarming((address rewardToken, address bonusRewardToken, address pool, uint256 nonce) key, uint256 tokenId) external",
+      "function collectRewards((address rewardToken, address bonusRewardToken, address pool, uint256 nonce) key, uint256 tokenId) external",
+      "function claimReward(address rewardToken, address to, uint128 amountRequested) external returns (uint256 reward)"
+    ]);
+    positionManagerAbi2 = parseAbi13([
+      "function approveForFarming(uint256 tokenId, bool approve, address farmingAddress) external",
+      "function farmingApprovals(uint256 tokenId) external view returns (address)"
+    ]);
+    eternalFarmingAbi = parseAbi13([
+      "function incentives(bytes32 incentiveId) external view returns (uint256 totalReward, uint256 bonusReward, address virtualPoolAddress, uint24 minimalPositionWidth, bool deactivated, address pluginAddress)",
+      "function getRewardInfo((address rewardToken, address bonusRewardToken, address pool, uint256 nonce) key, uint256 tokenId) external view returns (uint256 reward, uint256 bonusReward)"
+    ]);
+    algebraFactoryAbi = parseAbi13([
+      "function poolByPair(address tokenA, address tokenB) external view returns (address pool)"
+    ]);
+    _addressDecodeAbi3 = parseAbi13(["function f() external view returns (address)"]);
+    nonceCache = /* @__PURE__ */ new Map();
+    KittenSwapFarmingAdapter = class {
+      protocolName;
+      farmingCenter;
+      eternalFarming;
+      positionManager;
+      rpcUrl;
+      factory;
+      constructor(protocolName, farmingCenter, eternalFarming, positionManager, rpcUrl, factory) {
+        this.protocolName = protocolName;
+        this.farmingCenter = farmingCenter;
+        this.eternalFarming = eternalFarming;
+        this.positionManager = positionManager;
+        this.rpcUrl = rpcUrl;
+        this.factory = factory;
+      }
+      name() {
+        return this.protocolName;
+      }
+      /**
+       * Discover the active IncentiveKey for a given pool.
+       * 1. Check runtime cache
+       * 2. Batch-query nonces 0-60 via single multicall (61 calls)
+       * 3. Return first non-zero incentive (totalReward > 0 and not deactivated)
+       */
+      async discoverIncentiveKey(pool) {
+        const poolLc = pool.toLowerCase();
+        if (nonceCache.has(poolLc)) {
+          return {
+            rewardToken: KITTEN_TOKEN,
+            bonusRewardToken: WHYPE_TOKEN,
+            pool,
+            nonce: nonceCache.get(poolLc)
+          };
+        }
+        const calls = [];
+        const nonces = [];
+        for (let n = 0; n <= MAX_NONCE_SCAN; n++) {
+          const nonce = BigInt(n);
+          nonces.push(nonce);
+          const key = {
+            rewardToken: KITTEN_TOKEN,
+            bonusRewardToken: WHYPE_TOKEN,
+            pool,
+            nonce
+          };
+          calls.push([
+            this.eternalFarming,
+            encodeFunctionData13({
+              abi: eternalFarmingAbi,
+              functionName: "incentives",
+              args: [incentiveId(key)]
+            })
+          ]);
+        }
+        const results = await multicallRead(this.rpcUrl, calls);
+        for (let i = 0; i < results.length; i++) {
+          const data = results[i];
+          if (!data || data.length < 66) continue;
+          try {
+            const decoded = decodeAbiParameters5(
+              [
+                { name: "totalReward", type: "uint256" },
+                { name: "bonusReward", type: "uint256" },
+                { name: "virtualPoolAddress", type: "address" },
+                { name: "minimalPositionWidth", type: "uint24" },
+                { name: "deactivated", type: "bool" },
+                { name: "pluginAddress", type: "address" }
+              ],
+              data
+            );
+            const totalReward = decoded[0];
+            const deactivated = decoded[4];
+            if (totalReward > 0n && !deactivated) {
+              const nonce = nonces[i];
+              nonceCache.set(poolLc, nonce);
+              return {
+                rewardToken: KITTEN_TOKEN,
+                bonusRewardToken: WHYPE_TOKEN,
+                pool,
+                nonce
+              };
+            }
+          } catch {
+          }
+        }
+        return null;
+      }
+      /**
+       * Build approveForFarming tx on the PositionManager.
+       * Required before enterFarming if not already approved.
+       */
+      async buildApproveForFarming(tokenId) {
+        const client = createPublicClient9({ transport: http9(this.rpcUrl) });
+        const currentApproval = await client.readContract({
+          address: this.positionManager,
+          abi: positionManagerAbi2,
+          functionName: "farmingApprovals",
+          args: [tokenId]
+        });
+        if (currentApproval.toLowerCase() === this.farmingCenter.toLowerCase()) {
+          return null;
+        }
+        return {
+          description: `[${this.protocolName}] Approve NFT #${tokenId} for farming`,
+          to: this.positionManager,
+          data: encodeFunctionData13({
+            abi: positionManagerAbi2,
+            functionName: "approveForFarming",
+            args: [tokenId, true, this.farmingCenter]
+          }),
+          value: 0n,
+          gas_estimate: 6e4
+        };
+      }
+      /**
+       * Build enterFarming tx for a position NFT.
+       * Checks farming approval first and returns pre_txs if needed.
+       */
+      async buildEnterFarming(tokenId, pool, _owner) {
+        const key = await this.discoverIncentiveKey(pool);
+        if (!key) {
+          throw new DefiError(
+            "CONTRACT_ERROR",
+            `[${this.protocolName}] No active incentive found for pool ${pool}`
+          );
+        }
+        const approveTx = await this.buildApproveForFarming(tokenId);
+        return {
+          description: `[${this.protocolName}] Enter farming for NFT #${tokenId} in pool ${pool}`,
+          to: this.farmingCenter,
+          data: encodeEnterFarming(key, tokenId),
+          value: 0n,
+          gas_estimate: 4e5,
+          pre_txs: approveTx ? [approveTx] : void 0
+        };
+      }
+      /**
+       * Build a tx that exits farming for a position NFT (unstakes).
+       */
+      async buildExitFarming(tokenId, pool) {
+        const key = await this.discoverIncentiveKey(pool);
+        if (!key) {
+          throw new DefiError(
+            "CONTRACT_ERROR",
+            `[${this.protocolName}] No active incentive found for pool ${pool}`
+          );
+        }
+        return {
+          description: `[${this.protocolName}] Exit farming for NFT #${tokenId} in pool ${pool}`,
+          to: this.farmingCenter,
+          data: encodeExitFarming(key, tokenId),
+          value: 0n,
+          gas_estimate: 3e5
+        };
+      }
+      /**
+       * Build a multicall tx that collects rewards for a staked position and claims them.
+       * Pattern: multicall([collectRewards(key, tokenId), claimReward(KITTEN, owner, max), claimReward(WHYPE, owner, max)])
+       */
+      async buildCollectRewards(tokenId, pool, owner) {
+        const key = await this.discoverIncentiveKey(pool);
+        if (!key) {
+          throw new DefiError(
+            "CONTRACT_ERROR",
+            `[${this.protocolName}] No active incentive found for pool ${pool}`
+          );
+        }
+        const calls = [
+          encodeCollectRewards(key, tokenId),
+          encodeClaimReward(KITTEN_TOKEN, owner),
+          encodeClaimReward(WHYPE_TOKEN, owner)
+        ];
         return {
-          description: `[${this.protocolName}] Claim MOE rewards for farm pid=${pid} (pool ${gauge})`,
-          to: this.masterchef,
-          data,
+          description: `[${this.protocolName}] Collect + claim rewards for NFT #${tokenId} in pool ${pool}`,
+          to: this.farmingCenter,
+          data: encodeMulticall(calls),
           value: 0n,
-          gas_estimate: 2e5
+          gas_estimate: 4e5
         };
       }
-      /** Claim pending MOE rewards for a specific pid (MasterChef extension beyond IGauge). */
-      async buildClaimRewardsPid(pid) {
-        const data = encodeFunctionData9({
-          abi: masterchefAbi,
-          functionName: "claim",
-          args: [[pid]]
-        });
+      /**
+       * Build a tx that only claims already-accumulated rewards (no position change needed).
+       */
+      async buildClaimReward(owner) {
+        const calls = [
+          encodeClaimReward(KITTEN_TOKEN, owner),
+          encodeClaimReward(WHYPE_TOKEN, owner)
+        ];
         return {
-          description: `[${this.protocolName}] Claim MOE rewards for farm pid=${pid}`,
-          to: this.masterchef,
-          data,
+          description: `[${this.protocolName}] Claim KITTEN + WHYPE farming rewards to ${owner}`,
+          to: this.farmingCenter,
+          data: encodeMulticall(calls),
           value: 0n,
           gas_estimate: 2e5
         };
       }
-      /** Get pending MOE rewards for a user. Requires rpcUrl. */
-      async getPendingRewards(_gauge, user) {
-        if (!this.rpcUrl) {
-          throw DefiError.unsupported(`[${this.protocolName}] getPendingRewards requires RPC`);
+      /**
+       * Query pending rewards for a staked position NFT.
+       */
+      async getPendingRewards(tokenId, pool) {
+        const key = await this.discoverIncentiveKey(pool);
+        if (!key) {
+          return { reward: 0n, bonusReward: 0n };
         }
-        const client = createPublicClient6({ transport: http6(this.rpcUrl) });
-        const rewards = await client.readContract({
-          address: this.masterchef,
-          abi: masterchefAbi,
-          functionName: "pendingRewards",
-          args: [user, [0n]]
+        const client = createPublicClient9({ transport: http9(this.rpcUrl) });
+        const result = await client.readContract({
+          address: this.eternalFarming,
+          abi: eternalFarmingAbi,
+          functionName: "getRewardInfo",
+          args: [key, tokenId]
         });
-        return rewards.map((amount) => ({
-          token: this.masterchef,
-          symbol: "MOE",
-          amount
-        }));
+        return { reward: result[0], bonusReward: result[1] };
+      }
+      /**
+       * Discover all KittenSwap pools with active farming incentives.
+       *
+       * Steps:
+       * 1. Generate all unique token pair combos from HYPEREVM_TOKENS (includes KITTEN)
+       * 2. Batch poolByPair calls via multicall against the Algebra factory
+       * 3. For each found pool, batch-scan nonces 0-60 via multicall
+       * 4. Return enriched FarmingPool[] for pools with active incentives
+       */
+      async discoverFarmingPools() {
+        if (!this.factory) {
+          return [];
+        }
+        const pairs = [];
+        for (let i = 0; i < HYPEREVM_TOKENS2.length; i++) {
+          for (let j = i + 1; j < HYPEREVM_TOKENS2.length; j++) {
+            pairs.push([HYPEREVM_TOKENS2[i], HYPEREVM_TOKENS2[j]]);
+          }
+        }
+        const poolByPairCalls = pairs.map(([tokenA, tokenB]) => [
+          this.factory,
+          encodeFunctionData13({
+            abi: algebraFactoryAbi,
+            functionName: "poolByPair",
+            args: [tokenA, tokenB]
+          })
+        ]);
+        const poolResults = await multicallRead(this.rpcUrl, poolByPairCalls);
+        const poolSet = /* @__PURE__ */ new Set();
+        for (const data of poolResults) {
+          const addr = decodeAddress3(data);
+          if (addr && addr !== zeroAddress7) {
+            poolSet.add(addr.toLowerCase());
+          }
+        }
+        if (poolSet.size === 0) return [];
+        const pools = Array.from(poolSet);
+        const NONCE_COUNT = MAX_NONCE_SCAN + 1;
+        const allNonceCalls = [];
+        for (const pool of pools) {
+          for (let n = 0; n <= MAX_NONCE_SCAN; n++) {
+            const key = {
+              rewardToken: KITTEN_TOKEN,
+              bonusRewardToken: WHYPE_TOKEN,
+              pool,
+              nonce: BigInt(n)
+            };
+            allNonceCalls.push([
+              this.eternalFarming,
+              encodeFunctionData13({
+                abi: eternalFarmingAbi,
+                functionName: "incentives",
+                args: [incentiveId(key)]
+              })
+            ]);
+          }
+        }
+        const allNonceResults = await multicallRead(this.rpcUrl, allNonceCalls);
+        const results = [];
+        for (let pi = 0; pi < pools.length; pi++) {
+          const pool = pools[pi];
+          const poolLc = pool.toLowerCase();
+          const base = pi * NONCE_COUNT;
+          let bestKey = null;
+          let bestTotalReward = 0n;
+          let bestBonusReward = 0n;
+          let bestActive = false;
+          for (let n = 0; n <= MAX_NONCE_SCAN; n++) {
+            const data = allNonceResults[base + n];
+            if (!data || data.length < 66) continue;
+            try {
+              const decoded = decodeAbiParameters5(
+                [
+                  { name: "totalReward", type: "uint256" },
+                  { name: "bonusReward", type: "uint256" },
+                  { name: "virtualPoolAddress", type: "address" },
+                  { name: "minimalPositionWidth", type: "uint24" },
+                  { name: "deactivated", type: "bool" },
+                  { name: "pluginAddress", type: "address" }
+                ],
+                data
+              );
+              const totalReward = decoded[0];
+              const bonusReward = decoded[1];
+              const deactivated = decoded[4];
+              if (totalReward > 0n) {
+                const nonce = BigInt(n);
+                const isActive = !deactivated;
+                if (!bestKey || isActive && !bestActive || isActive === bestActive && nonce > bestKey.nonce) {
+                  bestKey = {
+                    rewardToken: KITTEN_TOKEN,
+                    bonusRewardToken: WHYPE_TOKEN,
+                    pool,
+                    nonce
+                  };
+                  bestTotalReward = totalReward;
+                  bestBonusReward = bonusReward;
+                  bestActive = isActive;
+                }
+              }
+            } catch {
+            }
+          }
+          if (bestKey) {
+            nonceCache.set(poolLc, bestKey.nonce);
+            results.push({
+              pool,
+              key: bestKey,
+              totalReward: bestTotalReward,
+              bonusReward: bestBonusReward,
+              active: bestActive
+            });
+          }
+        }
+        return results;
       }
     };
-    POOL_ABI = parseAbi10([
+    POOL_ABI = parseAbi14([
       "function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external",
       "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)",
@@ -2828,27 +4992,27 @@ var init_dist3 = __esm({
       "function getUserAccountData(address user) external view returns (uint256 totalCollateralBase, uint256 totalDebtBase, uint256 availableBorrowsBase, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor)",
       "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)"
     ]);
-    ERC20_ABI = parseAbi10([
+    ERC20_ABI = parseAbi14([
       "function totalSupply() external view returns (uint256)"
     ]);
-    INCENTIVES_ABI = parseAbi10([
+    INCENTIVES_ABI = parseAbi14([
       "function getIncentivesController() external view returns (address)"
     ]);
-    REWARDS_CONTROLLER_ABI = parseAbi10([
+    REWARDS_CONTROLLER_ABI = parseAbi14([
       "function getRewardsByAsset(address asset) external view returns (address[])",
       "function getRewardsData(address asset, address reward) external view returns (uint256 index, uint256 emissionsPerSecond, uint256 lastUpdateTimestamp, uint256 distributionEnd)"
     ]);
-    POOL_PROVIDER_ABI = parseAbi10([
+    POOL_PROVIDER_ABI = parseAbi14([
       "function ADDRESSES_PROVIDER() external view returns (address)"
     ]);
-    ADDRESSES_PROVIDER_ABI = parseAbi10([
+    ADDRESSES_PROVIDER_ABI = parseAbi14([
       "function getPriceOracle() external view returns (address)"
     ]);
-    ORACLE_ABI = parseAbi10([
+    ORACLE_ABI = parseAbi14([
       "function getAssetPrice(address asset) external view returns (uint256)",
       "function BASE_CURRENCY_UNIT() external view returns (uint256)"
     ]);
-    ERC20_DECIMALS_ABI = parseAbi10([
+    ERC20_DECIMALS_ABI = parseAbi14([
       "function decimals() external view returns (uint8)"
     ]);
     AaveV3Adapter = class {
@@ -2866,7 +5030,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildSupply(params) {
-        const data = encodeFunctionData10({
+        const data = encodeFunctionData14({
           abi: POOL_ABI,
           functionName: "supply",
           args: [params.asset, params.amount, params.on_behalf_of, 0]
@@ -2882,7 +5046,7 @@ var init_dist3 = __esm({
       }
       async buildBorrow(params) {
         const rateMode = params.interest_rate_mode === InterestRateMode.Stable ? 1n : 2n;
-        const data = encodeFunctionData10({
+        const data = encodeFunctionData14({
           abi: POOL_ABI,
           functionName: "borrow",
           args: [params.asset, params.amount, rateMode, 0, params.on_behalf_of]
@@ -2897,7 +5061,7 @@ var init_dist3 = __esm({
       }
       async buildRepay(params) {
         const rateMode = params.interest_rate_mode === InterestRateMode.Stable ? 1n : 2n;
-        const data = encodeFunctionData10({
+        const data = encodeFunctionData14({
           abi: POOL_ABI,
           functionName: "repay",
           args: [params.asset, params.amount, rateMode, params.on_behalf_of]
@@ -2912,7 +5076,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(params) {
-        const data = encodeFunctionData10({
+        const data = encodeFunctionData14({
           abi: POOL_ABI,
           functionName: "withdraw",
           args: [params.asset, params.amount, params.to]
@@ -2927,15 +5091,21 @@ var init_dist3 = __esm({
       }
       async getRates(asset) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient7({ transport: http7(this.rpcUrl) });
-        const result = await client.readContract({
-          address: this.pool,
+        const reserveCallData = encodeFunctionData14({
           abi: POOL_ABI,
           functionName: "getReserveData",
           args: [asset]
-        }).catch((e) => {
+        });
+        const [reserveRaw] = await multicallRead(this.rpcUrl, [
+          [this.pool, reserveCallData]
+        ]).catch((e) => {
           throw DefiError.rpcError(`[${this.protocolName}] getReserveData failed: ${e}`);
         });
+        const reserveDecoded = decodeReserveData(reserveRaw ?? null);
+        if (!reserveDecoded) {
+          throw DefiError.rpcError(`[${this.protocolName}] getReserveData returned no data`);
+        }
+        const result = reserveDecoded;
         const RAY = 1e27;
         const SECONDS_PER_YEAR4 = 31536e3;
         const toApy = (rayRate) => {
@@ -2947,74 +5117,56 @@ var init_dist3 = __esm({
         const stableRate = toApy(result[5]);
         const aTokenAddress = result[8];
         const variableDebtTokenAddress = result[10];
-        const [totalSupply, totalBorrow] = await Promise.all([
-          client.readContract({
-            address: aTokenAddress,
-            abi: ERC20_ABI,
-            functionName: "totalSupply"
-          }).catch(() => 0n),
-          client.readContract({
-            address: variableDebtTokenAddress,
-            abi: ERC20_ABI,
-            functionName: "totalSupply"
-          }).catch(() => 0n)
+        const [supplyRaw, borrowRaw] = await multicallRead(this.rpcUrl, [
+          [aTokenAddress, encodeFunctionData14({ abi: ERC20_ABI, functionName: "totalSupply" })],
+          [variableDebtTokenAddress, encodeFunctionData14({ abi: ERC20_ABI, functionName: "totalSupply" })]
         ]);
+        const totalSupply = decodeU256(supplyRaw ?? null);
+        const totalBorrow = decodeU256(borrowRaw ?? null);
         const utilization = totalSupply > 0n ? Number(totalBorrow * 10000n / totalSupply) / 100 : 0;
         const supplyRewardTokens = [];
         const borrowRewardTokens = [];
         const supplyEmissions = [];
         const borrowEmissions = [];
         try {
-          const controllerAddr = await client.readContract({
-            address: aTokenAddress,
-            abi: INCENTIVES_ABI,
-            functionName: "getIncentivesController"
-          });
-          if (controllerAddr && controllerAddr !== zeroAddress5) {
-            const [supplyRewards, borrowRewards] = await Promise.all([
-              client.readContract({
-                address: controllerAddr,
-                abi: REWARDS_CONTROLLER_ABI,
-                functionName: "getRewardsByAsset",
-                args: [aTokenAddress]
-              }).catch(() => []),
-              client.readContract({
-                address: controllerAddr,
-                abi: REWARDS_CONTROLLER_ABI,
-                functionName: "getRewardsByAsset",
-                args: [variableDebtTokenAddress]
-              }).catch(() => [])
+          const [controllerRaw] = await multicallRead(this.rpcUrl, [
+            [aTokenAddress, encodeFunctionData14({ abi: INCENTIVES_ABI, functionName: "getIncentivesController" })]
+          ]);
+          const controllerAddr = decodeAddress4(controllerRaw ?? null);
+          if (controllerAddr && controllerAddr !== zeroAddress8) {
+            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] })]
             ]);
-            const supplyDataPromises = supplyRewards.map(
-              (reward) => client.readContract({
-                address: controllerAddr,
-                abi: REWARDS_CONTROLLER_ABI,
-                functionName: "getRewardsData",
-                args: [aTokenAddress, reward]
-              }).catch(() => null)
-            );
-            const supplyData = await Promise.all(supplyDataPromises);
-            for (let i = 0; i < supplyRewards.length; i++) {
-              const data = supplyData[i];
-              if (data && data[1] > 0n) {
-                supplyRewardTokens.push(supplyRewards[i]);
-                supplyEmissions.push(data[1].toString());
+            const supplyRewards = decodeAddressArray(supplyRewardsRaw ?? null);
+            const borrowRewards = decodeAddressArray(borrowRewardsRaw ?? null);
+            const rewardsDataCalls = [
+              ...supplyRewards.map((reward) => [
+                controllerAddr,
+                encodeFunctionData14({ abi: REWARDS_CONTROLLER_ABI, functionName: "getRewardsData", args: [aTokenAddress, reward] })
+              ]),
+              ...borrowRewards.map((reward) => [
+                controllerAddr,
+                encodeFunctionData14({ abi: REWARDS_CONTROLLER_ABI, functionName: "getRewardsData", args: [variableDebtTokenAddress, reward] })
+              ])
+            ];
+            if (rewardsDataCalls.length > 0) {
+              const rewardsDataResults = await multicallRead(this.rpcUrl, rewardsDataCalls);
+              const supplyDataResults = rewardsDataResults.slice(0, supplyRewards.length);
+              const borrowDataResults = rewardsDataResults.slice(supplyRewards.length);
+              for (let i = 0; i < supplyRewards.length; i++) {
+                const data = decodeRewardsData(supplyDataResults[i] ?? null);
+                if (data && data[1] > 0n) {
+                  supplyRewardTokens.push(supplyRewards[i]);
+                  supplyEmissions.push(data[1].toString());
+                }
               }
-            }
-            const borrowDataPromises = borrowRewards.map(
-              (reward) => client.readContract({
-                address: controllerAddr,
-                abi: REWARDS_CONTROLLER_ABI,
-                functionName: "getRewardsData",
-                args: [variableDebtTokenAddress, reward]
-              }).catch(() => null)
-            );
-            const borrowData = await Promise.all(borrowDataPromises);
-            for (let i = 0; i < borrowRewards.length; i++) {
-              const data = borrowData[i];
-              if (data && data[1] > 0n) {
-                borrowRewardTokens.push(borrowRewards[i]);
-                borrowEmissions.push(data[1].toString());
+              for (let i = 0; i < borrowRewards.length; i++) {
+                const data = decodeRewardsData(borrowDataResults[i] ?? null);
+                if (data && data[1] > 0n) {
+                  borrowRewardTokens.push(borrowRewards[i]);
+                  borrowEmissions.push(data[1].toString());
+                }
               }
             }
           }
@@ -3026,55 +5178,49 @@ var init_dist3 = __esm({
         const hasBorrowRewards = borrowRewardTokens.length > 0;
         if ((hasSupplyRewards || hasBorrowRewards) && totalSupply > 0n) {
           try {
-            const providerAddr = await client.readContract({
-              address: this.pool,
-              abi: POOL_PROVIDER_ABI,
-              functionName: "ADDRESSES_PROVIDER"
-            });
-            const oracleAddr = await client.readContract({
-              address: providerAddr,
-              abi: ADDRESSES_PROVIDER_ABI,
-              functionName: "getPriceOracle"
-            });
-            const [assetPrice, baseCurrencyUnit, assetDecimals] = await Promise.all([
-              client.readContract({
-                address: oracleAddr,
-                abi: ORACLE_ABI,
-                functionName: "getAssetPrice",
-                args: [asset]
-              }),
-              client.readContract({
-                address: oracleAddr,
-                abi: ORACLE_ABI,
-                functionName: "BASE_CURRENCY_UNIT"
-              }),
-              client.readContract({
-                address: asset,
-                abi: ERC20_DECIMALS_ABI,
-                functionName: "decimals"
-              }).catch(() => 18)
+            const [providerRaw] = await multicallRead(this.rpcUrl, [
+              [this.pool, encodeFunctionData14({ abi: POOL_PROVIDER_ABI, functionName: "ADDRESSES_PROVIDER" })]
+            ]);
+            const providerAddr = decodeAddress4(providerRaw ?? null);
+            if (!providerAddr) throw new Error("No provider address");
+            const [oracleRaw] = await multicallRead(this.rpcUrl, [
+              [providerAddr, encodeFunctionData14({ abi: ADDRESSES_PROVIDER_ABI, functionName: "getPriceOracle" })]
+            ]);
+            const oracleAddr = decodeAddress4(oracleRaw ?? null);
+            if (!oracleAddr) throw new Error("No oracle address");
+            const [assetPriceRaw, baseCurrencyUnitRaw, assetDecimalsRaw] = await multicallRead(this.rpcUrl, [
+              [oracleAddr, encodeFunctionData14({ abi: ORACLE_ABI, functionName: "getAssetPrice", args: [asset] })],
+              [oracleAddr, encodeFunctionData14({ abi: ORACLE_ABI, functionName: "BASE_CURRENCY_UNIT" })],
+              [asset, encodeFunctionData14({ abi: ERC20_DECIMALS_ABI, functionName: "decimals" })]
             ]);
-            const priceUnit = Number(baseCurrencyUnit);
+            const assetPrice = decodeU256(assetPriceRaw ?? null);
+            const baseCurrencyUnit = decodeU256(baseCurrencyUnitRaw ?? null);
+            const assetDecimals = assetDecimalsRaw ? Number(decodeU256(assetDecimalsRaw)) : 18;
+            const priceUnit = Number(baseCurrencyUnit) || 1e8;
             const assetPriceF = Number(assetPrice) / priceUnit;
             const assetDecimalsDivisor = 10 ** assetDecimals;
+            const allRewardTokens = Array.from(/* @__PURE__ */ new Set([...supplyRewardTokens, ...borrowRewardTokens]));
+            const rewardPriceCalls = allRewardTokens.flatMap((token) => [
+              [oracleAddr, encodeFunctionData14({ abi: ORACLE_ABI, functionName: "getAssetPrice", args: [token] })],
+              [token, encodeFunctionData14({ abi: ERC20_DECIMALS_ABI, functionName: "decimals" })]
+            ]);
+            const rewardPriceResults = rewardPriceCalls.length > 0 ? await multicallRead(this.rpcUrl, rewardPriceCalls) : [];
+            const rewardPriceMap = /* @__PURE__ */ new Map();
+            for (let i = 0; i < allRewardTokens.length; i++) {
+              const priceRaw = rewardPriceResults[i * 2] ?? null;
+              const decimalsRaw = rewardPriceResults[i * 2 + 1] ?? null;
+              const price = decodeU256(priceRaw);
+              const decimals = decimalsRaw ? Number(decodeU256(decimalsRaw)) : 18;
+              rewardPriceMap.set(allRewardTokens[i].toLowerCase(), { price, decimals });
+            }
             if (hasSupplyRewards) {
               let totalSupplyIncentiveUsdPerYear = 0;
               const totalSupplyUsd = Number(totalSupply) / assetDecimalsDivisor * assetPriceF;
               for (let i = 0; i < supplyRewardTokens.length; i++) {
                 const emissionPerSec = BigInt(supplyEmissions[i]);
-                const [rewardPrice, rewardDecimals] = await Promise.all([
-                  client.readContract({
-                    address: oracleAddr,
-                    abi: ORACLE_ABI,
-                    functionName: "getAssetPrice",
-                    args: [supplyRewardTokens[i]]
-                  }).catch(() => 0n),
-                  client.readContract({
-                    address: supplyRewardTokens[i],
-                    abi: ERC20_DECIMALS_ABI,
-                    functionName: "decimals"
-                  }).catch(() => 18)
-                ]);
+                const entry = rewardPriceMap.get(supplyRewardTokens[i].toLowerCase());
+                const rewardPrice = entry?.price ?? 0n;
+                const rewardDecimals = entry?.decimals ?? 18;
                 if (rewardPrice > 0n) {
                   const rewardPriceF = Number(rewardPrice) / priceUnit;
                   const emissionPerYear = Number(emissionPerSec) / 10 ** rewardDecimals * SECONDS_PER_YEAR4;
@@ -3090,19 +5236,9 @@ var init_dist3 = __esm({
               const totalBorrowUsd = Number(totalBorrow) / assetDecimalsDivisor * assetPriceF;
               for (let i = 0; i < borrowRewardTokens.length; i++) {
                 const emissionPerSec = BigInt(borrowEmissions[i]);
-                const [rewardPrice, rewardDecimals] = await Promise.all([
-                  client.readContract({
-                    address: oracleAddr,
-                    abi: ORACLE_ABI,
-                    functionName: "getAssetPrice",
-                    args: [borrowRewardTokens[i]]
-                  }).catch(() => 0n),
-                  client.readContract({
-                    address: borrowRewardTokens[i],
-                    abi: ERC20_DECIMALS_ABI,
-                    functionName: "decimals"
-                  }).catch(() => 18)
-                ]);
+                const entry = rewardPriceMap.get(borrowRewardTokens[i].toLowerCase());
+                const rewardPrice = entry?.price ?? 0n;
+                const rewardDecimals = entry?.decimals ?? 18;
                 if (rewardPrice > 0n) {
                   const rewardPriceF = Number(rewardPrice) / priceUnit;
                   const emissionPerYear = Number(emissionPerSec) / 10 ** rewardDecimals * SECONDS_PER_YEAR4;
@@ -3139,7 +5275,7 @@ var init_dist3 = __esm({
       }
       async getUserPosition(user) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient7({ transport: http7(this.rpcUrl) });
+        const client = createPublicClient10({ transport: http10(this.rpcUrl) });
         const result = await client.readContract({
           address: this.pool,
           abi: POOL_ABI,
@@ -3154,8 +5290,8 @@ var init_dist3 = __esm({
         const collateralUsd = u256ToF64(totalCollateralBase) / 1e8;
         const debtUsd = u256ToF64(totalDebtBase) / 1e8;
         const ltvBps = u256ToF64(ltv);
-        const supplies = collateralUsd > 0 ? [{ asset: zeroAddress5, symbol: "Total Collateral", amount: totalCollateralBase, value_usd: collateralUsd }] : [];
-        const borrows = debtUsd > 0 ? [{ asset: zeroAddress5, 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,
@@ -3166,7 +5302,7 @@ var init_dist3 = __esm({
         };
       }
     };
-    POOL_ABI2 = parseAbi11([
+    POOL_ABI2 = parseAbi15([
       "function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external",
       "function borrow(address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf) external",
       "function repay(address asset, uint256 amount, uint256 rateMode, address onBehalfOf) external returns (uint256)",
@@ -3179,7 +5315,7 @@ var init_dist3 = __esm({
       //            [9]=variableDebtTokenAddress, [10]=interestRateStrategyAddress, [11]=id
       "function getReserveData(address asset) external view returns (uint256 configuration, uint128 liquidityIndex, uint128 variableBorrowIndex, uint128 currentLiquidityRate, uint128 currentVariableBorrowRate, uint128 currentStableBorrowRate, uint40 lastUpdateTimestamp, address aTokenAddress, address stableDebtTokenAddress, address variableDebtTokenAddress, address interestRateStrategyAddress, uint8 id)"
     ]);
-    ERC20_ABI2 = parseAbi11([
+    ERC20_ABI2 = parseAbi15([
       "function totalSupply() external view returns (uint256)"
     ]);
     AaveV2Adapter = class {
@@ -3197,7 +5333,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildSupply(params) {
-        const data = encodeFunctionData11({
+        const data = encodeFunctionData15({
           abi: POOL_ABI2,
           functionName: "deposit",
           args: [params.asset, params.amount, params.on_behalf_of, 0]
@@ -3213,7 +5349,7 @@ var init_dist3 = __esm({
       }
       async buildBorrow(params) {
         const rateMode = params.interest_rate_mode === InterestRateMode.Stable ? 1n : 2n;
-        const data = encodeFunctionData11({
+        const data = encodeFunctionData15({
           abi: POOL_ABI2,
           functionName: "borrow",
           args: [params.asset, params.amount, rateMode, 0, params.on_behalf_of]
@@ -3228,7 +5364,7 @@ var init_dist3 = __esm({
       }
       async buildRepay(params) {
         const rateMode = params.interest_rate_mode === InterestRateMode.Stable ? 1n : 2n;
-        const data = encodeFunctionData11({
+        const data = encodeFunctionData15({
           abi: POOL_ABI2,
           functionName: "repay",
           args: [params.asset, params.amount, rateMode, params.on_behalf_of]
@@ -3243,7 +5379,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(params) {
-        const data = encodeFunctionData11({
+        const data = encodeFunctionData15({
           abi: POOL_ABI2,
           functionName: "withdraw",
           args: [params.asset, params.amount, params.to]
@@ -3258,7 +5394,7 @@ var init_dist3 = __esm({
       }
       async getRates(asset) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient8({ transport: http8(this.rpcUrl) });
+        const client = createPublicClient11({ transport: http11(this.rpcUrl) });
         const result = await client.readContract({
           address: this.pool,
           abi: POOL_ABI2,
@@ -3304,7 +5440,7 @@ var init_dist3 = __esm({
       }
       async getUserPosition(user) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient8({ transport: http8(this.rpcUrl) });
+        const client = createPublicClient11({ transport: http11(this.rpcUrl) });
         const result = await client.readContract({
           address: this.pool,
           abi: POOL_ABI2,
@@ -3319,8 +5455,8 @@ var init_dist3 = __esm({
         const collateralUsd = u256ToF642(totalCollateralBase) / 1e18;
         const debtUsd = u256ToF642(totalDebtBase) / 1e18;
         const ltvBps = u256ToF642(ltv);
-        const supplies = collateralUsd > 0 ? [{ asset: zeroAddress6, symbol: "Total Collateral", amount: totalCollateralBase, value_usd: collateralUsd }] : [];
-        const borrows = debtUsd > 0 ? [{ asset: zeroAddress6, symbol: "Total Debt", amount: totalDebtBase, value_usd: debtUsd }] : [];
+        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 }] : [];
         return {
           protocol: this.protocolName,
           user,
@@ -3331,7 +5467,7 @@ var init_dist3 = __esm({
         };
       }
     };
-    ORACLE_ABI2 = parseAbi12([
+    ORACLE_ABI2 = parseAbi16([
       "function getAssetPrice(address asset) external view returns (uint256)",
       "function getAssetsPrices(address[] calldata assets) external view returns (uint256[] memory)",
       "function BASE_CURRENCY_UNIT() external view returns (uint256)"
@@ -3352,7 +5488,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async getPrice(asset) {
-        const client = createPublicClient9({ transport: http9(this.rpcUrl) });
+        const client = createPublicClient12({ transport: http12(this.rpcUrl) });
         const baseUnit = await client.readContract({
           address: this.oracle,
           abi: ORACLE_ABI2,
@@ -3379,7 +5515,7 @@ var init_dist3 = __esm({
         };
       }
       async getPrices(assets) {
-        const client = createPublicClient9({ transport: http9(this.rpcUrl) });
+        const client = createPublicClient12({ transport: http12(this.rpcUrl) });
         const baseUnit = await client.readContract({
           address: this.oracle,
           abi: ORACLE_ABI2,
@@ -3408,7 +5544,7 @@ var init_dist3 = __esm({
         });
       }
     };
-    CTOKEN_ABI = parseAbi13([
+    CTOKEN_ABI = parseAbi17([
       "function supplyRatePerBlock() external view returns (uint256)",
       "function borrowRatePerBlock() external view returns (uint256)",
       "function totalSupply() external view returns (uint256)",
@@ -3435,7 +5571,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildSupply(params) {
-        const data = encodeFunctionData12({
+        const data = encodeFunctionData16({
           abi: CTOKEN_ABI,
           functionName: "mint",
           args: [params.amount]
@@ -3449,7 +5585,7 @@ var init_dist3 = __esm({
         };
       }
       async buildBorrow(params) {
-        const data = encodeFunctionData12({
+        const data = encodeFunctionData16({
           abi: CTOKEN_ABI,
           functionName: "borrow",
           args: [params.amount]
@@ -3463,7 +5599,7 @@ var init_dist3 = __esm({
         };
       }
       async buildRepay(params) {
-        const data = encodeFunctionData12({
+        const data = encodeFunctionData16({
           abi: CTOKEN_ABI,
           functionName: "repayBorrow",
           args: [params.amount]
@@ -3477,7 +5613,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(params) {
-        const data = encodeFunctionData12({
+        const data = encodeFunctionData16({
           abi: CTOKEN_ABI,
           functionName: "redeem",
           args: [params.amount]
@@ -3492,7 +5628,7 @@ var init_dist3 = __esm({
       }
       async getRates(asset) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient10({ transport: http10(this.rpcUrl) });
+        const client = createPublicClient13({ transport: http13(this.rpcUrl) });
         const [supplyRate, borrowRate, totalSupply, totalBorrows] = await Promise.all([
           client.readContract({ address: this.defaultVtoken, abi: CTOKEN_ABI, functionName: "supplyRatePerBlock" }).catch((e) => {
             throw DefiError.rpcError(`[${this.protocolName}] supplyRatePerBlock failed: ${e}`);
@@ -3526,7 +5662,7 @@ var init_dist3 = __esm({
         );
       }
     };
-    COMET_ABI = parseAbi14([
+    COMET_ABI = parseAbi18([
       "function getUtilization() external view returns (uint256)",
       "function getSupplyRate(uint256 utilization) external view returns (uint64)",
       "function getBorrowRate(uint256 utilization) external view returns (uint64)",
@@ -3552,7 +5688,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildSupply(params) {
-        const data = encodeFunctionData13({
+        const data = encodeFunctionData17({
           abi: COMET_ABI,
           functionName: "supply",
           args: [params.asset, params.amount]
@@ -3566,7 +5702,7 @@ var init_dist3 = __esm({
         };
       }
       async buildBorrow(params) {
-        const data = encodeFunctionData13({
+        const data = encodeFunctionData17({
           abi: COMET_ABI,
           functionName: "withdraw",
           args: [params.asset, params.amount]
@@ -3580,7 +5716,7 @@ var init_dist3 = __esm({
         };
       }
       async buildRepay(params) {
-        const data = encodeFunctionData13({
+        const data = encodeFunctionData17({
           abi: COMET_ABI,
           functionName: "supply",
           args: [params.asset, params.amount]
@@ -3594,7 +5730,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(params) {
-        const data = encodeFunctionData13({
+        const data = encodeFunctionData17({
           abi: COMET_ABI,
           functionName: "withdraw",
           args: [params.asset, params.amount]
@@ -3609,7 +5745,7 @@ var init_dist3 = __esm({
       }
       async getRates(asset) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient11({ transport: http11(this.rpcUrl) });
+        const client = createPublicClient14({ transport: http14(this.rpcUrl) });
         const utilization = await client.readContract({
           address: this.comet,
           abi: COMET_ABI,
@@ -3648,7 +5784,7 @@ var init_dist3 = __esm({
         );
       }
     };
-    EULER_VAULT_ABI = parseAbi15([
+    EULER_VAULT_ABI = parseAbi19([
       "function deposit(uint256 amount, address receiver) external returns (uint256)",
       "function withdraw(uint256 amount, address receiver, address owner) external returns (uint256)",
       "function borrow(uint256 amount, address receiver) external returns (uint256)",
@@ -3674,7 +5810,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildSupply(params) {
-        const data = encodeFunctionData14({
+        const data = encodeFunctionData18({
           abi: EULER_VAULT_ABI,
           functionName: "deposit",
           args: [params.amount, params.on_behalf_of]
@@ -3688,7 +5824,7 @@ var init_dist3 = __esm({
         };
       }
       async buildBorrow(params) {
-        const data = encodeFunctionData14({
+        const data = encodeFunctionData18({
           abi: EULER_VAULT_ABI,
           functionName: "borrow",
           args: [params.amount, params.on_behalf_of]
@@ -3702,7 +5838,7 @@ var init_dist3 = __esm({
         };
       }
       async buildRepay(params) {
-        const data = encodeFunctionData14({
+        const data = encodeFunctionData18({
           abi: EULER_VAULT_ABI,
           functionName: "repay",
           args: [params.amount, params.on_behalf_of]
@@ -3716,7 +5852,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(params) {
-        const data = encodeFunctionData14({
+        const data = encodeFunctionData18({
           abi: EULER_VAULT_ABI,
           functionName: "withdraw",
           args: [params.amount, params.to, params.to]
@@ -3731,7 +5867,7 @@ var init_dist3 = __esm({
       }
       async getRates(asset) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient12({ transport: http12(this.rpcUrl) });
+        const client = createPublicClient15({ transport: http15(this.rpcUrl) });
         const [totalSupply, totalBorrows, interestRate] = await Promise.all([
           client.readContract({ address: this.euler, abi: EULER_VAULT_ABI, functionName: "totalSupply" }).catch((e) => {
             throw DefiError.rpcError(`[${this.protocolName}] totalSupply failed: ${e}`);
@@ -3765,7 +5901,7 @@ var init_dist3 = __esm({
         );
       }
     };
-    MORPHO_ABI = parseAbi16([
+    MORPHO_ABI = parseAbi20([
       "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)",
@@ -3773,13 +5909,13 @@ var init_dist3 = __esm({
       "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)"
     ]);
-    META_MORPHO_ABI = parseAbi16([
+    META_MORPHO_ABI = parseAbi20([
       "function supplyQueueLength() external view returns (uint256)",
       "function supplyQueue(uint256 index) external view returns (bytes32)",
       "function totalAssets() external view returns (uint256)",
       "function totalSupply() external view returns (uint256)"
     ]);
-    IRM_ABI = parseAbi16([
+    IRM_ABI = parseAbi20([
       "function borrowRateView((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, (uint128 totalSupplyAssets, uint128 totalSupplyShares, uint128 totalBorrowAssets, uint128 totalBorrowShares, uint128 lastUpdate, uint128 fee) market) external view returns (uint256)"
     ]);
     SECONDS_PER_YEAR3 = 365.25 * 24 * 3600;
@@ -3802,7 +5938,7 @@ var init_dist3 = __esm({
       }
       async buildSupply(params) {
         const market = defaultMarketParams(params.asset);
-        const data = encodeFunctionData15({
+        const data = encodeFunctionData19({
           abi: MORPHO_ABI,
           functionName: "supply",
           args: [market, params.amount, 0n, params.on_behalf_of, "0x"]
@@ -3817,7 +5953,7 @@ var init_dist3 = __esm({
       }
       async buildBorrow(params) {
         const market = defaultMarketParams(params.asset);
-        const data = encodeFunctionData15({
+        const data = encodeFunctionData19({
           abi: MORPHO_ABI,
           functionName: "borrow",
           args: [market, params.amount, 0n, params.on_behalf_of, params.on_behalf_of]
@@ -3832,7 +5968,7 @@ var init_dist3 = __esm({
       }
       async buildRepay(params) {
         const market = defaultMarketParams(params.asset);
-        const data = encodeFunctionData15({
+        const data = encodeFunctionData19({
           abi: MORPHO_ABI,
           functionName: "repay",
           args: [market, params.amount, 0n, params.on_behalf_of, "0x"]
@@ -3847,7 +5983,7 @@ var init_dist3 = __esm({
       }
       async buildWithdraw(params) {
         const market = defaultMarketParams(params.asset);
-        const data = encodeFunctionData15({
+        const data = encodeFunctionData19({
           abi: MORPHO_ABI,
           functionName: "withdraw",
           args: [market, params.amount, 0n, params.to, params.to]
@@ -3865,14 +6001,12 @@ var init_dist3 = __esm({
         if (!this.defaultVault) {
           throw DefiError.contractError(`[${this.protocolName}] No MetaMorpho vault configured for rate query`);
         }
-        const client = createPublicClient13({ transport: http13(this.rpcUrl) });
-        const queueLen = await client.readContract({
-          address: this.defaultVault,
-          abi: META_MORPHO_ABI,
-          functionName: "supplyQueueLength"
-        }).catch((e) => {
+        const [queueLenRaw] = await multicallRead(this.rpcUrl, [
+          [this.defaultVault, encodeFunctionData19({ abi: META_MORPHO_ABI, functionName: "supplyQueueLength" })]
+        ]).catch((e) => {
           throw DefiError.rpcError(`[${this.protocolName}] supplyQueueLength failed: ${e}`);
         });
+        const queueLen = decodeU256(queueLenRaw ?? null);
         if (queueLen === 0n) {
           return {
             protocol: this.protocolName,
@@ -3884,45 +6018,40 @@ var init_dist3 = __esm({
             total_borrow: 0n
           };
         }
-        const marketId = await client.readContract({
-          address: this.defaultVault,
-          abi: META_MORPHO_ABI,
-          functionName: "supplyQueue",
-          args: [0n]
-        }).catch((e) => {
+        const [marketIdRaw] = await multicallRead(this.rpcUrl, [
+          [this.defaultVault, encodeFunctionData19({ abi: META_MORPHO_ABI, functionName: "supplyQueue", args: [0n] })]
+        ]).catch((e) => {
           throw DefiError.rpcError(`[${this.protocolName}] supplyQueue(0) failed: ${e}`);
         });
-        const mkt = await client.readContract({
-          address: this.morpho,
-          abi: MORPHO_ABI,
-          functionName: "market",
-          args: [marketId]
-        }).catch((e) => {
-          throw DefiError.rpcError(`[${this.protocolName}] market() failed: ${e}`);
+        if (!marketIdRaw || marketIdRaw.length < 66) {
+          throw DefiError.rpcError(`[${this.protocolName}] supplyQueue(0) returned no data`);
+        }
+        const marketId = marketIdRaw.slice(0, 66);
+        const [marketRaw, paramsRaw] = await multicallRead(this.rpcUrl, [
+          [this.morpho, encodeFunctionData19({ abi: MORPHO_ABI, functionName: "market", args: [marketId] })],
+          [this.morpho, encodeFunctionData19({ abi: MORPHO_ABI, functionName: "idToMarketParams", args: [marketId] })]
+        ]).catch((e) => {
+          throw DefiError.rpcError(`[${this.protocolName}] market/idToMarketParams failed: ${e}`);
         });
-        const [totalSupplyAssets, totalSupplyShares, totalBorrowAssets, totalBorrowShares, lastUpdate, fee] = mkt;
+        const mktDecoded = decodeMarket(marketRaw ?? null);
+        if (!mktDecoded) throw DefiError.rpcError(`[${this.protocolName}] market() returned no data`);
+        const [totalSupplyAssets, totalSupplyShares, totalBorrowAssets, totalBorrowShares, lastUpdate, fee] = mktDecoded;
+        const paramsDecoded = decodeMarketParams(paramsRaw ?? null);
+        if (!paramsDecoded) throw DefiError.rpcError(`[${this.protocolName}] idToMarketParams returned no data`);
+        const [loanToken, collateralToken, oracle, irm, lltv] = paramsDecoded;
         const supplyF = Number(totalSupplyAssets);
         const borrowF = Number(totalBorrowAssets);
         const util = supplyF > 0 ? borrowF / supplyF : 0;
-        const params2 = await client.readContract({
-          address: this.morpho,
-          abi: MORPHO_ABI,
-          functionName: "idToMarketParams",
-          args: [marketId]
-        }).catch((e) => {
-          throw DefiError.rpcError(`[${this.protocolName}] idToMarketParams failed: ${e}`);
-        });
-        const [loanToken, collateralToken, oracle, irm, lltv] = params2;
         const irmMarketParams = { loanToken, collateralToken, oracle, irm, lltv };
         const irmMarket = { totalSupplyAssets, totalSupplyShares, totalBorrowAssets, totalBorrowShares, lastUpdate, fee };
-        const borrowRatePerSec = await client.readContract({
-          address: irm,
-          abi: IRM_ABI,
-          functionName: "borrowRateView",
-          args: [irmMarketParams, irmMarket]
-        }).catch((e) => {
-          throw DefiError.rpcError(`[${this.protocolName}] borrowRateView failed: ${e}`);
-        });
+        const borrowRatePerSec = await (async () => {
+          const [borrowRateRaw] = await multicallRead(this.rpcUrl, [
+            [irm, encodeFunctionData19({ abi: IRM_ABI, functionName: "borrowRateView", args: [irmMarketParams, irmMarket] })]
+          ]).catch((e) => {
+            throw DefiError.rpcError(`[${this.protocolName}] borrowRateView failed: ${e}`);
+          });
+          return decodeU256(borrowRateRaw ?? null);
+        })();
         const ratePerSec = Number(borrowRatePerSec) / 1e18;
         const borrowApy = ratePerSec * SECONDS_PER_YEAR3 * 100;
         const feePct = Number(fee) / 1e18;
@@ -3943,18 +6072,18 @@ var init_dist3 = __esm({
         );
       }
     };
-    BORROWER_OPS_ABI = parseAbi17([
+    BORROWER_OPS_ABI = parseAbi21([
       "function openTrove(address _owner, uint256 _ownerIndex, uint256 _collAmount, uint256 _boldAmount, uint256 _upperHint, uint256 _lowerHint, uint256 _annualInterestRate, uint256 _maxUpfrontFee, address _addManager, address _removeManager, address _receiver) external returns (uint256)",
       "function adjustTrove(uint256 _troveId, uint256 _collChange, bool _isCollIncrease, uint256 _debtChange, bool _isDebtIncrease, uint256 _upperHint, uint256 _lowerHint, uint256 _maxUpfrontFee) external",
       "function closeTrove(uint256 _troveId) external"
     ]);
-    TROVE_MANAGER_ABI = parseAbi17([
+    TROVE_MANAGER_ABI = parseAbi21([
       "function getLatestTroveData(uint256 _troveId) external view returns (uint256 entireDebt, uint256 entireColl, uint256 redistDebtGain, uint256 redistCollGain, uint256 accruedInterest, uint256 recordedDebt, uint256 annualInterestRate, uint256 accruedBatchManagementFee, uint256 weightedRecordedDebt, uint256 lastInterestRateAdjTime)"
     ]);
-    HINT_HELPERS_ABI = parseAbi17([
+    HINT_HELPERS_ABI = parseAbi21([
       "function getApproxHint(uint256 _collIndex, uint256 _interestRate, uint256 _numTrials, uint256 _inputRandomSeed) external view returns (uint256 hintId, uint256 diff, uint256 latestRandomSeed)"
     ]);
-    SORTED_TROVES_ABI = parseAbi17([
+    SORTED_TROVES_ABI = parseAbi21([
       "function findInsertPosition(uint256 _annualInterestRate, uint256 _prevId, uint256 _nextId) external view returns (uint256 prevId, uint256 nextId)"
     ]);
     FelixCdpAdapter = class {
@@ -3982,7 +6111,7 @@ var init_dist3 = __esm({
         if (!this.hintHelpers || !this.sortedTroves || !this.rpcUrl) {
           return [0n, 0n];
         }
-        const client = createPublicClient14({ transport: http14(this.rpcUrl) });
+        const client = createPublicClient16({ transport: http16(this.rpcUrl) });
         const approxResult = await client.readContract({
           address: this.hintHelpers,
           abi: HINT_HELPERS_ABI,
@@ -4005,7 +6134,7 @@ var init_dist3 = __esm({
         const interestRate = 50000000000000000n;
         const [upperHint, lowerHint] = await this.getHints(interestRate);
         const hasHints = upperHint !== 0n || lowerHint !== 0n;
-        const data = encodeFunctionData16({
+        const data = encodeFunctionData20({
           abi: BORROWER_OPS_ABI,
           functionName: "openTrove",
           args: [
@@ -4034,7 +6163,7 @@ var init_dist3 = __esm({
       async buildAdjust(params) {
         const collChange = params.collateral_delta ?? 0n;
         const debtChange = params.debt_delta ?? 0n;
-        const data = encodeFunctionData16({
+        const data = encodeFunctionData20({
           abi: BORROWER_OPS_ABI,
           functionName: "adjustTrove",
           args: [
@@ -4057,7 +6186,7 @@ var init_dist3 = __esm({
         };
       }
       async buildClose(params) {
-        const data = encodeFunctionData16({
+        const data = encodeFunctionData20({
           abi: BORROWER_OPS_ABI,
           functionName: "closeTrove",
           args: [params.cdp_id]
@@ -4073,7 +6202,7 @@ var init_dist3 = __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 = createPublicClient14({ transport: http14(this.rpcUrl) });
+        const client = createPublicClient16({ transport: http16(this.rpcUrl) });
         const data = await client.readContract({
           address: this.troveManager,
           abi: TROVE_MANAGER_ABI,
@@ -4091,13 +6220,13 @@ var init_dist3 = __esm({
           protocol: this.protocolName,
           cdp_id: cdpId,
           collateral: {
-            token: zeroAddress8,
+            token: zeroAddress11,
             symbol: "WHYPE",
             amount: entireColl,
             decimals: 18
           },
           debt: {
-            token: zeroAddress8,
+            token: zeroAddress11,
             symbol: "feUSD",
             amount: entireDebt,
             decimals: 18
@@ -4106,7 +6235,7 @@ var init_dist3 = __esm({
         };
       }
     };
-    PRICE_FEED_ABI = parseAbi18([
+    PRICE_FEED_ABI = parseAbi222([
       "function fetchPrice() external view returns (uint256 price, bool isNewOracleFailureDetected)",
       "function lastGoodPrice() external view returns (uint256)"
     ]);
@@ -4132,7 +6261,7 @@ var init_dist3 = __esm({
         if (asset !== this.asset && this.asset !== "0x0000000000000000000000000000000000000000") {
           throw DefiError.unsupported(`[${this.protocolName}] Felix PriceFeed only supports asset ${this.asset}`);
         }
-        const client = createPublicClient15({ transport: http15(this.rpcUrl) });
+        const client = createPublicClient17({ transport: http17(this.rpcUrl) });
         let priceVal;
         try {
           const result = await client.readContract({
@@ -4171,7 +6300,7 @@ var init_dist3 = __esm({
         return results;
       }
     };
-    ERC4626_ABI = parseAbi19([
+    ERC4626_ABI = parseAbi23([
       "function asset() external view returns (address)",
       "function totalAssets() external view returns (uint256)",
       "function totalSupply() external view returns (uint256)",
@@ -4195,7 +6324,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildDeposit(assets, receiver) {
-        const data = encodeFunctionData17({
+        const data = encodeFunctionData21({
           abi: ERC4626_ABI,
           functionName: "deposit",
           args: [assets, receiver]
@@ -4209,7 +6338,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(assets, receiver, owner) {
-        const data = encodeFunctionData17({
+        const data = encodeFunctionData21({
           abi: ERC4626_ABI,
           functionName: "withdraw",
           args: [assets, receiver, owner]
@@ -4224,7 +6353,7 @@ var init_dist3 = __esm({
       }
       async totalAssets() {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient16({ transport: http16(this.rpcUrl) });
+        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
         return client.readContract({
           address: this.vaultAddress,
           abi: ERC4626_ABI,
@@ -4235,7 +6364,7 @@ var init_dist3 = __esm({
       }
       async convertToShares(assets) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient16({ transport: http16(this.rpcUrl) });
+        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
         return client.readContract({
           address: this.vaultAddress,
           abi: ERC4626_ABI,
@@ -4247,7 +6376,7 @@ var init_dist3 = __esm({
       }
       async convertToAssets(shares) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient16({ transport: http16(this.rpcUrl) });
+        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
         return client.readContract({
           address: this.vaultAddress,
           abi: ERC4626_ABI,
@@ -4259,7 +6388,7 @@ var init_dist3 = __esm({
       }
       async getVaultInfo() {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient16({ transport: http16(this.rpcUrl) });
+        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
         const [totalAssets, totalSupply, asset] = await Promise.all([
           client.readContract({ address: this.vaultAddress, abi: ERC4626_ABI, functionName: "totalAssets" }).catch((e) => {
             throw DefiError.rpcError(`[${this.protocolName}] totalAssets failed: ${e}`);
@@ -4280,7 +6409,7 @@ var init_dist3 = __esm({
         };
       }
     };
-    GENERIC_LST_ABI = parseAbi20([
+    GENERIC_LST_ABI = parseAbi24([
       "function stake() external payable returns (uint256)",
       "function unstake(uint256 amount) external returns (uint256)"
     ]);
@@ -4297,7 +6426,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildStake(params) {
-        const data = encodeFunctionData18({ abi: GENERIC_LST_ABI, functionName: "stake" });
+        const data = encodeFunctionData222({ abi: GENERIC_LST_ABI, functionName: "stake" });
         return {
           description: `[${this.protocolName}] Stake ${params.amount} HYPE`,
           to: this.staking,
@@ -4307,7 +6436,7 @@ var init_dist3 = __esm({
         };
       }
       async buildUnstake(params) {
-        const data = encodeFunctionData18({
+        const data = encodeFunctionData222({
           abi: GENERIC_LST_ABI,
           functionName: "unstake",
           args: [params.amount]
@@ -4324,11 +6453,11 @@ var init_dist3 = __esm({
         throw DefiError.unsupported(`[${this.protocolName}] getInfo requires RPC`);
       }
     };
-    STHYPE_ABI = parseAbi21([
+    STHYPE_ABI = parseAbi25([
       "function submit(address referral) external payable returns (uint256)",
       "function requestWithdrawals(uint256[] amounts, address owner) external returns (uint256[] requestIds)"
     ]);
-    ERC20_ABI3 = parseAbi21([
+    ERC20_ABI3 = parseAbi25([
       "function totalSupply() external view returns (uint256)"
     ]);
     StHypeAdapter = class {
@@ -4348,10 +6477,10 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildStake(params) {
-        const data = encodeFunctionData19({
+        const data = encodeFunctionData23({
           abi: STHYPE_ABI,
           functionName: "submit",
-          args: [zeroAddress9]
+          args: [zeroAddress12]
         });
         return {
           description: `[${this.protocolName}] Stake ${params.amount} HYPE for stHYPE`,
@@ -4362,7 +6491,7 @@ var init_dist3 = __esm({
         };
       }
       async buildUnstake(params) {
-        const data = encodeFunctionData19({
+        const data = encodeFunctionData23({
           abi: STHYPE_ABI,
           functionName: "requestWithdrawals",
           args: [[params.amount], params.recipient]
@@ -4377,7 +6506,7 @@ var init_dist3 = __esm({
       }
       async getInfo() {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient17({ transport: http17(this.rpcUrl) });
+        const client = createPublicClient19({ transport: http19(this.rpcUrl) });
         const tokenAddr = this.sthypeToken ?? this.staking;
         const totalSupply = await client.readContract({
           address: tokenAddr,
@@ -4388,19 +6517,19 @@ var init_dist3 = __esm({
         });
         return {
           protocol: this.protocolName,
-          staked_token: zeroAddress9,
+          staked_token: zeroAddress12,
           liquid_token: tokenAddr,
           exchange_rate: 1,
           total_staked: totalSupply
         };
       }
     };
-    KINETIQ_ABI = parseAbi222([
+    KINETIQ_ABI = parseAbi26([
       "function stake() external payable returns (uint256)",
       "function requestUnstake(uint256 amount) external returns (uint256)",
       "function totalStaked() external view returns (uint256)"
     ]);
-    ORACLE_ABI3 = parseAbi222([
+    ORACLE_ABI3 = parseAbi26([
       "function getAssetPrice(address asset) external view returns (uint256)"
     ]);
     WHYPE = "0x5555555555555555555555555555555555555555";
@@ -4422,7 +6551,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildStake(params) {
-        const data = encodeFunctionData20({ abi: KINETIQ_ABI, functionName: "stake" });
+        const data = encodeFunctionData24({ abi: KINETIQ_ABI, functionName: "stake" });
         return {
           description: `[${this.protocolName}] Stake ${params.amount} HYPE for kHYPE`,
           to: this.staking,
@@ -4432,7 +6561,7 @@ var init_dist3 = __esm({
         };
       }
       async buildUnstake(params) {
-        const data = encodeFunctionData20({
+        const data = encodeFunctionData24({
           abi: KINETIQ_ABI,
           functionName: "requestUnstake",
           args: [params.amount]
@@ -4447,7 +6576,7 @@ var init_dist3 = __esm({
       }
       async getInfo() {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
+        const client = createPublicClient20({ transport: http20(this.rpcUrl) });
         const totalStaked = await client.readContract({
           address: this.staking,
           abi: KINETIQ_ABI,
@@ -4462,7 +6591,7 @@ var init_dist3 = __esm({
         const rateF64 = hypePrice > 0n && khypePrice > 0n ? Number(khypePrice * 10n ** 18n / hypePrice) / 1e18 : 1;
         return {
           protocol: this.protocolName,
-          staked_token: zeroAddress10,
+          staked_token: zeroAddress13,
           liquid_token: this.liquidToken,
           exchange_rate: rateF64,
           total_staked: totalStaked
@@ -4518,7 +6647,7 @@ var init_dist3 = __esm({
         );
       }
     };
-    HLP_ABI = parseAbi23([
+    HLP_ABI = parseAbi27([
       "function deposit(uint256 amount) external returns (uint256)",
       "function withdraw(uint256 shares) external returns (uint256)"
     ]);
@@ -4535,7 +6664,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildOpenPosition(params) {
-        const data = encodeFunctionData21({
+        const data = encodeFunctionData25({
           abi: HLP_ABI,
           functionName: "deposit",
           args: [params.collateral]
@@ -4549,7 +6678,7 @@ var init_dist3 = __esm({
         };
       }
       async buildClosePosition(params) {
-        const data = encodeFunctionData21({
+        const data = encodeFunctionData25({
           abi: HLP_ABI,
           functionName: "withdraw",
           args: [params.size]
@@ -4584,7 +6713,7 @@ var init_dist3 = __esm({
         );
       }
     };
-    RYSK_ABI = parseAbi24([
+    RYSK_ABI = parseAbi28([
       "function openOption(address underlying, uint256 strikePrice, uint256 expiry, bool isCall, uint256 amount) external returns (uint256 premium)",
       "function closeOption(address underlying, uint256 strikePrice, uint256 expiry, bool isCall, uint256 amount) external returns (uint256 payout)"
     ]);
@@ -4601,7 +6730,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildBuy(params) {
-        const data = encodeFunctionData222({
+        const data = encodeFunctionData26({
           abi: RYSK_ABI,
           functionName: "openOption",
           args: [
@@ -4621,7 +6750,7 @@ var init_dist3 = __esm({
         };
       }
       async buildSell(params) {
-        const data = encodeFunctionData222({
+        const data = encodeFunctionData26({
           abi: RYSK_ABI,
           functionName: "closeOption",
           args: [
@@ -4662,7 +6791,7 @@ var init_dist3 = __esm({
         );
       }
     };
-    ERC721_ABI = parseAbi25([
+    ERC721_ABI = parseAbi29([
       "function name() returns (string)",
       "function symbol() returns (string)",
       "function totalSupply() returns (uint256)",
@@ -4682,7 +6811,7 @@ var init_dist3 = __esm({
       }
       async getCollectionInfo(collection) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient19({ transport: http19(this.rpcUrl) });
+        const client = createPublicClient21({ transport: http21(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}`);
@@ -4701,7 +6830,7 @@ var init_dist3 = __esm({
       }
       async getTokenInfo(collection, tokenId) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient19({ transport: http19(this.rpcUrl) });
+        const client = createPublicClient21({ transport: http21(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}`);
@@ -4717,7 +6846,7 @@ var init_dist3 = __esm({
       }
       async getBalance(owner, collection) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient19({ transport: http19(this.rpcUrl) });
+        const client = createPublicClient21({ transport: http21(this.rpcUrl) });
         return client.readContract({ address: collection, abi: ERC721_ABI, functionName: "balanceOf", args: [owner] }).catch((e) => {
           throw DefiError.rpcError(`[${this.protocolName}] balanceOf failed: ${e}`);
         });
@@ -4773,9 +6902,10 @@ import { z } from "zod";
 
 // src/executor.ts
 init_dist2();
-import { createPublicClient as createPublicClient20, createWalletClient, http as http20, parseAbi as parseAbi26, encodeFunctionData as encodeFunctionData23 } from "viem";
+init_dist2();
+import { createPublicClient as createPublicClient23, createWalletClient, http as http23, parseAbi as parseAbi30, encodeFunctionData as encodeFunctionData27 } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
-var ERC20_ABI4 = parseAbi26([
+var ERC20_ABI4 = parseAbi30([
   "function allowance(address owner, address spender) external view returns (uint256)",
   "function approve(address spender, uint256 amount) external returns (bool)"
 ]);
@@ -4811,7 +6941,7 @@ var Executor = class _Executor {
       `  Approving ${amount} of ${token} for ${spender}...
 `
     );
-    const approveData = encodeFunctionData23({
+    const approveData = encodeFunctionData27({
       abi: ERC20_ABI4,
       functionName: "approve",
       args: [spender, amount]
@@ -4854,7 +6984,7 @@ var Executor = class _Executor {
   /** Fetch EIP-1559 fee params from the network. Returns [maxFeePerGas, maxPriorityFeePerGas]. */
   async fetchEip1559Fees(rpcUrl) {
     try {
-      const client = createPublicClient20({ transport: http20(rpcUrl) });
+      const client = createPublicClient23({ transport: http23(rpcUrl) });
       const gasPrice = await client.getGasPrice();
       let priorityFee = DEFAULT_PRIORITY_FEE_WEI;
       try {
@@ -4870,7 +7000,7 @@ var Executor = class _Executor {
   /** Estimate gas dynamically with buffer, falling back to a hardcoded estimate */
   async estimateGasWithBuffer(rpcUrl, tx, from) {
     try {
-      const client = createPublicClient20({ transport: http20(rpcUrl) });
+      const client = createPublicClient23({ transport: http23(rpcUrl) });
       const estimated = await client.estimateGas({
         to: tx.to,
         data: tx.data,
@@ -4882,8 +7012,11 @@ var Executor = class _Executor {
         return buffered > MAX_GAS_LIMIT ? MAX_GAS_LIMIT : buffered;
       }
     } catch {
+      if (tx.gas_estimate) {
+        return _Executor.applyGasBuffer(BigInt(tx.gas_estimate));
+      }
     }
-    return tx.gas_estimate ? BigInt(tx.gas_estimate) : 0n;
+    return 0n;
   }
   /** Simulate a transaction via eth_call + eth_estimateGas */
   async simulate(tx) {
@@ -4891,9 +7024,49 @@ var Executor = class _Executor {
     if (!rpcUrl) {
       throw DefiError.rpcError("No RPC URL \u2014 cannot simulate. Set HYPEREVM_RPC_URL.");
     }
-    const client = createPublicClient20({ transport: http20(rpcUrl) });
+    const client = createPublicClient23({ transport: http23(rpcUrl) });
     const privateKey = process.env["DEFI_PRIVATE_KEY"];
     const from = privateKey ? privateKeyToAccount(privateKey).address : "0x0000000000000000000000000000000000000001";
+    if (tx.approvals && tx.approvals.length > 0) {
+      const pendingApprovals = [];
+      for (const approval of tx.approvals) {
+        try {
+          const allowance = await client.readContract({
+            address: approval.token,
+            abi: ERC20_ABI4,
+            functionName: "allowance",
+            args: [from, approval.spender]
+          });
+          if (allowance < approval.amount) {
+            pendingApprovals.push({
+              token: approval.token,
+              spender: approval.spender,
+              needed: approval.amount.toString(),
+              current: allowance.toString()
+            });
+          }
+        } catch {
+        }
+      }
+      if (pendingApprovals.length > 0) {
+        return {
+          tx_hash: void 0,
+          status: TxStatus.NeedsApproval,
+          gas_used: tx.gas_estimate,
+          description: tx.description,
+          details: {
+            to: tx.to,
+            from,
+            data: tx.data,
+            value: tx.value.toString(),
+            mode: "simulated",
+            result: "needs_approval",
+            pending_approvals: pendingApprovals,
+            hint: "Use --broadcast to auto-approve and execute"
+          }
+        };
+      }
+    }
     try {
       await client.call({ to: tx.to, data: tx.data, value: tx.value, account: from });
       const gasEstimate = await this.estimateGasWithBuffer(rpcUrl, tx, from);
@@ -4964,8 +7137,33 @@ var Executor = class _Executor {
     if (!rpcUrl) {
       throw DefiError.rpcError("No RPC URL configured for broadcasting");
     }
-    const publicClient = createPublicClient20({ transport: http20(rpcUrl) });
-    const walletClient = createWalletClient({ account, transport: http20(rpcUrl) });
+    const publicClient = createPublicClient23({ transport: http23(rpcUrl) });
+    const walletClient = createWalletClient({ account, transport: http23(rpcUrl) });
+    if (tx.pre_txs && tx.pre_txs.length > 0) {
+      for (const preTx of tx.pre_txs) {
+        process.stderr.write(`  Pre-tx: ${preTx.description}...
+`);
+        const preGas = await this.estimateGasWithBuffer(rpcUrl, preTx, account.address);
+        const preTxHash = await walletClient.sendTransaction({
+          chain: null,
+          to: preTx.to,
+          data: preTx.data,
+          value: preTx.value,
+          gas: preGas > 0n ? preGas : void 0
+        });
+        const preTxUrl = this.explorerUrl ? `${this.explorerUrl}/tx/${preTxHash}` : void 0;
+        process.stderr.write(`  Pre-tx sent: ${preTxHash}
+`);
+        if (preTxUrl) process.stderr.write(`  Explorer: ${preTxUrl}
+`);
+        const preReceipt = await publicClient.waitForTransactionReceipt({ hash: preTxHash });
+        if (preReceipt.status !== "success") {
+          throw new DefiError("TX_FAILED", `Pre-transaction failed: ${preTx.description}`);
+        }
+        process.stderr.write(`  Pre-tx confirmed
+`);
+      }
+    }
     if (tx.approvals && tx.approvals.length > 0) {
       for (const approval of tx.approvals) {
         await this.checkAndApprove(
@@ -5003,20 +7201,37 @@ var Executor = class _Executor {
     process.stderr.write("Waiting for confirmation...\n");
     const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
     const status = receipt.status === "success" ? "confirmed" : "failed";
+    let mintedTokenId;
+    if (receipt.status === "success" && receipt.logs) {
+      const TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+      const ZERO_TOPIC = "0x0000000000000000000000000000000000000000000000000000000000000000";
+      for (const log of receipt.logs) {
+        if (log.topics.length >= 4 && log.topics[0] === TRANSFER_TOPIC && log.topics[1] === ZERO_TOPIC) {
+          mintedTokenId = BigInt(log.topics[3]).toString();
+          break;
+        }
+      }
+    }
+    const details = {
+      to: tx.to,
+      from: account.address,
+      block_number: receipt.blockNumber?.toString(),
+      gas_limit: gasLimit.toString(),
+      gas_used: receipt.gasUsed?.toString(),
+      explorer_url: txUrl,
+      mode: "broadcast"
+    };
+    if (mintedTokenId) {
+      details.minted_token_id = mintedTokenId;
+      process.stderr.write(`  Minted NFT tokenId: ${mintedTokenId}
+`);
+    }
     return {
       tx_hash: txHash,
       status,
       gas_used: receipt.gasUsed ? Number(receipt.gasUsed) : void 0,
       description: tx.description,
-      details: {
-        to: tx.to,
-        from: account.address,
-        block_number: receipt.blockNumber?.toString(),
-        gas_limit: gasLimit.toString(),
-        gas_used: receipt.gasUsed?.toString(),
-        explorer_url: txUrl,
-        mode: "broadcast"
-      }
+      details
     };
   }
 };
@@ -5604,8 +7819,8 @@ server.tool(
       const user = address;
       const { ProtocolCategory: ProtocolCategory2, multicallRead: multicallRead2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
       const { createLending: _createLending } = await Promise.resolve().then(() => (init_dist3(), dist_exports2));
-      const { encodeFunctionData: encodeFunctionData24, parseAbi: parseAbi27 } = await import("viem");
-      const POOL_ABI3 = parseAbi27([
+      const { encodeFunctionData: encodeFunctionData28, parseAbi: parseAbi31 } = await import("viem");
+      const POOL_ABI3 = parseAbi31([
         "function getUserAccountData(address user) external view returns (uint256 totalCollateralBase, uint256 totalDebtBase, uint256 availableBorrowsBase, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor)"
       ]);
       const lendingProtos = registry.getProtocolsForChain(chainName).filter((p) => p.category === ProtocolCategory2.Lending);
@@ -5614,7 +7829,7 @@ server.tool(
         const poolAddr = p.contracts?.pool;
         if (!poolAddr) continue;
         try {
-          const callData = encodeFunctionData24({ abi: POOL_ABI3, functionName: "getUserAccountData", args: [user] });
+          const callData = encodeFunctionData28({ abi: POOL_ABI3, functionName: "getUserAccountData", args: [user] });
           const results = await multicallRead2(rpcUrl, [[poolAddr, callData]]);
           const raw = results[0];
           if (!raw || raw.length < 2 + 6 * 64) continue;