@hypurrquant/defi-cli 0.3.0 → 0.3.2

package/dist/mcp-server.js

@@ -1208,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;
+      }
     };
   }
 });
@@ -1234,7 +1252,9 @@ __export(dist_exports2, {
   GenericOptionsAdapter: () => GenericOptionsAdapter,
   GenericYieldAdapter: () => GenericYieldAdapter,
   HlpVaultAdapter: () => HlpVaultAdapter,
+  HybraGaugeAdapter: () => HybraGaugeAdapter,
   KinetiqAdapter: () => KinetiqAdapter,
+  KittenSwapFarmingAdapter: () => KittenSwapFarmingAdapter,
   MasterChefAdapter: () => MasterChefAdapter,
   MerchantMoeLBAdapter: () => MerchantMoeLBAdapter,
   MorphoBlueAdapter: () => MorphoBlueAdapter,
@@ -1243,6 +1263,7 @@ __export(dist_exports2, {
   SolidlyAdapter: () => SolidlyAdapter,
   SolidlyGaugeAdapter: () => SolidlyGaugeAdapter,
   StHypeAdapter: () => StHypeAdapter,
+  ThenaCLAdapter: () => ThenaCLAdapter,
   UniswapV2Adapter: () => UniswapV2Adapter,
   UniswapV3Adapter: () => UniswapV3Adapter,
   WooFiAdapter: () => WooFiAdapter,
@@ -1250,6 +1271,7 @@ __export(dist_exports2, {
   createDerivatives: () => createDerivatives,
   createDex: () => createDex,
   createGauge: () => createGauge,
+  createKittenSwapFarming: () => createKittenSwapFarming,
   createLending: () => createLending,
   createLiquidStaking: () => createLiquidStaking,
   createMasterChef: () => createMasterChef,
@@ -1267,36 +1289,104 @@ import { encodeFunctionData as encodeFunctionData32, parseAbi as parseAbi32, cre
 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, decodeAbiParameters as decodeAbiParameters4 } from "viem";
-import { encodeFunctionData as encodeFunctionData7, parseAbi as parseAbi7, zeroAddress as zeroAddress3 } from "viem";
-import { createPublicClient as createPublicClient4, encodeFunctionData as encodeFunctionData8, http as http4, parseAbi as parseAbi8, zeroAddress as zeroAddress4 } from "viem";
-import { encodeFunctionData as encodeFunctionData9, parseAbi as parseAbi9, createPublicClient as createPublicClient5, http as http5 } 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 {
-  encodeFunctionData as encodeFunctionData10,
-  decodeFunctionResult as decodeFunctionResult22,
-  parseAbi as parseAbi10,
-  createPublicClient as createPublicClient6,
-  http as http6
+  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 createPublicClient7, http as http7, parseAbi as parseAbi11, encodeFunctionData as encodeFunctionData11, decodeFunctionResult as decodeFunctionResult3, zeroAddress as zeroAddress5 } from "viem";
-import { createPublicClient as createPublicClient8, http as http8, parseAbi as parseAbi12, encodeFunctionData as encodeFunctionData12, zeroAddress as zeroAddress6 } from "viem";
-import { createPublicClient as createPublicClient9, http as http9, parseAbi as parseAbi13 } from "viem";
-import { createPublicClient as createPublicClient10, http as http10, parseAbi as parseAbi14, encodeFunctionData as encodeFunctionData13 } from "viem";
-import { createPublicClient as createPublicClient11, http as http11, parseAbi as parseAbi15, encodeFunctionData as encodeFunctionData14 } from "viem";
-import { createPublicClient as createPublicClient12, http as http12, parseAbi as parseAbi16, encodeFunctionData as encodeFunctionData15 } from "viem";
-import { parseAbi as parseAbi17, encodeFunctionData as encodeFunctionData16, decodeFunctionResult as decodeFunctionResult4, zeroAddress as zeroAddress7 } from "viem";
-import { createPublicClient as createPublicClient13, http as http13, parseAbi as parseAbi18, encodeFunctionData as encodeFunctionData17, zeroAddress as zeroAddress8 } from "viem";
-import { createPublicClient as createPublicClient14, http as http14, parseAbi as parseAbi19 } from "viem";
-import { createPublicClient as createPublicClient15, http as http15, parseAbi as parseAbi20, encodeFunctionData as encodeFunctionData18 } from "viem";
-import { parseAbi as parseAbi21, encodeFunctionData as encodeFunctionData19 } from "viem";
-import { createPublicClient as createPublicClient16, http as http16, parseAbi as parseAbi222, encodeFunctionData as encodeFunctionData20, zeroAddress as zeroAddress9 } from "viem";
-import { createPublicClient as createPublicClient17, http as http17, parseAbi as parseAbi23, encodeFunctionData as encodeFunctionData21, zeroAddress as zeroAddress10 } 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 { parseAbi as parseAbi25, encodeFunctionData as encodeFunctionData23 } from "viem";
-import { createPublicClient as createPublicClient18, http as http18, parseAbi as parseAbi26 } 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 decodeFunctionResult22({ abi: _addressAbi, functionName: "f", data });
+    return decodeFunctionResult4({ abi: _addressAbi, functionName: "f", data });
   } catch {
     return null;
   }
@@ -1304,7 +1394,7 @@ function decodeAddressResult(data) {
 function decodeUint256Result(data) {
   if (!data) return null;
   try {
-    return decodeFunctionResult22({ abi: _uint256Abi, functionName: "f", data });
+    return decodeFunctionResult4({ abi: _uint256Abi, functionName: "f", data });
   } catch {
     return null;
   }
@@ -1312,7 +1402,7 @@ function decodeUint256Result(data) {
 function decodeBoolResult(data) {
   if (!data) return null;
   try {
-    return decodeFunctionResult22({ abi: _boolAbi, functionName: "f", data });
+    return decodeFunctionResult4({ abi: _boolAbi, functionName: "f", data });
   } catch {
     return null;
   }
@@ -1320,7 +1410,7 @@ function decodeBoolResult(data) {
 function decodeStringResult(data) {
   if (!data) return "?";
   try {
-    return decodeFunctionResult22({ abi: erc20Abi2, functionName: "symbol", data });
+    return decodeFunctionResult4({ abi: erc20Abi2, functionName: "symbol", data });
   } catch {
     return "?";
   }
@@ -1328,7 +1418,7 @@ function decodeStringResult(data) {
 function decodeRangeResult(data) {
   if (!data) return null;
   try {
-    return decodeFunctionResult22({ abi: _rangeAbi, functionName: "f", data });
+    return decodeFunctionResult4({ abi: _rangeAbi, functionName: "f", data });
   } catch {
     return null;
   }
@@ -1336,7 +1426,7 @@ function decodeRangeResult(data) {
 function decodeBinResult(data) {
   if (!data) return null;
   try {
-    return decodeFunctionResult22({ abi: _binAbi, functionName: "f", data });
+    return decodeFunctionResult4({ abi: _binAbi, functionName: "f", data });
   } catch {
     return null;
   }
@@ -1344,7 +1434,7 @@ function decodeBinResult(data) {
 function decodeUint256ArrayResult(data) {
   if (!data) return null;
   try {
-    return decodeFunctionResult22({ abi: _uint256ArrayAbi, functionName: "f", data });
+    return decodeFunctionResult4({ abi: _uint256ArrayAbi, functionName: "f", data });
   } catch {
     return null;
   }
@@ -1384,19 +1474,76 @@ function buildUniformDistribution(deltaIds) {
   }
   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 decodeAddress(data) {
+function decodeAddress4(data) {
   if (!data || data.length < 66) return null;
   return `0x${data.slice(26, 66)}`;
 }
 function decodeAddressArray(data) {
   if (!data) return [];
   try {
-    return decodeFunctionResult3({
+    return decodeFunctionResult6({
       abi: REWARDS_CONTROLLER_ABI,
       functionName: "getRewardsByAsset",
       data
@@ -1408,7 +1555,7 @@ function decodeAddressArray(data) {
 function decodeReserveData(data) {
   if (!data) return null;
   try {
-    return decodeFunctionResult3({
+    return decodeFunctionResult6({
       abi: POOL_ABI,
       functionName: "getReserveData",
       data
@@ -1420,7 +1567,7 @@ function decodeReserveData(data) {
 function decodeRewardsData(data) {
   if (!data) return null;
   try {
-    return decodeFunctionResult3({
+    return decodeFunctionResult6({
       abi: REWARDS_CONTROLLER_ABI,
       functionName: "getRewardsData",
       data
@@ -1434,19 +1581,19 @@ function u256ToF642(v) {
   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 decodeFunctionResult4({
+    return decodeFunctionResult7({
       abi: MORPHO_ABI,
       functionName: "market",
       data
@@ -1458,7 +1605,7 @@ function decodeMarket(data) {
 function decodeMarketParams(data) {
   if (!data) return null;
   try {
-    return decodeFunctionResult4({
+    return decodeFunctionResult7({
       abi: MORPHO_ABI,
       functionName: "idToMarketParams",
       data
@@ -1482,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":
@@ -1542,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`);
@@ -1609,7 +1760,23 @@ function createOracleFromCdp(entry, _asset, rpcUrl) {
 function createMerchantMoeLB(entry, rpcUrl) {
   return new MerchantMoeLBAdapter(entry, rpcUrl);
 }
-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, lbRouterAbi, lbFactoryAbi, lbPairAbi, lbRewarderAbi, masterChefAbi, veMoeAbi, lbPairBinAbi, lbQuoterAbi2, erc20Abi2, _addressAbi, _uint256Abi, _boolAbi, _rangeAbi, _binAbi, _uint256ArrayAbi, MerchantMoeLBAdapter, 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 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";
@@ -1644,6 +1811,9 @@ var init_dist3 = __esm({
     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; }",
@@ -2105,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)"
     ]);
@@ -2250,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) {
@@ -2571,7 +2767,440 @@ var init_dist3 = __esm({
         };
       }
     };
-    abi5 = parseAbi7([
+    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)"
+    ]);
+    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;
+      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 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 data = encodeFunctionData7({
+          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`,
+          to: this.router,
+          data,
+          value: 0n,
+          gas_estimate: 3e5,
+          approvals: [{ token: params.token_in, spender: this.router, amount: params.amount_in }]
+        };
+      }
+      async quote(_params) {
+        throw DefiError.unsupported(`[${this.protocolName}] quote not yet implemented \u2014 use swap 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}] remove_liquidity requires tokenId`);
+      }
+    };
+    _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"
+    ]);
+    voterAbi = parseAbi8([
+      "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"
+    ]);
+    HybraGaugeAdapter = class {
+      protocolName;
+      gaugeManager;
+      veToken;
+      voter;
+      positionManager;
+      poolFactory;
+      rpcUrl;
+      constructor(entry, rpcUrl) {
+        this.protocolName = entry.name;
+        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;
+      }
+      // ─── 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"
+          });
+        } catch {
+          return [];
+        }
+        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]
+        });
+        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: encodeFunctionData8({ abi: gaugeCLAbi, functionName: "deposit", args: [tokenId] }),
+          value: 0n,
+          gas_estimate: 5e5,
+          pre_txs: [approveTx]
+        };
+      }
+      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 NFT #${tokenId} from gauge`,
+          to: gauge,
+          data: encodeFunctionData8({ abi: gaugeCLAbi, functionName: "withdraw", args: [tokenId, 1] }),
+          value: 0n,
+          gas_estimate: 1e6
+        };
+      }
+      // ─── 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 rewards for NFT #${tokenId}`,
+          to: this.gaugeManager,
+          data: encodeFunctionData8({
+            abi: gaugeManagerAbi,
+            functionName: "claimRewards",
+            args: [gauge, [tokenId], 1]
+            // redeemType=1
+          }),
+          value: 0n,
+          gas_estimate: 1e6
+        };
+      }
+      // ─── 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]
+        });
+      }
+      // ─── VoteEscrow ──────────────────────────────────────────────
+      async buildCreateLock(amount, lockDuration) {
+        return {
+          description: `[${this.protocolName}] Create veNFT lock`,
+          to: this.veToken,
+          data: encodeFunctionData8({ abi: veAbi, functionName: "create_lock", args: [amount, BigInt(lockDuration)] }),
+          value: 0n,
+          gas_estimate: 3e5
+        };
+      }
+      async buildIncreaseAmount(tokenId, amount) {
+        return {
+          description: `[${this.protocolName}] Increase veNFT #${tokenId}`,
+          to: this.veToken,
+          data: encodeFunctionData8({ abi: veAbi, functionName: "increase_amount", args: [tokenId, amount] }),
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      async buildIncreaseUnlockTime(tokenId, lockDuration) {
+        return {
+          description: `[${this.protocolName}] Extend veNFT #${tokenId} lock`,
+          to: this.veToken,
+          data: encodeFunctionData8({ abi: veAbi, functionName: "increase_unlock_time", args: [tokenId, BigInt(lockDuration)] }),
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      async buildWithdrawExpired(tokenId) {
+        return {
+          description: `[${this.protocolName}] Withdraw expired veNFT #${tokenId}`,
+          to: this.veToken,
+          data: encodeFunctionData8({ abi: veAbi, functionName: "withdraw", args: [tokenId] }),
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      // ─── Voter ──────────────────────────────────────────────────
+      async buildVote(tokenId, pools, weights) {
+        return {
+          description: `[${this.protocolName}] Vote with veNFT #${tokenId}`,
+          to: this.voter,
+          data: encodeFunctionData8({ abi: voterAbi, functionName: "vote", args: [tokenId, pools, weights] }),
+          value: 0n,
+          gas_estimate: 5e5
+        };
+      }
+      async buildClaimBribes(bribes, tokenId) {
+        const tokensPerBribe = bribes.map(() => []);
+        return {
+          description: `[${this.protocolName}] Claim bribes for veNFT #${tokenId}`,
+          to: this.voter,
+          data: encodeFunctionData8({ abi: voterAbi, functionName: "claimBribes", args: [bribes, tokensPerBribe, tokenId] }),
+          value: 0n,
+          gas_estimate: 3e5
+        };
+      }
+      async buildClaimFees(fees, tokenId) {
+        const tokensPerFee = fees.map(() => []);
+        return {
+          description: `[${this.protocolName}] Claim fees for veNFT #${tokenId}`,
+          to: this.voter,
+          data: encodeFunctionData8({ abi: voterAbi, functionName: "claimFees", args: [fees, tokensPerFee, tokenId] }),
+          value: 0n,
+          gas_estimate: 3e5
+        };
+      }
+    };
+    abi5 = parseAbi9([
       "function swap(address fromToken, address toToken, uint256 fromAmount, uint256 minToAmount, address to, address rebateTo) external payable returns (uint256 realToAmount)"
     ]);
     WooFiAdapter = class {
@@ -2590,7 +3219,7 @@ var init_dist3 = __esm({
       }
       async buildSwap(params) {
         const minToAmount = 0n;
-        const data = encodeFunctionData7({
+        const data = encodeFunctionData9({
           abi: abi5,
           functionName: "swap",
           args: [
@@ -2599,7 +3228,7 @@ var init_dist3 = __esm({
             params.amount_in,
             minToAmount,
             params.recipient,
-            zeroAddress3
+            zeroAddress5
           ]
         });
         return {
@@ -2620,20 +3249,25 @@ var init_dist3 = __esm({
         throw DefiError.unsupported(`[${this.protocolName}] WOOFi does not support LP positions via router`);
       }
     };
-    gaugeAbi = parseAbi8([
+    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 isReward(address token) external view returns (bool)"
+      "function rewardData(address token) external view returns (uint256 periodFinish, uint256 rewardRate, uint256 lastUpdateTime, uint256 rewardPerTokenStored)",
+      "function nonfungiblePositionManager() external view returns (address)"
     ]);
-    veAbi = parseAbi8([
+    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",
@@ -2641,17 +3275,39 @@ var init_dist3 = __esm({
       "function balanceOfNFT(uint256 tokenId) external view returns (uint256)",
       "function locked(uint256 tokenId) external view returns (uint256 amount, uint256 end)"
     ]);
-    voterAbi = parseAbi8([
+    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 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 voter = entry.contracts?.["voter"];
@@ -2665,14 +3321,250 @@ var init_dist3 = __esm({
         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;
       }
+      /** 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 = encodeFunctionData8({
+          const data2 = encodeFunctionData10({
             abi: gaugeAbi,
             functionName: "depositFor",
             args: [amount, tokenId]
@@ -2686,7 +3578,7 @@ var init_dist3 = __esm({
             approvals: lpToken ? [{ token: lpToken, spender: gauge, amount }] : void 0
           };
         }
-        const data = encodeFunctionData8({
+        const data = encodeFunctionData10({
           abi: gaugeAbi,
           functionName: "deposit",
           args: [amount]
@@ -2701,7 +3593,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(gauge, amount) {
-        const data = encodeFunctionData8({
+        const data = encodeFunctionData10({
           abi: gaugeAbi,
           functionName: "withdraw",
           args: [amount]
@@ -2714,36 +3606,108 @@ var init_dist3 = __esm({
           gas_estimate: 2e5
         };
       }
-      async buildClaimRewards(gauge, account) {
-        if (account && this.rpcUrl) {
+      /**
+       * 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 client = createPublicClient4({ transport: http4(this.rpcUrl) });
-            const listLen = await client.readContract({
-              address: gauge,
-              abi: gaugeAbi,
-              functionName: "rewardsListLength"
+            const gauge = await client.readContract({
+              address: this.voter,
+              abi: voterAbi2,
+              functionName: fn,
+              args: [pool]
             });
-            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
-              };
-            }
+            if (gauge !== zeroAddress6) return gauge;
           } catch {
           }
         }
-        const data = encodeFunctionData8({
+        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: [account ?? zeroAddress4]
+          args: []
         });
         return {
           description: `[${this.protocolName}] Claim gauge rewards`,
@@ -2753,13 +3717,83 @@ var init_dist3 = __esm({
           gas_estimate: 2e5
         };
       }
-      async getPendingRewards(_gauge, _user) {
-        throw DefiError.unsupported(`[${this.protocolName}] get_pending_rewards requires RPC`);
+      /**
+       * 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 = encodeFunctionData8({
-          abi: veAbi,
+        const data = encodeFunctionData10({
+          abi: veAbi2,
           functionName: "create_lock",
           args: [amount, BigInt(lockDuration)]
         });
@@ -2772,8 +3806,8 @@ var init_dist3 = __esm({
         };
       }
       async buildIncreaseAmount(tokenId, amount) {
-        const data = encodeFunctionData8({
-          abi: veAbi,
+        const data = encodeFunctionData10({
+          abi: veAbi2,
           functionName: "increase_amount",
           args: [tokenId, amount]
         });
@@ -2786,8 +3820,8 @@ var init_dist3 = __esm({
         };
       }
       async buildIncreaseUnlockTime(tokenId, lockDuration) {
-        const data = encodeFunctionData8({
-          abi: veAbi,
+        const data = encodeFunctionData10({
+          abi: veAbi2,
           functionName: "increase_unlock_time",
           args: [tokenId, BigInt(lockDuration)]
         });
@@ -2800,8 +3834,8 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdrawExpired(tokenId) {
-        const data = encodeFunctionData8({
-          abi: veAbi,
+        const data = encodeFunctionData10({
+          abi: veAbi2,
           functionName: "withdraw",
           args: [tokenId]
         });
@@ -2815,8 +3849,8 @@ var init_dist3 = __esm({
       }
       // IVoter
       async buildVote(tokenId, pools, weights) {
-        const data = encodeFunctionData8({
-          abi: voterAbi,
+        const data = encodeFunctionData10({
+          abi: voterAbi2,
           functionName: "vote",
           args: [tokenId, pools, weights]
         });
@@ -2830,8 +3864,8 @@ var init_dist3 = __esm({
       }
       async buildClaimBribes(bribes, tokenId) {
         const tokensPerBribe = bribes.map(() => []);
-        const data = encodeFunctionData8({
-          abi: voterAbi,
+        const data = encodeFunctionData10({
+          abi: voterAbi2,
           functionName: "claimBribes",
           args: [bribes, tokensPerBribe, tokenId]
         });
@@ -2845,8 +3879,8 @@ var init_dist3 = __esm({
       }
       async buildClaimFees(fees, tokenId) {
         const tokensPerFee = fees.map(() => []);
-        const data = encodeFunctionData8({
-          abi: voterAbi,
+        const data = encodeFunctionData10({
+          abi: voterAbi2,
           functionName: "claimFees",
           args: [fees, tokensPerFee, tokenId]
         });
@@ -2859,7 +3893,7 @@ var init_dist3 = __esm({
         };
       }
     };
-    masterchefAbi = parseAbi9([
+    masterchefAbi = parseAbi11([
       "function deposit(uint256 pid, uint256 amount) external",
       "function withdraw(uint256 pid, uint256 amount) external",
       "function claim(uint256[] calldata pids) external",
@@ -2890,7 +3924,7 @@ var init_dist3 = __esm({
        */
       async buildDeposit(gauge, amount, tokenId) {
         const pid = tokenId ?? 0n;
-        const data = encodeFunctionData9({
+        const data = encodeFunctionData11({
           abi: masterchefAbi,
           functionName: "deposit",
           args: [pid, amount]
@@ -2911,7 +3945,7 @@ var init_dist3 = __esm({
        */
       async buildWithdraw(gauge, amount) {
         const pid = 0n;
-        const data = encodeFunctionData9({
+        const data = encodeFunctionData11({
           abi: masterchefAbi,
           functionName: "withdraw",
           args: [pid, amount]
@@ -2926,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]
@@ -2942,7 +3976,7 @@ var init_dist3 = __esm({
       /** Claim pending MOE rewards. IGauge interface provides no pid — defaults to pid=0. */
       async buildClaimRewards(gauge) {
         const pid = 0n;
-        const data = encodeFunctionData9({
+        const data = encodeFunctionData11({
           abi: masterchefAbi,
           functionName: "claim",
           args: [[pid]]
@@ -2957,7 +3991,7 @@ var init_dist3 = __esm({
       }
       /** Claim pending MOE rewards for a specific pid (MasterChef extension beyond IGauge). */
       async buildClaimRewardsPid(pid) {
-        const data = encodeFunctionData9({
+        const data = encodeFunctionData11({
           abi: masterchefAbi,
           functionName: "claim",
           args: [[pid]]
@@ -2975,7 +4009,7 @@ var init_dist3 = __esm({
         if (!this.rpcUrl) {
           throw DefiError.unsupported(`[${this.protocolName}] getPendingRewards requires RPC`);
         }
-        const client = createPublicClient5({ transport: http5(this.rpcUrl) });
+        const client = createPublicClient7({ transport: http7(this.rpcUrl) });
         const rewards = await client.readContract({
           address: this.masterchef,
           abi: masterchefAbi,
@@ -2989,16 +4023,16 @@ var init_dist3 = __esm({
         }));
       }
     };
-    lbRouterAbi = parseAbi10([
+    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 = parseAbi10([
+    lbFactoryAbi = parseAbi12([
       "function getNumberOfLBPairs() external view returns (uint256)",
       "function getLBPairAtIndex(uint256 index) external view returns (address)"
     ]);
-    lbPairAbi = parseAbi10([
+    lbPairAbi = parseAbi12([
       "function getLBHooksParameters() external view returns (bytes32)",
       "function getActiveId() external view returns (uint24)",
       "function getBinStep() external view returns (uint16)",
@@ -3007,7 +4041,7 @@ var init_dist3 = __esm({
       "function balanceOf(address account, uint256 id) external view returns (uint256)",
       "function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory)"
     ]);
-    lbRewarderAbi = parseAbi10([
+    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)",
@@ -3017,33 +4051,33 @@ var init_dist3 = __esm({
       "function getLBPair() external view returns (address)",
       "function getMasterChef() external view returns (address)"
     ]);
-    masterChefAbi = parseAbi10([
+    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 = parseAbi10([
+    veMoeAbi = parseAbi12([
       "function getWeight(uint256 pid) external view returns (uint256)",
       "function getTotalWeight() external view returns (uint256)",
       "function getTopPoolIds() external view returns (uint256[] memory)"
     ]);
-    lbPairBinAbi = parseAbi10([
+    lbPairBinAbi = parseAbi12([
       "function getBin(uint24 id) external view returns (uint128 reserveX, uint128 reserveY)",
       "function getActiveId() external view returns (uint24)"
     ]);
-    lbQuoterAbi2 = parseAbi10([
+    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 = parseAbi10([
+    erc20Abi2 = parseAbi12([
       "function symbol() external view returns (string)"
     ]);
-    _addressAbi = parseAbi10(["function f() external view returns (address)"]);
-    _uint256Abi = parseAbi10(["function f() external view returns (uint256)"]);
-    _boolAbi = parseAbi10(["function f() external view returns (bool)"]);
-    _rangeAbi = parseAbi10(["function f() external view returns (uint256 minBinId, uint256 maxBinId)"]);
-    _binAbi = parseAbi10(["function f() external view returns (uint128 reserveX, uint128 reserveY)"]);
-    _uint256ArrayAbi = parseAbi10(["function f() external view returns (uint256[] memory)"]);
+    _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;
@@ -3090,7 +4124,7 @@ var init_dist3 = __esm({
         let activeIdDesired = params.activeIdDesired;
         if (activeIdDesired === void 0) {
           const rpcUrl = this.requireRpc();
-          const client = createPublicClient6({ transport: http6(rpcUrl) });
+          const client = createPublicClient8({ transport: http8(rpcUrl) });
           const activeId = await client.readContract({
             address: params.pool,
             abi: lbPairAbi,
@@ -3103,7 +4137,7 @@ var init_dist3 = __esm({
           deltaIds.push(d);
         }
         const { distributionX, distributionY } = buildUniformDistribution(deltaIds);
-        const data = encodeFunctionData10({
+        const data = encodeFunctionData12({
           abi: lbRouterAbi,
           functionName: "addLiquidity",
           args: [
@@ -3143,7 +4177,7 @@ var init_dist3 = __esm({
        */
       async buildRemoveLiquidity(params) {
         const deadline = params.deadline ?? BigInt("18446744073709551615");
-        const data = encodeFunctionData10({
+        const data = encodeFunctionData12({
           abi: lbRouterAbi,
           functionName: "removeLiquidity",
           args: [
@@ -3172,7 +4206,7 @@ var init_dist3 = __esm({
        */
       async autoDetectBins(pool) {
         const rpcUrl = this.requireRpc();
-        const client = createPublicClient6({ transport: http6(rpcUrl) });
+        const client = createPublicClient8({ transport: http8(rpcUrl) });
         const hooksParams = await client.readContract({
           address: pool,
           abi: lbPairAbi,
@@ -3207,7 +4241,7 @@ var init_dist3 = __esm({
        */
       async getPendingRewards(user, pool, binIds) {
         const rpcUrl = this.requireRpc();
-        const client = createPublicClient6({ transport: http6(rpcUrl) });
+        const client = createPublicClient8({ transport: http8(rpcUrl) });
         const hooksParams = await client.readContract({
           address: pool,
           abi: lbPairAbi,
@@ -3256,7 +4290,7 @@ var init_dist3 = __esm({
        */
       async buildClaimRewards(user, pool, binIds) {
         const rpcUrl = this.requireRpc();
-        const client = createPublicClient6({ transport: http6(rpcUrl) });
+        const client = createPublicClient8({ transport: http8(rpcUrl) });
         const hooksParams = await client.readContract({
           address: pool,
           abi: lbPairAbi,
@@ -3278,7 +4312,7 @@ var init_dist3 = __esm({
           resolvedBinIds = [];
           for (let b = min; b <= max; b++) resolvedBinIds.push(b);
         }
-        const data = encodeFunctionData10({
+        const data = encodeFunctionData12({
           abi: lbRewarderAbi,
           functionName: "claim",
           args: [user, resolvedBinIds.map(BigInt)]
@@ -3306,7 +4340,7 @@ var init_dist3 = __esm({
        */
       async discoverRewardedPools() {
         const rpcUrl = this.requireRpc();
-        const client = createPublicClient6({ transport: http6(rpcUrl) });
+        const client = createPublicClient8({ transport: http8(rpcUrl) });
         const pairCount = await client.readContract({
           address: this.lbFactory,
           abi: lbFactoryAbi,
@@ -3316,14 +4350,14 @@ var init_dist3 = __esm({
         if (count === 0) return [];
         const batch1Calls = Array.from({ length: count }, (_, i) => [
           this.lbFactory,
-          encodeFunctionData10({ abi: lbFactoryAbi, functionName: "getLBPairAtIndex", args: [BigInt(i)] })
+          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,
-          encodeFunctionData10({ abi: lbPairAbi, functionName: "getLBHooksParameters" })
+          encodeFunctionData12({ abi: lbPairAbi, functionName: "getLBHooksParameters" })
         ]);
         const batch2Results = await multicallRead(rpcUrl, batch2Calls);
         const rewardedPairs = [];
@@ -3332,8 +4366,8 @@ var init_dist3 = __esm({
           if (!raw) continue;
           let hooksBytes;
           try {
-            const _bytes32Abi = parseAbi10(["function f() external view returns (bytes32)"]);
-            hooksBytes = decodeFunctionResult22({ abi: _bytes32Abi, functionName: "f", data: raw });
+            const _bytes32Abi = parseAbi12(["function f() external view returns (bytes32)"]);
+            hooksBytes = decodeFunctionResult4({ abi: _bytes32Abi, functionName: "f", data: raw });
           } catch {
             continue;
           }
@@ -3345,17 +4379,17 @@ var init_dist3 = __esm({
         if (rewardedPairs.length === 0) return [];
         const batch3Calls = [];
         for (const { rewarder } of rewardedPairs) {
-          batch3Calls.push([rewarder, encodeFunctionData10({ abi: lbRewarderAbi, functionName: "isStopped" })]);
-          batch3Calls.push([rewarder, encodeFunctionData10({ abi: lbRewarderAbi, functionName: "getRewardedRange" })]);
-          batch3Calls.push([rewarder, encodeFunctionData10({ abi: lbRewarderAbi, functionName: "getRewardToken" })]);
-          batch3Calls.push([rewarder, encodeFunctionData10({ abi: lbRewarderAbi, functionName: "getPid" })]);
-          batch3Calls.push([rewarder, encodeFunctionData10({ abi: lbRewarderAbi, functionName: "getMasterChef" })]);
+          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, encodeFunctionData10({ abi: lbPairAbi, functionName: "getTokenX" })]);
-          batch4aCalls.push([pool, encodeFunctionData10({ abi: lbPairAbi, functionName: "getTokenY" })]);
+          batch4aCalls.push([pool, encodeFunctionData12({ abi: lbPairAbi, functionName: "getTokenX" })]);
+          batch4aCalls.push([pool, encodeFunctionData12({ abi: lbPairAbi, functionName: "getTokenY" })]);
         }
         const batch4aResults = await multicallRead(rpcUrl, batch4aCalls);
         const tokenXAddresses = [];
@@ -3369,7 +4403,7 @@ var init_dist3 = __esm({
         );
         const batch4bCalls = uniqueTokens.map((token) => [
           token,
-          encodeFunctionData10({ abi: erc20Abi2, functionName: "symbol" })
+          encodeFunctionData12({ abi: erc20Abi2, functionName: "symbol" })
         ]);
         const batch4bResults = await multicallRead(rpcUrl, batch4bCalls);
         const symbolMap = /* @__PURE__ */ new Map();
@@ -3400,11 +4434,11 @@ var init_dist3 = __esm({
             functionName: "getVeMoe"
           });
           const batch5Calls = [
-            [masterChefAddr, encodeFunctionData10({ abi: masterChefAbi, functionName: "getMoePerSecond" })],
-            [masterChefAddr, encodeFunctionData10({ abi: masterChefAbi, functionName: "getTreasuryShare" })],
-            [masterChefAddr, encodeFunctionData10({ abi: masterChefAbi, functionName: "getStaticShare" })],
-            [veMoeAddr, encodeFunctionData10({ abi: veMoeAbi, functionName: "getTotalWeight" })],
-            [veMoeAddr, encodeFunctionData10({ abi: veMoeAbi, functionName: "getTopPoolIds" })]
+            [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;
@@ -3421,7 +4455,7 @@ var init_dist3 = __esm({
         if (veMoeAddr && rewardedPairs.length > 0) {
           const batch6Calls = poolData.map((d) => [
             veMoeAddr,
-            encodeFunctionData10({ abi: veMoeAbi, functionName: "getWeight", args: [BigInt(d.pid)] })
+            encodeFunctionData12({ abi: veMoeAbi, functionName: "getWeight", args: [BigInt(d.pid)] })
           ]);
           const batch6Results = await multicallRead(rpcUrl, batch6Calls);
           for (let i = 0; i < poolData.length; i++) {
@@ -3468,7 +4502,7 @@ var init_dist3 = __esm({
         if (binRequests.length > 0) {
           const batch7Calls = binRequests.map(({ poolIdx, binId }) => [
             rewardedPairs[poolIdx].pool,
-            encodeFunctionData10({ abi: lbPairBinAbi, functionName: "getBin", args: [binId] })
+            encodeFunctionData12({ abi: lbPairBinAbi, functionName: "getBin", args: [binId] })
           ]);
           const batch7Results = await multicallRead(rpcUrl, batch7Calls);
           for (let j = 0; j < binRequests.length; j++) {
@@ -3560,7 +4594,7 @@ var init_dist3 = __esm({
        */
       async getUserPositions(user, pool, binIds) {
         const rpcUrl = this.requireRpc();
-        const client = createPublicClient6({ transport: http6(rpcUrl) });
+        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);
@@ -3573,7 +4607,384 @@ var init_dist3 = __esm({
         return resolvedBinIds.map((binId, i) => ({ binId, balance: balances[i] ?? 0n })).filter((p) => p.balance > 0n);
       }
     };
-    POOL_ABI = parseAbi11([
+    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}] Collect + claim rewards for NFT #${tokenId} in pool ${pool}`,
+          to: this.farmingCenter,
+          data: encodeMulticall(calls),
+          value: 0n,
+          gas_estimate: 4e5
+        };
+      }
+      /**
+       * 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 KITTEN + WHYPE farming rewards to ${owner}`,
+          to: this.farmingCenter,
+          data: encodeMulticall(calls),
+          value: 0n,
+          gas_estimate: 2e5
+        };
+      }
+      /**
+       * 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 = createPublicClient9({ transport: http9(this.rpcUrl) });
+        const result = await client.readContract({
+          address: this.eternalFarming,
+          abi: eternalFarmingAbi,
+          functionName: "getRewardInfo",
+          args: [key, tokenId]
+        });
+        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 = 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)",
@@ -3581,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 = parseAbi11([
+    ERC20_ABI = parseAbi14([
       "function totalSupply() external view returns (uint256)"
     ]);
-    INCENTIVES_ABI = parseAbi11([
+    INCENTIVES_ABI = parseAbi14([
       "function getIncentivesController() external view returns (address)"
     ]);
-    REWARDS_CONTROLLER_ABI = parseAbi11([
+    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 = parseAbi11([
+    POOL_PROVIDER_ABI = parseAbi14([
       "function ADDRESSES_PROVIDER() external view returns (address)"
     ]);
-    ADDRESSES_PROVIDER_ABI = parseAbi11([
+    ADDRESSES_PROVIDER_ABI = parseAbi14([
       "function getPriceOracle() external view returns (address)"
     ]);
-    ORACLE_ABI = parseAbi11([
+    ORACLE_ABI = parseAbi14([
       "function getAssetPrice(address asset) external view returns (uint256)",
       "function BASE_CURRENCY_UNIT() external view returns (uint256)"
     ]);
-    ERC20_DECIMALS_ABI = parseAbi11([
+    ERC20_DECIMALS_ABI = parseAbi14([
       "function decimals() external view returns (uint8)"
     ]);
     AaveV3Adapter = class {
@@ -3619,7 +5030,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildSupply(params) {
-        const data = encodeFunctionData11({
+        const data = encodeFunctionData14({
           abi: POOL_ABI,
           functionName: "supply",
           args: [params.asset, params.amount, params.on_behalf_of, 0]
@@ -3635,7 +5046,7 @@ var init_dist3 = __esm({
       }
       async buildBorrow(params) {
         const rateMode = params.interest_rate_mode === InterestRateMode.Stable ? 1n : 2n;
-        const data = encodeFunctionData11({
+        const data = encodeFunctionData14({
           abi: POOL_ABI,
           functionName: "borrow",
           args: [params.asset, params.amount, rateMode, 0, params.on_behalf_of]
@@ -3650,7 +5061,7 @@ var init_dist3 = __esm({
       }
       async buildRepay(params) {
         const rateMode = params.interest_rate_mode === InterestRateMode.Stable ? 1n : 2n;
-        const data = encodeFunctionData11({
+        const data = encodeFunctionData14({
           abi: POOL_ABI,
           functionName: "repay",
           args: [params.asset, params.amount, rateMode, params.on_behalf_of]
@@ -3665,7 +5076,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(params) {
-        const data = encodeFunctionData11({
+        const data = encodeFunctionData14({
           abi: POOL_ABI,
           functionName: "withdraw",
           args: [params.asset, params.amount, params.to]
@@ -3680,7 +5091,7 @@ var init_dist3 = __esm({
       }
       async getRates(asset) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const reserveCallData = encodeFunctionData11({
+        const reserveCallData = encodeFunctionData14({
           abi: POOL_ABI,
           functionName: "getReserveData",
           args: [asset]
@@ -3707,8 +5118,8 @@ var init_dist3 = __esm({
         const aTokenAddress = result[8];
         const variableDebtTokenAddress = result[10];
         const [supplyRaw, borrowRaw] = await multicallRead(this.rpcUrl, [
-          [aTokenAddress, encodeFunctionData11({ abi: ERC20_ABI, functionName: "totalSupply" })],
-          [variableDebtTokenAddress, encodeFunctionData11({ abi: ERC20_ABI, functionName: "totalSupply" })]
+          [aTokenAddress, encodeFunctionData14({ abi: ERC20_ABI, functionName: "totalSupply" })],
+          [variableDebtTokenAddress, encodeFunctionData14({ abi: ERC20_ABI, functionName: "totalSupply" })]
         ]);
         const totalSupply = decodeU256(supplyRaw ?? null);
         const totalBorrow = decodeU256(borrowRaw ?? null);
@@ -3719,24 +5130,24 @@ var init_dist3 = __esm({
         const borrowEmissions = [];
         try {
           const [controllerRaw] = await multicallRead(this.rpcUrl, [
-            [aTokenAddress, encodeFunctionData11({ abi: INCENTIVES_ABI, functionName: "getIncentivesController" })]
+            [aTokenAddress, encodeFunctionData14({ abi: INCENTIVES_ABI, functionName: "getIncentivesController" })]
           ]);
-          const controllerAddr = decodeAddress(controllerRaw ?? null);
-          if (controllerAddr && controllerAddr !== zeroAddress5) {
+          const controllerAddr = decodeAddress4(controllerRaw ?? null);
+          if (controllerAddr && controllerAddr !== zeroAddress8) {
             const [supplyRewardsRaw, borrowRewardsRaw] = await multicallRead(this.rpcUrl, [
-              [controllerAddr, encodeFunctionData11({ abi: REWARDS_CONTROLLER_ABI, functionName: "getRewardsByAsset", args: [aTokenAddress] })],
-              [controllerAddr, encodeFunctionData11({ abi: REWARDS_CONTROLLER_ABI, functionName: "getRewardsByAsset", args: [variableDebtTokenAddress] })]
+              [controllerAddr, encodeFunctionData14({ abi: REWARDS_CONTROLLER_ABI, functionName: "getRewardsByAsset", args: [aTokenAddress] })],
+              [controllerAddr, encodeFunctionData14({ abi: REWARDS_CONTROLLER_ABI, functionName: "getRewardsByAsset", args: [variableDebtTokenAddress] })]
             ]);
             const supplyRewards = decodeAddressArray(supplyRewardsRaw ?? null);
             const borrowRewards = decodeAddressArray(borrowRewardsRaw ?? null);
             const rewardsDataCalls = [
               ...supplyRewards.map((reward) => [
                 controllerAddr,
-                encodeFunctionData11({ abi: REWARDS_CONTROLLER_ABI, functionName: "getRewardsData", args: [aTokenAddress, reward] })
+                encodeFunctionData14({ abi: REWARDS_CONTROLLER_ABI, functionName: "getRewardsData", args: [aTokenAddress, reward] })
               ]),
               ...borrowRewards.map((reward) => [
                 controllerAddr,
-                encodeFunctionData11({ abi: REWARDS_CONTROLLER_ABI, functionName: "getRewardsData", args: [variableDebtTokenAddress, reward] })
+                encodeFunctionData14({ abi: REWARDS_CONTROLLER_ABI, functionName: "getRewardsData", args: [variableDebtTokenAddress, reward] })
               ])
             ];
             if (rewardsDataCalls.length > 0) {
@@ -3768,19 +5179,19 @@ var init_dist3 = __esm({
         if ((hasSupplyRewards || hasBorrowRewards) && totalSupply > 0n) {
           try {
             const [providerRaw] = await multicallRead(this.rpcUrl, [
-              [this.pool, encodeFunctionData11({ abi: POOL_PROVIDER_ABI, functionName: "ADDRESSES_PROVIDER" })]
+              [this.pool, encodeFunctionData14({ abi: POOL_PROVIDER_ABI, functionName: "ADDRESSES_PROVIDER" })]
             ]);
-            const providerAddr = decodeAddress(providerRaw ?? null);
+            const providerAddr = decodeAddress4(providerRaw ?? null);
             if (!providerAddr) throw new Error("No provider address");
             const [oracleRaw] = await multicallRead(this.rpcUrl, [
-              [providerAddr, encodeFunctionData11({ abi: ADDRESSES_PROVIDER_ABI, functionName: "getPriceOracle" })]
+              [providerAddr, encodeFunctionData14({ abi: ADDRESSES_PROVIDER_ABI, functionName: "getPriceOracle" })]
             ]);
-            const oracleAddr = decodeAddress(oracleRaw ?? null);
+            const oracleAddr = decodeAddress4(oracleRaw ?? null);
             if (!oracleAddr) throw new Error("No oracle address");
             const [assetPriceRaw, baseCurrencyUnitRaw, assetDecimalsRaw] = await multicallRead(this.rpcUrl, [
-              [oracleAddr, encodeFunctionData11({ abi: ORACLE_ABI, functionName: "getAssetPrice", args: [asset] })],
-              [oracleAddr, encodeFunctionData11({ abi: ORACLE_ABI, functionName: "BASE_CURRENCY_UNIT" })],
-              [asset, encodeFunctionData11({ abi: ERC20_DECIMALS_ABI, functionName: "decimals" })]
+              [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 assetPrice = decodeU256(assetPriceRaw ?? null);
             const baseCurrencyUnit = decodeU256(baseCurrencyUnitRaw ?? null);
@@ -3790,8 +5201,8 @@ var init_dist3 = __esm({
             const assetDecimalsDivisor = 10 ** assetDecimals;
             const allRewardTokens = Array.from(/* @__PURE__ */ new Set([...supplyRewardTokens, ...borrowRewardTokens]));
             const rewardPriceCalls = allRewardTokens.flatMap((token) => [
-              [oracleAddr, encodeFunctionData11({ abi: ORACLE_ABI, functionName: "getAssetPrice", args: [token] })],
-              [token, encodeFunctionData11({ abi: ERC20_DECIMALS_ABI, functionName: "decimals" })]
+              [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();
@@ -3864,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,
@@ -3879,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,
@@ -3891,7 +5302,7 @@ var init_dist3 = __esm({
         };
       }
     };
-    POOL_ABI2 = parseAbi12([
+    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)",
@@ -3904,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 = parseAbi12([
+    ERC20_ABI2 = parseAbi15([
       "function totalSupply() external view returns (uint256)"
     ]);
     AaveV2Adapter = class {
@@ -3922,7 +5333,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildSupply(params) {
-        const data = encodeFunctionData12({
+        const data = encodeFunctionData15({
           abi: POOL_ABI2,
           functionName: "deposit",
           args: [params.asset, params.amount, params.on_behalf_of, 0]
@@ -3938,7 +5349,7 @@ var init_dist3 = __esm({
       }
       async buildBorrow(params) {
         const rateMode = params.interest_rate_mode === InterestRateMode.Stable ? 1n : 2n;
-        const data = encodeFunctionData12({
+        const data = encodeFunctionData15({
           abi: POOL_ABI2,
           functionName: "borrow",
           args: [params.asset, params.amount, rateMode, 0, params.on_behalf_of]
@@ -3953,7 +5364,7 @@ var init_dist3 = __esm({
       }
       async buildRepay(params) {
         const rateMode = params.interest_rate_mode === InterestRateMode.Stable ? 1n : 2n;
-        const data = encodeFunctionData12({
+        const data = encodeFunctionData15({
           abi: POOL_ABI2,
           functionName: "repay",
           args: [params.asset, params.amount, rateMode, params.on_behalf_of]
@@ -3968,7 +5379,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(params) {
-        const data = encodeFunctionData12({
+        const data = encodeFunctionData15({
           abi: POOL_ABI2,
           functionName: "withdraw",
           args: [params.asset, params.amount, params.to]
@@ -3983,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,
@@ -4029,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,
@@ -4044,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,
@@ -4056,7 +5467,7 @@ var init_dist3 = __esm({
         };
       }
     };
-    ORACLE_ABI2 = parseAbi13([
+    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)"
@@ -4077,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,
@@ -4104,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,
@@ -4133,7 +5544,7 @@ var init_dist3 = __esm({
         });
       }
     };
-    CTOKEN_ABI = parseAbi14([
+    CTOKEN_ABI = parseAbi17([
       "function supplyRatePerBlock() external view returns (uint256)",
       "function borrowRatePerBlock() external view returns (uint256)",
       "function totalSupply() external view returns (uint256)",
@@ -4160,7 +5571,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildSupply(params) {
-        const data = encodeFunctionData13({
+        const data = encodeFunctionData16({
           abi: CTOKEN_ABI,
           functionName: "mint",
           args: [params.amount]
@@ -4174,7 +5585,7 @@ var init_dist3 = __esm({
         };
       }
       async buildBorrow(params) {
-        const data = encodeFunctionData13({
+        const data = encodeFunctionData16({
           abi: CTOKEN_ABI,
           functionName: "borrow",
           args: [params.amount]
@@ -4188,7 +5599,7 @@ var init_dist3 = __esm({
         };
       }
       async buildRepay(params) {
-        const data = encodeFunctionData13({
+        const data = encodeFunctionData16({
           abi: CTOKEN_ABI,
           functionName: "repayBorrow",
           args: [params.amount]
@@ -4202,7 +5613,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(params) {
-        const data = encodeFunctionData13({
+        const data = encodeFunctionData16({
           abi: CTOKEN_ABI,
           functionName: "redeem",
           args: [params.amount]
@@ -4217,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}`);
@@ -4251,7 +5662,7 @@ var init_dist3 = __esm({
         );
       }
     };
-    COMET_ABI = parseAbi15([
+    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)",
@@ -4277,7 +5688,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildSupply(params) {
-        const data = encodeFunctionData14({
+        const data = encodeFunctionData17({
           abi: COMET_ABI,
           functionName: "supply",
           args: [params.asset, params.amount]
@@ -4291,7 +5702,7 @@ var init_dist3 = __esm({
         };
       }
       async buildBorrow(params) {
-        const data = encodeFunctionData14({
+        const data = encodeFunctionData17({
           abi: COMET_ABI,
           functionName: "withdraw",
           args: [params.asset, params.amount]
@@ -4305,7 +5716,7 @@ var init_dist3 = __esm({
         };
       }
       async buildRepay(params) {
-        const data = encodeFunctionData14({
+        const data = encodeFunctionData17({
           abi: COMET_ABI,
           functionName: "supply",
           args: [params.asset, params.amount]
@@ -4319,7 +5730,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(params) {
-        const data = encodeFunctionData14({
+        const data = encodeFunctionData17({
           abi: COMET_ABI,
           functionName: "withdraw",
           args: [params.asset, params.amount]
@@ -4334,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,
@@ -4373,7 +5784,7 @@ var init_dist3 = __esm({
         );
       }
     };
-    EULER_VAULT_ABI = parseAbi16([
+    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)",
@@ -4399,7 +5810,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildSupply(params) {
-        const data = encodeFunctionData15({
+        const data = encodeFunctionData18({
           abi: EULER_VAULT_ABI,
           functionName: "deposit",
           args: [params.amount, params.on_behalf_of]
@@ -4413,7 +5824,7 @@ var init_dist3 = __esm({
         };
       }
       async buildBorrow(params) {
-        const data = encodeFunctionData15({
+        const data = encodeFunctionData18({
           abi: EULER_VAULT_ABI,
           functionName: "borrow",
           args: [params.amount, params.on_behalf_of]
@@ -4427,7 +5838,7 @@ var init_dist3 = __esm({
         };
       }
       async buildRepay(params) {
-        const data = encodeFunctionData15({
+        const data = encodeFunctionData18({
           abi: EULER_VAULT_ABI,
           functionName: "repay",
           args: [params.amount, params.on_behalf_of]
@@ -4441,7 +5852,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(params) {
-        const data = encodeFunctionData15({
+        const data = encodeFunctionData18({
           abi: EULER_VAULT_ABI,
           functionName: "withdraw",
           args: [params.amount, params.to, params.to]
@@ -4456,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}`);
@@ -4490,7 +5901,7 @@ var init_dist3 = __esm({
         );
       }
     };
-    MORPHO_ABI = parseAbi17([
+    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)",
@@ -4498,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 = parseAbi17([
+    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 = parseAbi17([
+    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;
@@ -4527,7 +5938,7 @@ var init_dist3 = __esm({
       }
       async buildSupply(params) {
         const market = defaultMarketParams(params.asset);
-        const data = encodeFunctionData16({
+        const data = encodeFunctionData19({
           abi: MORPHO_ABI,
           functionName: "supply",
           args: [market, params.amount, 0n, params.on_behalf_of, "0x"]
@@ -4542,7 +5953,7 @@ var init_dist3 = __esm({
       }
       async buildBorrow(params) {
         const market = defaultMarketParams(params.asset);
-        const data = encodeFunctionData16({
+        const data = encodeFunctionData19({
           abi: MORPHO_ABI,
           functionName: "borrow",
           args: [market, params.amount, 0n, params.on_behalf_of, params.on_behalf_of]
@@ -4557,7 +5968,7 @@ var init_dist3 = __esm({
       }
       async buildRepay(params) {
         const market = defaultMarketParams(params.asset);
-        const data = encodeFunctionData16({
+        const data = encodeFunctionData19({
           abi: MORPHO_ABI,
           functionName: "repay",
           args: [market, params.amount, 0n, params.on_behalf_of, "0x"]
@@ -4572,7 +5983,7 @@ var init_dist3 = __esm({
       }
       async buildWithdraw(params) {
         const market = defaultMarketParams(params.asset);
-        const data = encodeFunctionData16({
+        const data = encodeFunctionData19({
           abi: MORPHO_ABI,
           functionName: "withdraw",
           args: [market, params.amount, 0n, params.to, params.to]
@@ -4591,7 +6002,7 @@ var init_dist3 = __esm({
           throw DefiError.contractError(`[${this.protocolName}] No MetaMorpho vault configured for rate query`);
         }
         const [queueLenRaw] = await multicallRead(this.rpcUrl, [
-          [this.defaultVault, encodeFunctionData16({ abi: META_MORPHO_ABI, functionName: "supplyQueueLength" })]
+          [this.defaultVault, encodeFunctionData19({ abi: META_MORPHO_ABI, functionName: "supplyQueueLength" })]
         ]).catch((e) => {
           throw DefiError.rpcError(`[${this.protocolName}] supplyQueueLength failed: ${e}`);
         });
@@ -4608,7 +6019,7 @@ var init_dist3 = __esm({
           };
         }
         const [marketIdRaw] = await multicallRead(this.rpcUrl, [
-          [this.defaultVault, encodeFunctionData16({ abi: META_MORPHO_ABI, functionName: "supplyQueue", args: [0n] })]
+          [this.defaultVault, encodeFunctionData19({ abi: META_MORPHO_ABI, functionName: "supplyQueue", args: [0n] })]
         ]).catch((e) => {
           throw DefiError.rpcError(`[${this.protocolName}] supplyQueue(0) failed: ${e}`);
         });
@@ -4617,8 +6028,8 @@ var init_dist3 = __esm({
         }
         const marketId = marketIdRaw.slice(0, 66);
         const [marketRaw, paramsRaw] = await multicallRead(this.rpcUrl, [
-          [this.morpho, encodeFunctionData16({ abi: MORPHO_ABI, functionName: "market", args: [marketId] })],
-          [this.morpho, encodeFunctionData16({ abi: MORPHO_ABI, functionName: "idToMarketParams", args: [marketId] })]
+          [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}`);
         });
@@ -4635,7 +6046,7 @@ var init_dist3 = __esm({
         const irmMarket = { totalSupplyAssets, totalSupplyShares, totalBorrowAssets, totalBorrowShares, lastUpdate, fee };
         const borrowRatePerSec = await (async () => {
           const [borrowRateRaw] = await multicallRead(this.rpcUrl, [
-            [irm, encodeFunctionData16({ abi: IRM_ABI, functionName: "borrowRateView", args: [irmMarketParams, irmMarket] })]
+            [irm, encodeFunctionData19({ abi: IRM_ABI, functionName: "borrowRateView", args: [irmMarketParams, irmMarket] })]
           ]).catch((e) => {
             throw DefiError.rpcError(`[${this.protocolName}] borrowRateView failed: ${e}`);
           });
@@ -4661,18 +6072,18 @@ var init_dist3 = __esm({
         );
       }
     };
-    BORROWER_OPS_ABI = parseAbi18([
+    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 = parseAbi18([
+    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 = parseAbi18([
+    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 = parseAbi18([
+    SORTED_TROVES_ABI = parseAbi21([
       "function findInsertPosition(uint256 _annualInterestRate, uint256 _prevId, uint256 _nextId) external view returns (uint256 prevId, uint256 nextId)"
     ]);
     FelixCdpAdapter = class {
@@ -4700,7 +6111,7 @@ var init_dist3 = __esm({
         if (!this.hintHelpers || !this.sortedTroves || !this.rpcUrl) {
           return [0n, 0n];
         }
-        const client = createPublicClient13({ transport: http13(this.rpcUrl) });
+        const client = createPublicClient16({ transport: http16(this.rpcUrl) });
         const approxResult = await client.readContract({
           address: this.hintHelpers,
           abi: HINT_HELPERS_ABI,
@@ -4723,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 = encodeFunctionData17({
+        const data = encodeFunctionData20({
           abi: BORROWER_OPS_ABI,
           functionName: "openTrove",
           args: [
@@ -4752,7 +6163,7 @@ var init_dist3 = __esm({
       async buildAdjust(params) {
         const collChange = params.collateral_delta ?? 0n;
         const debtChange = params.debt_delta ?? 0n;
-        const data = encodeFunctionData17({
+        const data = encodeFunctionData20({
           abi: BORROWER_OPS_ABI,
           functionName: "adjustTrove",
           args: [
@@ -4775,7 +6186,7 @@ var init_dist3 = __esm({
         };
       }
       async buildClose(params) {
-        const data = encodeFunctionData17({
+        const data = encodeFunctionData20({
           abi: BORROWER_OPS_ABI,
           functionName: "closeTrove",
           args: [params.cdp_id]
@@ -4791,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 = createPublicClient13({ transport: http13(this.rpcUrl) });
+        const client = createPublicClient16({ transport: http16(this.rpcUrl) });
         const data = await client.readContract({
           address: this.troveManager,
           abi: TROVE_MANAGER_ABI,
@@ -4809,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
@@ -4824,7 +6235,7 @@ var init_dist3 = __esm({
         };
       }
     };
-    PRICE_FEED_ABI = parseAbi19([
+    PRICE_FEED_ABI = parseAbi222([
       "function fetchPrice() external view returns (uint256 price, bool isNewOracleFailureDetected)",
       "function lastGoodPrice() external view returns (uint256)"
     ]);
@@ -4850,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 = createPublicClient14({ transport: http14(this.rpcUrl) });
+        const client = createPublicClient17({ transport: http17(this.rpcUrl) });
         let priceVal;
         try {
           const result = await client.readContract({
@@ -4889,7 +6300,7 @@ var init_dist3 = __esm({
         return results;
       }
     };
-    ERC4626_ABI = parseAbi20([
+    ERC4626_ABI = parseAbi23([
       "function asset() external view returns (address)",
       "function totalAssets() external view returns (uint256)",
       "function totalSupply() external view returns (uint256)",
@@ -4913,7 +6324,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildDeposit(assets, receiver) {
-        const data = encodeFunctionData18({
+        const data = encodeFunctionData21({
           abi: ERC4626_ABI,
           functionName: "deposit",
           args: [assets, receiver]
@@ -4927,7 +6338,7 @@ var init_dist3 = __esm({
         };
       }
       async buildWithdraw(assets, receiver, owner) {
-        const data = encodeFunctionData18({
+        const data = encodeFunctionData21({
           abi: ERC4626_ABI,
           functionName: "withdraw",
           args: [assets, receiver, owner]
@@ -4942,7 +6353,7 @@ var init_dist3 = __esm({
       }
       async totalAssets() {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient15({ transport: http15(this.rpcUrl) });
+        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
         return client.readContract({
           address: this.vaultAddress,
           abi: ERC4626_ABI,
@@ -4953,7 +6364,7 @@ var init_dist3 = __esm({
       }
       async convertToShares(assets) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient15({ transport: http15(this.rpcUrl) });
+        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
         return client.readContract({
           address: this.vaultAddress,
           abi: ERC4626_ABI,
@@ -4965,7 +6376,7 @@ var init_dist3 = __esm({
       }
       async convertToAssets(shares) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient15({ transport: http15(this.rpcUrl) });
+        const client = createPublicClient18({ transport: http18(this.rpcUrl) });
         return client.readContract({
           address: this.vaultAddress,
           abi: ERC4626_ABI,
@@ -4977,7 +6388,7 @@ var init_dist3 = __esm({
       }
       async getVaultInfo() {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient15({ transport: http15(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}`);
@@ -4998,7 +6409,7 @@ var init_dist3 = __esm({
         };
       }
     };
-    GENERIC_LST_ABI = parseAbi21([
+    GENERIC_LST_ABI = parseAbi24([
       "function stake() external payable returns (uint256)",
       "function unstake(uint256 amount) external returns (uint256)"
     ]);
@@ -5015,7 +6426,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildStake(params) {
-        const data = encodeFunctionData19({ 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,
@@ -5025,7 +6436,7 @@ var init_dist3 = __esm({
         };
       }
       async buildUnstake(params) {
-        const data = encodeFunctionData19({
+        const data = encodeFunctionData222({
           abi: GENERIC_LST_ABI,
           functionName: "unstake",
           args: [params.amount]
@@ -5042,11 +6453,11 @@ var init_dist3 = __esm({
         throw DefiError.unsupported(`[${this.protocolName}] getInfo requires RPC`);
       }
     };
-    STHYPE_ABI = parseAbi222([
+    STHYPE_ABI = parseAbi25([
       "function submit(address referral) external payable returns (uint256)",
       "function requestWithdrawals(uint256[] amounts, address owner) external returns (uint256[] requestIds)"
     ]);
-    ERC20_ABI3 = parseAbi222([
+    ERC20_ABI3 = parseAbi25([
       "function totalSupply() external view returns (uint256)"
     ]);
     StHypeAdapter = class {
@@ -5066,10 +6477,10 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildStake(params) {
-        const data = encodeFunctionData20({
+        const data = encodeFunctionData23({
           abi: STHYPE_ABI,
           functionName: "submit",
-          args: [zeroAddress9]
+          args: [zeroAddress12]
         });
         return {
           description: `[${this.protocolName}] Stake ${params.amount} HYPE for stHYPE`,
@@ -5080,7 +6491,7 @@ var init_dist3 = __esm({
         };
       }
       async buildUnstake(params) {
-        const data = encodeFunctionData20({
+        const data = encodeFunctionData23({
           abi: STHYPE_ABI,
           functionName: "requestWithdrawals",
           args: [[params.amount], params.recipient]
@@ -5095,7 +6506,7 @@ var init_dist3 = __esm({
       }
       async getInfo() {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient16({ transport: http16(this.rpcUrl) });
+        const client = createPublicClient19({ transport: http19(this.rpcUrl) });
         const tokenAddr = this.sthypeToken ?? this.staking;
         const totalSupply = await client.readContract({
           address: tokenAddr,
@@ -5106,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 = parseAbi23([
+    KINETIQ_ABI = parseAbi26([
       "function stake() external payable returns (uint256)",
       "function requestUnstake(uint256 amount) external returns (uint256)",
       "function totalStaked() external view returns (uint256)"
     ]);
-    ORACLE_ABI3 = parseAbi23([
+    ORACLE_ABI3 = parseAbi26([
       "function getAssetPrice(address asset) external view returns (uint256)"
     ]);
     WHYPE = "0x5555555555555555555555555555555555555555";
@@ -5140,7 +6551,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildStake(params) {
-        const data = encodeFunctionData21({ 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,
@@ -5150,7 +6561,7 @@ var init_dist3 = __esm({
         };
       }
       async buildUnstake(params) {
-        const data = encodeFunctionData21({
+        const data = encodeFunctionData24({
           abi: KINETIQ_ABI,
           functionName: "requestUnstake",
           args: [params.amount]
@@ -5165,7 +6576,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 = createPublicClient20({ transport: http20(this.rpcUrl) });
         const totalStaked = await client.readContract({
           address: this.staking,
           abi: KINETIQ_ABI,
@@ -5180,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
@@ -5236,7 +6647,7 @@ var init_dist3 = __esm({
         );
       }
     };
-    HLP_ABI = parseAbi24([
+    HLP_ABI = parseAbi27([
       "function deposit(uint256 amount) external returns (uint256)",
       "function withdraw(uint256 shares) external returns (uint256)"
     ]);
@@ -5253,7 +6664,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildOpenPosition(params) {
-        const data = encodeFunctionData222({
+        const data = encodeFunctionData25({
           abi: HLP_ABI,
           functionName: "deposit",
           args: [params.collateral]
@@ -5267,7 +6678,7 @@ var init_dist3 = __esm({
         };
       }
       async buildClosePosition(params) {
-        const data = encodeFunctionData222({
+        const data = encodeFunctionData25({
           abi: HLP_ABI,
           functionName: "withdraw",
           args: [params.size]
@@ -5302,7 +6713,7 @@ var init_dist3 = __esm({
         );
       }
     };
-    RYSK_ABI = parseAbi25([
+    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)"
     ]);
@@ -5319,7 +6730,7 @@ var init_dist3 = __esm({
         return this.protocolName;
       }
       async buildBuy(params) {
-        const data = encodeFunctionData23({
+        const data = encodeFunctionData26({
           abi: RYSK_ABI,
           functionName: "openOption",
           args: [
@@ -5339,7 +6750,7 @@ var init_dist3 = __esm({
         };
       }
       async buildSell(params) {
-        const data = encodeFunctionData23({
+        const data = encodeFunctionData26({
           abi: RYSK_ABI,
           functionName: "closeOption",
           args: [
@@ -5380,7 +6791,7 @@ var init_dist3 = __esm({
         );
       }
     };
-    ERC721_ABI = parseAbi26([
+    ERC721_ABI = parseAbi29([
       "function name() returns (string)",
       "function symbol() returns (string)",
       "function totalSupply() returns (uint256)",
@@ -5400,7 +6811,7 @@ var init_dist3 = __esm({
       }
       async getCollectionInfo(collection) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient18({ transport: http18(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}`);
@@ -5419,7 +6830,7 @@ var init_dist3 = __esm({
       }
       async getTokenInfo(collection, tokenId) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient18({ transport: http18(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}`);
@@ -5435,7 +6846,7 @@ var init_dist3 = __esm({
       }
       async getBalance(owner, collection) {
         if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-        const client = createPublicClient18({ transport: http18(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}`);
         });
@@ -5492,9 +6903,9 @@ import { z } from "zod";
 // src/executor.ts
 init_dist2();
 init_dist2();
-import { createPublicClient as createPublicClient19, createWalletClient, http as http19, parseAbi as parseAbi27, encodeFunctionData as encodeFunctionData24 } from "viem";
+import { createPublicClient as createPublicClient23, createWalletClient, http as http23, parseAbi as parseAbi30, encodeFunctionData as encodeFunctionData27 } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
-var ERC20_ABI4 = parseAbi27([
+var ERC20_ABI4 = parseAbi30([
   "function allowance(address owner, address spender) external view returns (uint256)",
   "function approve(address spender, uint256 amount) external returns (bool)"
 ]);
@@ -5530,7 +6941,7 @@ var Executor = class _Executor {
       `  Approving ${amount} of ${token} for ${spender}...
 `
     );
-    const approveData = encodeFunctionData24({
+    const approveData = encodeFunctionData27({
       abi: ERC20_ABI4,
       functionName: "approve",
       args: [spender, amount]
@@ -5573,7 +6984,7 @@ var Executor = class _Executor {
   /** Fetch EIP-1559 fee params from the network. Returns [maxFeePerGas, maxPriorityFeePerGas]. */
   async fetchEip1559Fees(rpcUrl) {
     try {
-      const client = createPublicClient19({ transport: http19(rpcUrl) });
+      const client = createPublicClient23({ transport: http23(rpcUrl) });
       const gasPrice = await client.getGasPrice();
       let priorityFee = DEFAULT_PRIORITY_FEE_WEI;
       try {
@@ -5589,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 = createPublicClient19({ transport: http19(rpcUrl) });
+      const client = createPublicClient23({ transport: http23(rpcUrl) });
       const estimated = await client.estimateGas({
         to: tx.to,
         data: tx.data,
@@ -5601,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) {
@@ -5610,7 +7024,7 @@ var Executor = class _Executor {
     if (!rpcUrl) {
       throw DefiError.rpcError("No RPC URL \u2014 cannot simulate. Set HYPEREVM_RPC_URL.");
     }
-    const client = createPublicClient19({ transport: http19(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) {
@@ -5723,8 +7137,33 @@ var Executor = class _Executor {
     if (!rpcUrl) {
       throw DefiError.rpcError("No RPC URL configured for broadcasting");
     }
-    const publicClient = createPublicClient19({ transport: http19(rpcUrl) });
-    const walletClient = createWalletClient({ account, transport: http19(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(
@@ -5762,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
     };
   }
 };
@@ -6363,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: encodeFunctionData25, parseAbi: parseAbi28 } = await import("viem");
-      const POOL_ABI3 = parseAbi28([
+      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);
@@ -6373,7 +7829,7 @@ server.tool(
         const poolAddr = p.contracts?.pool;
         if (!poolAddr) continue;
         try {
-          const callData = encodeFunctionData25({ 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;