@hypurrquant/defi-cli 0.3.0 → 0.3.2

package/dist/main.js

@@ -1023,6 +1023,24 @@ var Registry = class _Registry {
     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;
+  }
 };
 
 // src/executor.ts
@@ -1133,8 +1151,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) {
@@ -1257,6 +1278,31 @@ var Executor = class _Executor {
     }
     const publicClient = createPublicClient2({ transport: http2(rpcUrl) });
     const walletClient = createWalletClient({ account, transport: http2(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(
@@ -1294,20 +1340,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
     };
   }
 };
@@ -1851,32 +1914,45 @@ import { encodeFunctionData as encodeFunctionData32, parseAbi as parseAbi32, cre
 import { encodeFunctionData as encodeFunctionData42, parseAbi as parseAbi42, 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 createPublicClient42, encodeFunctionData as encodeFunctionData8, http as http42, 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 createPublicClient42, http as http42, zeroAddress as zeroAddress3 } from "viem";
+import { createPublicClient as createPublicClient5, decodeFunctionResult as decodeFunctionResult22, encodeFunctionData as encodeFunctionData8, http as http5, parseAbi as parseAbi8, zeroAddress as zeroAddress4 } from "viem";
+import { encodeFunctionData as encodeFunctionData9, parseAbi as parseAbi9, zeroAddress as zeroAddress5 } from "viem";
+import { createPublicClient as createPublicClient6, decodeFunctionResult as decodeFunctionResult3, encodeFunctionData as encodeFunctionData10, http as http6, parseAbi as parseAbi10, zeroAddress as zeroAddress6 } from "viem";
+import { encodeFunctionData as encodeFunctionData11, parseAbi as parseAbi11, createPublicClient as createPublicClient7, http as http7 } from "viem";
 import {
-  encodeFunctionData as encodeFunctionData10,
-  decodeFunctionResult as decodeFunctionResult22,
-  parseAbi as parseAbi10,
-  createPublicClient as createPublicClient6,
-  http as http6
+  encodeFunctionData as encodeFunctionData12,
+  decodeFunctionResult as decodeFunctionResult4,
+  parseAbi as parseAbi12,
+  createPublicClient as createPublicClient8,
+  http as http8
 } 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 {
+  decodeAbiParameters as decodeAbiParameters5,
+  encodeFunctionData as encodeFunctionData13,
+  encodeAbiParameters,
+  http as http9,
+  createPublicClient as createPublicClient9,
+  keccak256,
+  parseAbi as parseAbi13,
+  decodeFunctionResult as decodeFunctionResult5,
+  zeroAddress as zeroAddress7
+} from "viem";
+import { createPublicClient as createPublicClient10, http as http10, parseAbi as parseAbi14, encodeFunctionData as encodeFunctionData14, decodeFunctionResult as decodeFunctionResult6, zeroAddress as zeroAddress8 } from "viem";
+import { createPublicClient as createPublicClient11, http as http11, parseAbi as parseAbi15, encodeFunctionData as encodeFunctionData15, zeroAddress as zeroAddress9 } from "viem";
+import { createPublicClient as createPublicClient12, http as http12, parseAbi as parseAbi16 } from "viem";
+import { createPublicClient as createPublicClient13, http as http13, parseAbi as parseAbi17, encodeFunctionData as encodeFunctionData16 } from "viem";
+import { createPublicClient as createPublicClient14, http as http14, parseAbi as parseAbi18, encodeFunctionData as encodeFunctionData17 } from "viem";
+import { createPublicClient as createPublicClient15, http as http15, parseAbi as parseAbi19, encodeFunctionData as encodeFunctionData18 } from "viem";
+import { parseAbi as parseAbi20, encodeFunctionData as encodeFunctionData19, decodeFunctionResult as decodeFunctionResult7, zeroAddress as zeroAddress10 } from "viem";
+import { createPublicClient as createPublicClient16, http as http16, parseAbi as parseAbi21, encodeFunctionData as encodeFunctionData20, zeroAddress as zeroAddress11 } from "viem";
+import { createPublicClient as createPublicClient17, http as http17, parseAbi as parseAbi222 } from "viem";
+import { createPublicClient as createPublicClient18, http as http18, parseAbi as parseAbi23, encodeFunctionData as encodeFunctionData21 } from "viem";
 import { parseAbi as parseAbi24, encodeFunctionData as encodeFunctionData222 } from "viem";
-import { 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";
 var DEFAULT_FEE = 3e3;
 var swapRouterAbi = parseAbi4([
   "struct ExactInputSingleParams { address tokenIn; address tokenOut; uint24 fee; address recipient; uint256 deadline; uint256 amountIn; uint256 amountOutMinimum; uint160 sqrtPriceLimitX96; }",
@@ -2328,6 +2404,22 @@ var UniswapV2Adapter = class {
     };
   }
 };
+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)
+  };
+}
 var abi2 = parseAbi32([
   "struct ExactInputSingleParams { address tokenIn; address tokenOut; address recipient; uint256 deadline; uint256 amountIn; uint256 amountOutMinimum; uint160 limitSqrtPrice; }",
   "function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut)"
@@ -2338,7 +2430,11 @@ var algebraQuoterAbi = parseAbi32([
 var algebraSingleQuoterAbi = parseAbi32([
   "function quoteExactInputSingle((address tokenIn, address tokenOut, uint256 amountIn, uint160 limitSqrtPrice) params) external returns (uint256 amountOut, uint256 amountIn, uint160 sqrtPriceX96After)"
 ]);
-var algebraPositionManagerAbi = parseAbi32([
+var 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)"
+]);
+var 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)"
 ]);
@@ -2483,36 +2579,58 @@ var AlgebraV3Adapter = class {
       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 = createPublicClient32({ transport: http32(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) {
@@ -2804,228 +2922,1105 @@ var SolidlyAdapter = class {
     };
   }
 };
-var abi5 = parseAbi7([
-  "function swap(address fromToken, address toToken, uint256 fromAmount, uint256 minToAmount, address to, address rebateTo) external payable returns (uint256 realToAmount)"
+var 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)"
 ]);
-var WooFiAdapter = class {
+var 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)"
+]);
+var 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)"
+]);
+var thenaFactoryAbi = parseAbi7([
+  "function getPool(address tokenA, address tokenB, int24 tickSpacing) view returns (address)"
+]);
+var ThenaCLAdapter = class {
   protocolName;
   router;
-  constructor(entry, _rpcUrl) {
+  positionManager;
+  factory;
+  rpcUrl;
+  defaultTickSpacing;
+  constructor(entry, rpcUrl) {
     this.protocolName = entry.name;
     const router = entry.contracts?.["router"];
-    if (!router) {
-      throw new DefiError("CONTRACT_ERROR", "Missing 'router' contract");
-    }
+    if (!router) throw new DefiError("CONTRACT_ERROR", "Missing 'router' contract address");
     this.router = router;
+    this.positionManager = entry.contracts?.["position_manager"];
+    this.factory = entry.contracts?.["pool_factory"];
+    this.rpcUrl = rpcUrl;
+    this.defaultTickSpacing = 50;
   }
   name() {
     return this.protocolName;
   }
   async buildSwap(params) {
-    const minToAmount = 0n;
     const data = encodeFunctionData7({
-      abi: abi5,
-      functionName: "swap",
-      args: [
-        params.token_in,
-        params.token_out,
-        params.amount_in,
-        minToAmount,
-        params.recipient,
-        zeroAddress3
-      ]
+      abi: thenaRouterAbi,
+      functionName: "exactInputSingle",
+      args: [{
+        tokenIn: params.token_in,
+        tokenOut: params.token_out,
+        tickSpacing: this.defaultTickSpacing,
+        recipient: params.recipient,
+        deadline: BigInt(params.deadline ?? 18446744073709551615n),
+        amountIn: params.amount_in,
+        amountOutMinimum: 0n,
+        sqrtPriceLimitX96: 0n
+      }]
     });
     return {
-      description: `[${this.protocolName}] Swap ${params.amount_in} via WOOFi`,
+      description: `[${this.protocolName}] Swap`,
       to: this.router,
       data,
       value: 0n,
-      gas_estimate: 2e5
+      gas_estimate: 3e5,
+      approvals: [{ token: params.token_in, spender: this.router, amount: params.amount_in }]
     };
   }
   async quote(_params) {
-    throw DefiError.unsupported(`[${this.protocolName}] quote requires RPC`);
+    throw DefiError.unsupported(`[${this.protocolName}] quote not yet implemented \u2014 use swap router`);
   }
-  async buildAddLiquidity(_params) {
-    throw DefiError.unsupported(`[${this.protocolName}] WOOFi does not support LP positions via router`);
+  async buildAddLiquidity(params) {
+    const pm = this.positionManager;
+    if (!pm) throw new DefiError("CONTRACT_ERROR", "Position manager not configured");
+    if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required");
+    const [token0, token1, rawAmount0, rawAmount1] = params.token_a.toLowerCase() < params.token_b.toLowerCase() ? [params.token_a, params.token_b, params.amount_a, params.amount_b] : [params.token_b, params.token_a, params.amount_b, params.amount_a];
+    const client = createPublicClient42({ transport: http42(this.rpcUrl) });
+    const poolAddr = params.pool;
+    let tickSpacing = this.defaultTickSpacing;
+    let tickLower = params.tick_lower ?? 0;
+    let tickUpper = params.tick_upper ?? 0;
+    if (poolAddr || !params.tick_lower || !params.tick_upper) {
+      let pool = poolAddr;
+      if (!pool && this.factory) {
+        pool = await client.readContract({
+          address: this.factory,
+          abi: thenaFactoryAbi,
+          functionName: "getPool",
+          args: [token0, token1, tickSpacing]
+        });
+        if (pool === zeroAddress3) throw new DefiError("CONTRACT_ERROR", "Pool not found");
+      }
+      if (pool) {
+        const [slot0, ts] = await Promise.all([
+          client.readContract({ address: pool, abi: thenaPoolAbi, functionName: "slot0" }),
+          client.readContract({ address: pool, abi: thenaPoolAbi, functionName: "tickSpacing" })
+        ]);
+        const currentTick = Number(slot0[1]);
+        tickSpacing = Number(ts);
+        if (params.range_pct !== void 0) {
+          const range = rangeToTicks(currentTick, params.range_pct, tickSpacing);
+          tickLower = range.tickLower;
+          tickUpper = range.tickUpper;
+        } else if (!params.tick_lower && !params.tick_upper) {
+          const isSingleSide = rawAmount0 === 0n || rawAmount1 === 0n;
+          if (isSingleSide) {
+            if (rawAmount0 > 0n) {
+              tickLower = alignTickUp(currentTick + tickSpacing, tickSpacing);
+              tickUpper = Math.floor(887272 / tickSpacing) * tickSpacing;
+            } else {
+              tickLower = Math.ceil(-887272 / tickSpacing) * tickSpacing;
+              tickUpper = alignTickDown(currentTick - tickSpacing, tickSpacing);
+            }
+          } else {
+            tickLower = Math.ceil(-887272 / tickSpacing) * tickSpacing;
+            tickUpper = Math.floor(887272 / tickSpacing) * tickSpacing;
+          }
+        }
+      }
+    }
+    if (params.tick_lower !== void 0) tickLower = params.tick_lower;
+    if (params.tick_upper !== void 0) tickUpper = params.tick_upper;
+    const data = encodeFunctionData7({
+      abi: thenaPmAbi,
+      functionName: "mint",
+      args: [{
+        token0,
+        token1,
+        tickSpacing,
+        tickLower,
+        tickUpper,
+        amount0Desired: rawAmount0,
+        amount1Desired: rawAmount1,
+        amount0Min: 0n,
+        amount1Min: 0n,
+        recipient: params.recipient,
+        deadline: BigInt("18446744073709551615"),
+        sqrtPriceX96: 0n
+      }]
+    });
+    const approvals = [];
+    if (rawAmount0 > 0n) approvals.push({ token: token0, spender: pm, amount: rawAmount0 });
+    if (rawAmount1 > 0n) approvals.push({ token: token1, spender: pm, amount: rawAmount1 });
+    return {
+      description: `[${this.protocolName}] Add liquidity [${tickLower}, ${tickUpper}]`,
+      to: pm,
+      data,
+      value: 0n,
+      gas_estimate: 7e5,
+      approvals
+    };
   }
   async buildRemoveLiquidity(_params) {
-    throw DefiError.unsupported(`[${this.protocolName}] WOOFi does not support LP positions via router`);
+    throw DefiError.unsupported(`[${this.protocolName}] remove_liquidity requires tokenId`);
   }
 };
-var gaugeAbi = parseAbi8([
-  "function deposit(uint256 amount) external",
-  "function depositFor(uint256 amount, uint256 tokenId) external",
-  "function withdraw(uint256 amount) external",
-  "function getReward(address account) external",
-  "function getReward(address account, address[] tokens) external",
-  "function earned(address account) external view returns (uint256)",
-  "function earned(address token, address account) external view returns (uint256)",
-  "function rewardRate() external view returns (uint256)",
-  "function totalSupply() external view returns (uint256)",
-  "function rewardsListLength() external view returns (uint256)",
-  "function isReward(address token) external view returns (bool)"
+var _addressDecodeAbi = parseAbi8(["function f() external view returns (address)"]);
+function decodeAddress(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult22({ abi: _addressDecodeAbi, functionName: "f", data });
+  } catch {
+    return null;
+  }
+}
+var _symbolDecodeAbi = parseAbi8(["function symbol() external view returns (string)"]);
+function decodeSymbol(data) {
+  if (!data) return "?";
+  try {
+    return decodeFunctionResult22({ abi: _symbolDecodeAbi, functionName: "symbol", data });
+  } catch {
+    return "?";
+  }
+}
+var 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"
+]);
+var 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)"
+]);
+var nfpmAbi = parseAbi8([
+  "function approve(address to, uint256 tokenId) external",
+  "function getApproved(uint256 tokenId) view returns (address)"
 ]);
 var veAbi = parseAbi8([
   "function create_lock(uint256 value, uint256 lock_duration) external returns (uint256)",
   "function increase_amount(uint256 tokenId, uint256 value) external",
   "function increase_unlock_time(uint256 tokenId, uint256 lock_duration) external",
-  "function withdraw(uint256 tokenId) external",
-  "function balanceOfNFT(uint256 tokenId) external view returns (uint256)",
-  "function locked(uint256 tokenId) external view returns (uint256 amount, uint256 end)"
+  "function withdraw(uint256 tokenId) external"
 ]);
 var voterAbi = parseAbi8([
-  "function vote(uint256 tokenId, address[] calldata pools, uint256[] calldata weights) external",
-  "function claimBribes(address[] calldata bribes, address[][] calldata tokens, uint256 tokenId) external",
-  "function claimFees(address[] calldata fees, address[][] calldata tokens, uint256 tokenId) external",
-  "function gauges(address pool) external view returns (address)"
+  "function vote(uint256 tokenId, address[] pools, uint256[] weights) external",
+  "function claimBribes(address[] bribes, address[][] tokens, uint256 tokenId) external",
+  "function claimFees(address[] fees, address[][] tokens, uint256 tokenId) external"
 ]);
-var SolidlyGaugeAdapter = class {
+var HybraGaugeAdapter = class {
   protocolName;
-  voter;
+  gaugeManager;
   veToken;
+  voter;
+  positionManager;
+  poolFactory;
   rpcUrl;
   constructor(entry, rpcUrl) {
     this.protocolName = entry.name;
-    const voter = entry.contracts?.["voter"];
-    if (!voter) {
-      throw new DefiError("CONTRACT_ERROR", "Missing 'voter' contract");
-    }
-    const veToken = entry.contracts?.["ve_token"];
-    if (!veToken) {
-      throw new DefiError("CONTRACT_ERROR", "Missing 've_token' contract");
-    }
-    this.voter = voter;
-    this.veToken = veToken;
+    const gm = entry.contracts?.["gauge_manager"];
+    if (!gm) throw new DefiError("CONTRACT_ERROR", "Missing 'gauge_manager' contract");
+    this.gaugeManager = gm;
+    const ve = entry.contracts?.["ve_token"];
+    if (!ve) throw new DefiError("CONTRACT_ERROR", "Missing 've_token' contract");
+    this.veToken = ve;
+    this.voter = entry.contracts?.["voter"] ?? zeroAddress4;
+    this.positionManager = entry.contracts?.["position_manager"] ?? zeroAddress4;
+    this.poolFactory = entry.contracts?.["pool_factory"];
     this.rpcUrl = rpcUrl;
   }
   name() {
     return this.protocolName;
   }
-  // IGauge
-  async buildDeposit(gauge, amount, tokenId, lpToken) {
-    if (tokenId !== void 0) {
-      const data2 = encodeFunctionData8({
-        abi: gaugeAbi,
-        functionName: "depositFor",
-        args: [amount, tokenId]
+  // ─── Gauge Discovery ──────────────────────────────────────
+  async discoverGaugedPools() {
+    if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required for gauge discovery");
+    if (!this.poolFactory) throw new DefiError("CONTRACT_ERROR", "Missing 'pool_factory' contract");
+    const factoryAbi = parseAbi8([
+      "function allPoolsLength() external view returns (uint256)",
+      "function allPools(uint256) external view returns (address)"
+    ]);
+    const poolAbi2 = parseAbi8([
+      "function token0() external view returns (address)",
+      "function token1() external view returns (address)"
+    ]);
+    const erc20SymbolAbi = parseAbi8(["function symbol() external view returns (string)"]);
+    const gaugesAbi = parseAbi8(["function gauges(address pool) view returns (address gauge)"]);
+    const client = createPublicClient5({ transport: http5(this.rpcUrl) });
+    let poolCount;
+    try {
+      poolCount = await client.readContract({
+        address: this.poolFactory,
+        abi: factoryAbi,
+        functionName: "allPoolsLength"
       });
-      return {
-        description: `[${this.protocolName}] Deposit ${amount} LP to gauge (boost veNFT #${tokenId})`,
-        to: gauge,
-        data: data2,
-        value: 0n,
-        gas_estimate: 2e5,
-        approvals: lpToken ? [{ token: lpToken, spender: gauge, amount }] : void 0
-      };
+    } catch {
+      return [];
     }
-    const data = encodeFunctionData8({
-      abi: gaugeAbi,
-      functionName: "deposit",
-      args: [amount]
-    });
+    const count = Number(poolCount);
+    if (count === 0) return [];
+    const poolAddressCalls = [];
+    for (let i = 0; i < count; i++) {
+      poolAddressCalls.push([
+        this.poolFactory,
+        encodeFunctionData8({ abi: factoryAbi, functionName: "allPools", args: [BigInt(i)] })
+      ]);
+    }
+    const poolAddressResults = await multicallRead(this.rpcUrl, poolAddressCalls);
+    const pools = poolAddressResults.map((r) => decodeAddress(r)).filter((a) => a !== null && a !== zeroAddress4);
+    if (pools.length === 0) return [];
+    const gaugeCalls = pools.map((pool) => [
+      this.gaugeManager,
+      encodeFunctionData8({ abi: gaugesAbi, functionName: "gauges", args: [pool] })
+    ]);
+    const gaugeResults = await multicallRead(this.rpcUrl, gaugeCalls);
+    const gaugedPools = [];
+    for (let i = 0; i < pools.length; i++) {
+      const gauge = decodeAddress(gaugeResults[i] ?? null);
+      if (gauge && gauge !== zeroAddress4) {
+        gaugedPools.push({ pool: pools[i], gauge });
+      }
+    }
+    if (gaugedPools.length === 0) return [];
+    const tokenCalls = [];
+    for (const { pool } of gaugedPools) {
+      tokenCalls.push([pool, encodeFunctionData8({ abi: poolAbi2, functionName: "token0" })]);
+      tokenCalls.push([pool, encodeFunctionData8({ abi: poolAbi2, functionName: "token1" })]);
+    }
+    const tokenResults = await multicallRead(this.rpcUrl, tokenCalls);
+    const tokenAddrs = /* @__PURE__ */ new Set();
+    for (let i = 0; i < gaugedPools.length; i++) {
+      const t0 = decodeAddress(tokenResults[i * 2] ?? null);
+      const t1 = decodeAddress(tokenResults[i * 2 + 1] ?? null);
+      if (t0 && t0 !== zeroAddress4) tokenAddrs.add(t0);
+      if (t1 && t1 !== zeroAddress4) tokenAddrs.add(t1);
+    }
+    const uniqueTokens = Array.from(tokenAddrs);
+    const symbolCalls = uniqueTokens.map((t) => [
+      t,
+      encodeFunctionData8({ abi: erc20SymbolAbi, functionName: "symbol" })
+    ]);
+    const symbolResults = await multicallRead(this.rpcUrl, symbolCalls);
+    const symbolMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < uniqueTokens.length; i++) {
+      symbolMap.set(uniqueTokens[i], decodeSymbol(symbolResults[i] ?? null));
+    }
+    const out = [];
+    for (let i = 0; i < gaugedPools.length; i++) {
+      const { pool, gauge } = gaugedPools[i];
+      const t0 = decodeAddress(tokenResults[i * 2] ?? null);
+      const t1 = decodeAddress(tokenResults[i * 2 + 1] ?? null);
+      out.push({
+        pool,
+        gauge,
+        token0: t0 ? symbolMap.get(t0) ?? t0.slice(0, 10) : "?",
+        token1: t1 ? symbolMap.get(t1) ?? t1.slice(0, 10) : "?",
+        type: "CL"
+      });
+    }
+    return out;
+  }
+  // ─── Gauge Lookup ──────────────────────────────────────────
+  async resolveGauge(pool) {
+    if (!this.rpcUrl) throw DefiError.rpcError("RPC required");
+    const client = createPublicClient5({ transport: http5(this.rpcUrl) });
+    const gauge = await client.readContract({
+      address: this.gaugeManager,
+      abi: gaugeManagerAbi,
+      functionName: "gauges",
+      args: [pool]
+    });
+    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 ${amount} LP to gauge`,
+      description: `[${this.protocolName}] Deposit NFT #${tokenId} to gauge`,
       to: gauge,
-      data,
+      data: encodeFunctionData8({ abi: gaugeCLAbi, functionName: "deposit", args: [tokenId] }),
       value: 0n,
-      gas_estimate: 2e5,
-      approvals: lpToken ? [{ token: lpToken, spender: gauge, amount }] : void 0
+      gas_estimate: 5e5,
+      pre_txs: [approveTx]
     };
   }
-  async buildWithdraw(gauge, amount) {
-    const data = encodeFunctionData8({
-      abi: gaugeAbi,
-      functionName: "withdraw",
-      args: [amount]
-    });
+  async buildWithdraw(gauge, _amount, tokenId) {
+    if (tokenId === void 0) throw new DefiError("CONTRACT_ERROR", "tokenId required for CL gauge withdraw");
     return {
-      description: `[${this.protocolName}] Withdraw ${amount} LP from gauge`,
+      description: `[${this.protocolName}] Withdraw NFT #${tokenId} from gauge`,
       to: gauge,
-      data,
+      data: encodeFunctionData8({ abi: gaugeCLAbi, functionName: "withdraw", args: [tokenId, 1] }),
       value: 0n,
-      gas_estimate: 2e5
+      gas_estimate: 1e6
     };
   }
-  async buildClaimRewards(gauge, account) {
-    if (account && this.rpcUrl) {
-      try {
-        const client = createPublicClient42({ transport: http42(this.rpcUrl) });
-        const listLen = await client.readContract({
-          address: gauge,
-          abi: gaugeAbi,
-          functionName: "rewardsListLength"
-        });
-        if (listLen > 0n) {
-          const data2 = encodeFunctionData8({
-            abi: gaugeAbi,
-            functionName: "getReward",
-            args: [account, []]
-          });
-          return {
-            description: `[${this.protocolName}] Claim gauge rewards`,
-            to: gauge,
-            data: data2,
-            value: 0n,
-            gas_estimate: 3e5
-          };
-        }
-      } catch {
-      }
-    }
-    const data = encodeFunctionData8({
-      abi: gaugeAbi,
-      functionName: "getReward",
-      args: [account ?? zeroAddress4]
-    });
+  // ─── Claim: via GaugeManager ──────────────────────────────────
+  async buildClaimRewards(gauge, _account) {
+    throw DefiError.unsupported(`[${this.protocolName}] Use buildClaimRewardsByTokenId for CL gauges`);
+  }
+  async buildClaimRewardsByTokenId(gauge, tokenId) {
     return {
-      description: `[${this.protocolName}] Claim gauge rewards`,
-      to: gauge,
-      data,
+      description: `[${this.protocolName}] Claim rewards for NFT #${tokenId}`,
+      to: this.gaugeManager,
+      data: encodeFunctionData8({
+        abi: gaugeManagerAbi,
+        functionName: "claimRewards",
+        args: [gauge, [tokenId], 1]
+        // redeemType=1
+      }),
       value: 0n,
-      gas_estimate: 2e5
+      gas_estimate: 1e6
     };
   }
-  async getPendingRewards(_gauge, _user) {
-    throw DefiError.unsupported(`[${this.protocolName}] get_pending_rewards requires RPC`);
+  // ─── Pending Rewards ──────────────────────────────────────────
+  async getPendingRewards(gauge, _user) {
+    throw DefiError.unsupported(`[${this.protocolName}] Use getPendingRewardsByTokenId for CL gauges`);
   }
-  // IVoteEscrow
-  async buildCreateLock(amount, lockDuration) {
-    const data = encodeFunctionData8({
-      abi: veAbi,
-      functionName: "create_lock",
-      args: [amount, BigInt(lockDuration)]
+  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: ${amount} tokens for ${lockDuration}s`,
+      description: `[${this.protocolName}] Create veNFT lock`,
       to: this.veToken,
-      data,
+      data: encodeFunctionData8({ abi: veAbi, functionName: "create_lock", args: [amount, BigInt(lockDuration)] }),
       value: 0n,
       gas_estimate: 3e5
     };
   }
   async buildIncreaseAmount(tokenId, amount) {
-    const data = encodeFunctionData8({
-      abi: veAbi,
-      functionName: "increase_amount",
-      args: [tokenId, amount]
-    });
     return {
-      description: `[${this.protocolName}] Increase veNFT #${tokenId} by ${amount}`,
+      description: `[${this.protocolName}] Increase veNFT #${tokenId}`,
       to: this.veToken,
-      data,
+      data: encodeFunctionData8({ abi: veAbi, functionName: "increase_amount", args: [tokenId, amount] }),
       value: 0n,
       gas_estimate: 2e5
     };
   }
   async buildIncreaseUnlockTime(tokenId, lockDuration) {
-    const data = encodeFunctionData8({
-      abi: veAbi,
-      functionName: "increase_unlock_time",
-      args: [tokenId, BigInt(lockDuration)]
-    });
     return {
-      description: `[${this.protocolName}] Extend veNFT #${tokenId} lock by ${lockDuration}s`,
+      description: `[${this.protocolName}] Extend veNFT #${tokenId} lock`,
+      to: this.veToken,
+      data: 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
+    };
+  }
+};
+var abi5 = parseAbi9([
+  "function swap(address fromToken, address toToken, uint256 fromAmount, uint256 minToAmount, address to, address rebateTo) external payable returns (uint256 realToAmount)"
+]);
+var WooFiAdapter = class {
+  protocolName;
+  router;
+  constructor(entry, _rpcUrl) {
+    this.protocolName = entry.name;
+    const router = entry.contracts?.["router"];
+    if (!router) {
+      throw new DefiError("CONTRACT_ERROR", "Missing 'router' contract");
+    }
+    this.router = router;
+  }
+  name() {
+    return this.protocolName;
+  }
+  async buildSwap(params) {
+    const minToAmount = 0n;
+    const data = encodeFunctionData9({
+      abi: abi5,
+      functionName: "swap",
+      args: [
+        params.token_in,
+        params.token_out,
+        params.amount_in,
+        minToAmount,
+        params.recipient,
+        zeroAddress5
+      ]
+    });
+    return {
+      description: `[${this.protocolName}] Swap ${params.amount_in} via WOOFi`,
+      to: this.router,
+      data,
+      value: 0n,
+      gas_estimate: 2e5
+    };
+  }
+  async quote(_params) {
+    throw DefiError.unsupported(`[${this.protocolName}] quote requires RPC`);
+  }
+  async buildAddLiquidity(_params) {
+    throw DefiError.unsupported(`[${this.protocolName}] WOOFi does not support LP positions via router`);
+  }
+  async buildRemoveLiquidity(_params) {
+    throw DefiError.unsupported(`[${this.protocolName}] WOOFi does not support LP positions via router`);
+  }
+};
+var gaugeAbi = parseAbi10([
+  "function deposit(uint256 amount) external",
+  "function depositFor(uint256 amount, uint256 tokenId) external",
+  "function withdraw(uint256 amount) external",
+  "function getReward() external",
+  "function getReward(address account) external",
+  "function getReward(address account, address[] tokens) external",
+  "function getReward(uint256 tokenId) external",
+  "function earned(address account) external view returns (uint256)",
+  "function earned(address token, address account) external view returns (uint256)",
+  "function earned(uint256 tokenId) external view returns (uint256)",
+  "function rewardRate() external view returns (uint256)",
+  "function rewardToken() external view returns (address)",
+  "function totalSupply() external view returns (uint256)",
+  "function rewardsListLength() external view returns (uint256)",
+  "function rewardData(address token) external view returns (uint256 periodFinish, uint256 rewardRate, uint256 lastUpdateTime, uint256 rewardPerTokenStored)",
+  "function nonfungiblePositionManager() external view returns (address)"
+]);
+var veAbi2 = parseAbi10([
+  "function create_lock(uint256 value, uint256 lock_duration) external returns (uint256)",
+  "function increase_amount(uint256 tokenId, uint256 value) external",
+  "function increase_unlock_time(uint256 tokenId, uint256 lock_duration) external",
+  "function withdraw(uint256 tokenId) external",
+  "function balanceOfNFT(uint256 tokenId) external view returns (uint256)",
+  "function locked(uint256 tokenId) external view returns (uint256 amount, uint256 end)"
+]);
+var voterAbi2 = parseAbi10([
+  "function vote(uint256 tokenId, address[] calldata pools, uint256[] calldata weights) external",
+  "function claimBribes(address[] calldata bribes, address[][] calldata tokens, uint256 tokenId) external",
+  "function claimFees(address[] calldata fees, address[][] calldata tokens, uint256 tokenId) external",
+  "function gauges(address pool) external view returns (address)",
+  "function gaugeForPool(address pool) external view returns (address)",
+  "function poolToGauge(address pool) external view returns (address)"
+]);
+var _addressDecodeAbi2 = parseAbi10(["function f() external view returns (address)"]);
+function decodeAddress2(data) {
+  if (!data) return null;
+  try {
+    return decodeFunctionResult3({ abi: _addressDecodeAbi2, functionName: "f", data });
+  } catch {
+    return null;
+  }
+}
+var _symbolDecodeAbi2 = parseAbi10(["function symbol() external view returns (string)"]);
+function decodeSymbol2(data) {
+  if (!data) return "?";
+  try {
+    return decodeFunctionResult3({ abi: _symbolDecodeAbi2, functionName: "symbol", data });
+  } catch {
+    return "?";
+  }
+}
+var _boolDecodeAbi = parseAbi10(["function f() external view returns (bool)"]);
+function decodeBoolean(data) {
+  try {
+    return decodeFunctionResult3({ abi: _boolDecodeAbi, functionName: "f", data });
+  } catch {
+    return false;
+  }
+}
+var 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"
+};
+var CL_TICK_SPACINGS = [1, 5, 10, 50, 100, 200];
+var SolidlyGaugeAdapter = class {
+  protocolName;
+  voter;
+  veToken;
+  rpcUrl;
+  clFactory;
+  v2Factory;
+  constructor(entry, rpcUrl) {
+    this.protocolName = entry.name;
+    const voter = entry.contracts?.["voter"];
+    if (!voter) {
+      throw new DefiError("CONTRACT_ERROR", "Missing 'voter' contract");
+    }
+    const veToken = entry.contracts?.["ve_token"];
+    if (!veToken) {
+      throw new DefiError("CONTRACT_ERROR", "Missing 've_token' contract");
+    }
+    this.voter = voter;
+    this.veToken = veToken;
+    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 = encodeFunctionData10({
+        abi: gaugeAbi,
+        functionName: "depositFor",
+        args: [amount, tokenId]
+      });
+      return {
+        description: `[${this.protocolName}] Deposit ${amount} LP to gauge (boost veNFT #${tokenId})`,
+        to: gauge,
+        data: data2,
+        value: 0n,
+        gas_estimate: 2e5,
+        approvals: lpToken ? [{ token: lpToken, spender: gauge, amount }] : void 0
+      };
+    }
+    const data = encodeFunctionData10({
+      abi: gaugeAbi,
+      functionName: "deposit",
+      args: [amount]
+    });
+    return {
+      description: `[${this.protocolName}] Deposit ${amount} LP to gauge`,
+      to: gauge,
+      data,
+      value: 0n,
+      gas_estimate: 2e5,
+      approvals: lpToken ? [{ token: lpToken, spender: gauge, amount }] : void 0
+    };
+  }
+  async buildWithdraw(gauge, amount) {
+    const data = encodeFunctionData10({
+      abi: gaugeAbi,
+      functionName: "withdraw",
+      args: [amount]
+    });
+    return {
+      description: `[${this.protocolName}] Withdraw ${amount} LP from gauge`,
+      to: gauge,
+      data,
+      value: 0n,
+      gas_estimate: 2e5
+    };
+  }
+  /**
+   * Resolve gauge address from a pool address via voter contract.
+   * Tries gaugeForPool (Ramses), poolToGauge (NEST), gauges (classic Solidly).
+   */
+  async resolveGauge(pool) {
+    if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required for gauge lookup");
+    const client = createPublicClient6({ transport: http6(this.rpcUrl) });
+    for (const fn of ["gaugeForPool", "poolToGauge", "gauges"]) {
+      try {
+        const gauge = await client.readContract({
+          address: this.voter,
+          abi: voterAbi2,
+          functionName: fn,
+          args: [pool]
+        });
+        if (gauge !== zeroAddress6) return gauge;
+      } catch {
+      }
+    }
+    throw new DefiError("CONTRACT_ERROR", `[${this.protocolName}] No gauge found for pool ${pool}`);
+  }
+  /**
+   * Discover reward tokens for a gauge.
+   * Returns { tokens, multiToken } where multiToken indicates getReward(account, tokens[]) support.
+   */
+  async discoverRewardTokens(gauge) {
+    if (!this.rpcUrl) return { tokens: [], multiToken: false };
+    const client = createPublicClient6({ transport: http6(this.rpcUrl) });
+    try {
+      const len = await client.readContract({
+        address: gauge,
+        abi: gaugeAbi,
+        functionName: "rewardsListLength"
+      });
+      if (Number(len) > 0) {
+        const candidates = [
+          "0x5555555555555555555555555555555555555555",
+          // WHYPE
+          "0x555570a286F15EbDFE42B66eDE2f724Aa1AB5555",
+          // xRAM
+          "0x067b0C72aa4C6Bd3BFEFfF443c536DCd6a25a9C8",
+          // HYBR
+          "0x07c57E32a3C29D5659bda1d3EFC2E7BF004E3035"
+          // NEST token
+        ];
+        const found = [];
+        for (const token of candidates) {
+          try {
+            const rd = await client.readContract({
+              address: gauge,
+              abi: gaugeAbi,
+              functionName: "rewardData",
+              args: [token]
+            });
+            if (rd[0] > 0n || rd[1] > 0n) found.push(token);
+          } catch {
+          }
+        }
+        if (found.length > 0) return { tokens: found, multiToken: true };
+        return { tokens: [], multiToken: true };
+      }
+    } catch {
+    }
+    try {
+      const rt = await client.readContract({
+        address: gauge,
+        abi: gaugeAbi,
+        functionName: "rewardToken"
+      });
+      if (rt !== zeroAddress6) return { tokens: [rt], multiToken: false };
+    } catch {
+    }
+    return { tokens: [], multiToken: false };
+  }
+  async buildClaimRewards(gauge, account) {
+    if (!this.rpcUrl || !account) {
+      const data2 = encodeFunctionData10({
+        abi: gaugeAbi,
+        functionName: "getReward",
+        args: [account ?? zeroAddress6]
+      });
+      return { description: `[${this.protocolName}] Claim gauge rewards`, to: gauge, data: data2, value: 0n, gas_estimate: 2e5 };
+    }
+    const { tokens, multiToken } = await this.discoverRewardTokens(gauge);
+    if (multiToken && tokens.length > 0) {
+      const data2 = encodeFunctionData10({
+        abi: gaugeAbi,
+        functionName: "getReward",
+        args: [account, tokens]
+      });
+      return {
+        description: `[${this.protocolName}] Claim gauge rewards (${tokens.length} tokens)`,
+        to: gauge,
+        data: data2,
+        value: 0n,
+        gas_estimate: 3e5
+      };
+    }
+    const data = encodeFunctionData10({
+      abi: gaugeAbi,
+      functionName: "getReward",
+      args: []
+    });
+    return {
+      description: `[${this.protocolName}] Claim gauge rewards`,
+      to: gauge,
+      data,
+      value: 0n,
+      gas_estimate: 2e5
+    };
+  }
+  /**
+   * Claim rewards for a CL gauge by NFT tokenId (Hybra V4 style).
+   */
+  async buildClaimRewardsByTokenId(gauge, tokenId) {
+    const data = encodeFunctionData10({
+      abi: gaugeAbi,
+      functionName: "getReward",
+      args: [tokenId]
+    });
+    return {
+      description: `[${this.protocolName}] Claim gauge rewards for NFT #${tokenId}`,
+      to: gauge,
+      data,
+      value: 0n,
+      gas_estimate: 3e5
+    };
+  }
+  async getPendingRewards(gauge, user) {
+    if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required");
+    const client = createPublicClient6({ transport: http6(this.rpcUrl) });
+    const results = [];
+    const { tokens, multiToken } = await this.discoverRewardTokens(gauge);
+    if (multiToken && tokens.length > 0) {
+      for (const token of tokens) {
+        try {
+          const earned = await client.readContract({
+            address: gauge,
+            abi: gaugeAbi,
+            functionName: "earned",
+            args: [token, user]
+          });
+          results.push({ token, symbol: token.slice(0, 10), amount: earned });
+        } catch {
+        }
+      }
+    } else if (tokens.length > 0) {
+      try {
+        const earned = await client.readContract({
+          address: gauge,
+          abi: gaugeAbi,
+          functionName: "earned",
+          args: [user]
+        });
+        results.push({ token: tokens[0], symbol: tokens[0].slice(0, 10), amount: earned });
+      } catch {
+      }
+    } else {
+      try {
+        const earned = await client.readContract({
+          address: gauge,
+          abi: gaugeAbi,
+          functionName: "earned",
+          args: [user]
+        });
+        results.push({ token: zeroAddress6, symbol: "unknown", amount: earned });
+      } catch {
+      }
+    }
+    return results;
+  }
+  /**
+   * Get pending rewards for a CL gauge NFT position (Hybra V4 style).
+   */
+  async getPendingRewardsByTokenId(gauge, tokenId) {
+    if (!this.rpcUrl) throw DefiError.rpcError("RPC URL required");
+    const client = createPublicClient6({ transport: http6(this.rpcUrl) });
+    return await client.readContract({
+      address: gauge,
+      abi: gaugeAbi,
+      functionName: "earned",
+      args: [tokenId]
+    });
+  }
+  // IVoteEscrow
+  async buildCreateLock(amount, lockDuration) {
+    const data = encodeFunctionData10({
+      abi: veAbi2,
+      functionName: "create_lock",
+      args: [amount, BigInt(lockDuration)]
+    });
+    return {
+      description: `[${this.protocolName}] Create veNFT lock: ${amount} tokens for ${lockDuration}s`,
+      to: this.veToken,
+      data,
+      value: 0n,
+      gas_estimate: 3e5
+    };
+  }
+  async buildIncreaseAmount(tokenId, amount) {
+    const data = encodeFunctionData10({
+      abi: veAbi2,
+      functionName: "increase_amount",
+      args: [tokenId, amount]
+    });
+    return {
+      description: `[${this.protocolName}] Increase veNFT #${tokenId} by ${amount}`,
+      to: this.veToken,
+      data,
+      value: 0n,
+      gas_estimate: 2e5
+    };
+  }
+  async buildIncreaseUnlockTime(tokenId, lockDuration) {
+    const data = encodeFunctionData10({
+      abi: veAbi2,
+      functionName: "increase_unlock_time",
+      args: [tokenId, BigInt(lockDuration)]
+    });
+    return {
+      description: `[${this.protocolName}] Extend veNFT #${tokenId} lock by ${lockDuration}s`,
       to: this.veToken,
       data,
       value: 0n,
@@ -3033,8 +4028,8 @@ var SolidlyGaugeAdapter = class {
     };
   }
   async buildWithdrawExpired(tokenId) {
-    const data = encodeFunctionData8({
-      abi: veAbi,
+    const data = encodeFunctionData10({
+      abi: veAbi2,
       functionName: "withdraw",
       args: [tokenId]
     });
@@ -3048,8 +4043,8 @@ var SolidlyGaugeAdapter = class {
   }
   // IVoter
   async buildVote(tokenId, pools, weights) {
-    const data = encodeFunctionData8({
-      abi: voterAbi,
+    const data = encodeFunctionData10({
+      abi: voterAbi2,
       functionName: "vote",
       args: [tokenId, pools, weights]
     });
@@ -3063,8 +4058,8 @@ var SolidlyGaugeAdapter = class {
   }
   async buildClaimBribes(bribes, tokenId) {
     const tokensPerBribe = bribes.map(() => []);
-    const data = encodeFunctionData8({
-      abi: voterAbi,
+    const data = encodeFunctionData10({
+      abi: voterAbi2,
       functionName: "claimBribes",
       args: [bribes, tokensPerBribe, tokenId]
     });
@@ -3078,8 +4073,8 @@ var SolidlyGaugeAdapter = class {
   }
   async buildClaimFees(fees, tokenId) {
     const tokensPerFee = fees.map(() => []);
-    const data = encodeFunctionData8({
-      abi: voterAbi,
+    const data = encodeFunctionData10({
+      abi: voterAbi2,
       functionName: "claimFees",
       args: [fees, tokensPerFee, tokenId]
     });
@@ -3092,7 +4087,7 @@ var SolidlyGaugeAdapter = class {
     };
   }
 };
-var masterchefAbi = parseAbi9([
+var masterchefAbi = parseAbi11([
   "function deposit(uint256 pid, uint256 amount) external",
   "function withdraw(uint256 pid, uint256 amount) external",
   "function claim(uint256[] calldata pids) external",
@@ -3123,7 +4118,7 @@ var MasterChefAdapter = class {
    */
   async buildDeposit(gauge, amount, tokenId) {
     const pid = tokenId ?? 0n;
-    const data = encodeFunctionData9({
+    const data = encodeFunctionData11({
       abi: masterchefAbi,
       functionName: "deposit",
       args: [pid, amount]
@@ -3144,7 +4139,7 @@ var MasterChefAdapter = class {
    */
   async buildWithdraw(gauge, amount) {
     const pid = 0n;
-    const data = encodeFunctionData9({
+    const data = encodeFunctionData11({
       abi: masterchefAbi,
       functionName: "withdraw",
       args: [pid, amount]
@@ -3159,7 +4154,7 @@ var MasterChefAdapter = class {
   }
   /** 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]
@@ -3175,7 +4170,7 @@ var MasterChefAdapter = class {
   /** 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]]
@@ -3190,7 +4185,7 @@ var MasterChefAdapter = class {
   }
   /** 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]]
@@ -3208,7 +4203,7 @@ var MasterChefAdapter = class {
     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,
@@ -3222,16 +4217,16 @@ var MasterChefAdapter = class {
     }));
   }
 };
-var lbRouterAbi = parseAbi10([
+var 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)"
 ]);
-var lbFactoryAbi = parseAbi10([
+var lbFactoryAbi = parseAbi12([
   "function getNumberOfLBPairs() external view returns (uint256)",
   "function getLBPairAtIndex(uint256 index) external view returns (address)"
 ]);
-var lbPairAbi = parseAbi10([
+var lbPairAbi = parseAbi12([
   "function getLBHooksParameters() external view returns (bytes32)",
   "function getActiveId() external view returns (uint24)",
   "function getBinStep() external view returns (uint16)",
@@ -3240,7 +4235,7 @@ var lbPairAbi = parseAbi10([
   "function balanceOf(address account, uint256 id) external view returns (uint256)",
   "function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory)"
 ]);
-var lbRewarderAbi = parseAbi10([
+var 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)",
@@ -3250,50 +4245,50 @@ var lbRewarderAbi = parseAbi10([
   "function getLBPair() external view returns (address)",
   "function getMasterChef() external view returns (address)"
 ]);
-var masterChefAbi = parseAbi10([
+var 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)"
 ]);
-var veMoeAbi = parseAbi10([
+var veMoeAbi = parseAbi12([
   "function getWeight(uint256 pid) external view returns (uint256)",
   "function getTotalWeight() external view returns (uint256)",
   "function getTopPoolIds() external view returns (uint256[] memory)"
 ]);
-var lbPairBinAbi = parseAbi10([
+var lbPairBinAbi = parseAbi12([
   "function getBin(uint24 id) external view returns (uint128 reserveX, uint128 reserveY)",
   "function getActiveId() external view returns (uint24)"
 ]);
-var lbQuoterAbi2 = parseAbi10([
+var 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))"
 ]);
-var erc20Abi2 = parseAbi10([
+var erc20Abi2 = parseAbi12([
   "function symbol() external view returns (string)"
 ]);
-var _addressAbi = parseAbi10(["function f() external view returns (address)"]);
+var _addressAbi = parseAbi12(["function f() external view returns (address)"]);
 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;
   }
 }
-var _uint256Abi = parseAbi10(["function f() external view returns (uint256)"]);
+var _uint256Abi = parseAbi12(["function f() external view returns (uint256)"]);
 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;
   }
 }
-var _boolAbi = parseAbi10(["function f() external view returns (bool)"]);
+var _boolAbi = parseAbi12(["function f() external view returns (bool)"]);
 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;
   }
@@ -3301,34 +4296,34 @@ 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 "?";
   }
 }
-var _rangeAbi = parseAbi10(["function f() external view returns (uint256 minBinId, uint256 maxBinId)"]);
+var _rangeAbi = parseAbi12(["function f() external view returns (uint256 minBinId, uint256 maxBinId)"]);
 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;
   }
 }
-var _binAbi = parseAbi10(["function f() external view returns (uint128 reserveX, uint128 reserveY)"]);
+var _binAbi = parseAbi12(["function f() external view returns (uint128 reserveX, uint128 reserveY)"]);
 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;
   }
 }
-var _uint256ArrayAbi = parseAbi10(["function f() external view returns (uint256[] memory)"]);
+var _uint256ArrayAbi = parseAbi12(["function f() external view returns (uint256[] memory)"]);
 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;
   }
@@ -3414,7 +4409,7 @@ var MerchantMoeLBAdapter = class {
     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,
@@ -3427,7 +4422,7 @@ var MerchantMoeLBAdapter = class {
       deltaIds.push(d);
     }
     const { distributionX, distributionY } = buildUniformDistribution(deltaIds);
-    const data = encodeFunctionData10({
+    const data = encodeFunctionData12({
       abi: lbRouterAbi,
       functionName: "addLiquidity",
       args: [
@@ -3467,7 +4462,7 @@ var MerchantMoeLBAdapter = class {
    */
   async buildRemoveLiquidity(params) {
     const deadline = params.deadline ?? BigInt("18446744073709551615");
-    const data = encodeFunctionData10({
+    const data = encodeFunctionData12({
       abi: lbRouterAbi,
       functionName: "removeLiquidity",
       args: [
@@ -3496,7 +4491,7 @@ var MerchantMoeLBAdapter = class {
    */
   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,
@@ -3531,7 +4526,7 @@ var MerchantMoeLBAdapter = class {
    */
   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,
@@ -3580,7 +4575,7 @@ var MerchantMoeLBAdapter = class {
    */
   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,
@@ -3602,7 +4597,7 @@ var MerchantMoeLBAdapter = class {
       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)]
@@ -3630,7 +4625,7 @@ var MerchantMoeLBAdapter = class {
    */
   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,
@@ -3640,14 +4635,14 @@ var MerchantMoeLBAdapter = class {
     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 = [];
@@ -3656,8 +4651,8 @@ var MerchantMoeLBAdapter = class {
       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;
       }
@@ -3669,17 +4664,17 @@ var MerchantMoeLBAdapter = class {
     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 = [];
@@ -3693,7 +4688,7 @@ var MerchantMoeLBAdapter = class {
     );
     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();
@@ -3724,11 +4719,11 @@ var MerchantMoeLBAdapter = class {
         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;
@@ -3745,7 +4740,7 @@ var MerchantMoeLBAdapter = class {
     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++) {
@@ -3792,7 +4787,7 @@ var MerchantMoeLBAdapter = class {
     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++) {
@@ -3878,26 +4873,460 @@ var MerchantMoeLBAdapter = class {
     }
     return results;
   }
-  /**
-   * Get a user's LB positions (bin balances) across a range of bin IDs.
-   * If binIds is omitted, auto-detects from the rewarder's rewarded range (or active ± 50).
-   */
-  async getUserPositions(user, pool, binIds) {
-    const rpcUrl = this.requireRpc();
-    const client = createPublicClient6({ transport: http6(rpcUrl) });
-    const resolvedBinIds = binIds && binIds.length > 0 ? binIds : await this.autoDetectBins(pool);
-    const accounts = resolvedBinIds.map(() => user);
-    const ids = resolvedBinIds.map(BigInt);
-    const balances = await client.readContract({
-      address: pool,
-      abi: lbPairAbi,
-      functionName: "balanceOfBatch",
-      args: [accounts, ids]
-    });
-    return resolvedBinIds.map((binId, i) => ({ binId, balance: balances[i] ?? 0n })).filter((p) => p.balance > 0n);
-  }
+  /**
+   * Get a user's LB positions (bin balances) across a range of bin IDs.
+   * If binIds is omitted, auto-detects from the rewarder's rewarded range (or active ± 50).
+   */
+  async getUserPositions(user, pool, binIds) {
+    const rpcUrl = this.requireRpc();
+    const client = createPublicClient8({ transport: http8(rpcUrl) });
+    const resolvedBinIds = binIds && binIds.length > 0 ? binIds : await this.autoDetectBins(pool);
+    const accounts = resolvedBinIds.map(() => user);
+    const ids = resolvedBinIds.map(BigInt);
+    const balances = await client.readContract({
+      address: pool,
+      abi: lbPairAbi,
+      functionName: "balanceOfBatch",
+      args: [accounts, ids]
+    });
+    return resolvedBinIds.map((binId, i) => ({ binId, balance: balances[i] ?? 0n })).filter((p) => p.balance > 0n);
+  }
+};
+var KITTEN_TOKEN = "0x618275f8efe54c2afa87bfb9f210a52f0ff89364";
+var WHYPE_TOKEN = "0x5555555555555555555555555555555555555555";
+var MAX_NONCE_SCAN = 60;
+var 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
+];
+var 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)"
+]);
+var positionManagerAbi2 = parseAbi13([
+  "function approveForFarming(uint256 tokenId, bool approve, address farmingAddress) external",
+  "function farmingApprovals(uint256 tokenId) external view returns (address)"
+]);
+var 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)"
+]);
+var algebraFactoryAbi = parseAbi13([
+  "function poolByPair(address tokenA, address tokenB) external view returns (address pool)"
+]);
+var _addressDecodeAbi3 = parseAbi13(["function f() external view returns (address)"]);
+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]
+  });
+}
+var nonceCache = /* @__PURE__ */ new Map();
+var 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;
+  }
 };
-var POOL_ABI = parseAbi11([
+var 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)",
@@ -3905,27 +5334,27 @@ var POOL_ABI = parseAbi11([
   "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)"
 ]);
-var ERC20_ABI2 = parseAbi11([
+var ERC20_ABI2 = parseAbi14([
   "function totalSupply() external view returns (uint256)"
 ]);
-var INCENTIVES_ABI = parseAbi11([
+var INCENTIVES_ABI = parseAbi14([
   "function getIncentivesController() external view returns (address)"
 ]);
-var REWARDS_CONTROLLER_ABI = parseAbi11([
+var 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)"
 ]);
-var POOL_PROVIDER_ABI = parseAbi11([
+var POOL_PROVIDER_ABI = parseAbi14([
   "function ADDRESSES_PROVIDER() external view returns (address)"
 ]);
-var ADDRESSES_PROVIDER_ABI = parseAbi11([
+var ADDRESSES_PROVIDER_ABI = parseAbi14([
   "function getPriceOracle() external view returns (address)"
 ]);
-var ORACLE_ABI = parseAbi11([
+var ORACLE_ABI = parseAbi14([
   "function getAssetPrice(address asset) external view returns (uint256)",
   "function BASE_CURRENCY_UNIT() external view returns (uint256)"
 ]);
-var ERC20_DECIMALS_ABI = parseAbi11([
+var ERC20_DECIMALS_ABI = parseAbi14([
   "function decimals() external view returns (uint8)"
 ]);
 function u256ToF64(v) {
@@ -3933,14 +5362,14 @@ function u256ToF64(v) {
   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
@@ -3952,7 +5381,7 @@ function decodeAddressArray(data) {
 function decodeReserveData(data) {
   if (!data) return null;
   try {
-    return decodeFunctionResult3({
+    return decodeFunctionResult6({
       abi: POOL_ABI,
       functionName: "getReserveData",
       data
@@ -3964,7 +5393,7 @@ function decodeReserveData(data) {
 function decodeRewardsData(data) {
   if (!data) return null;
   try {
-    return decodeFunctionResult3({
+    return decodeFunctionResult6({
       abi: REWARDS_CONTROLLER_ABI,
       functionName: "getRewardsData",
       data
@@ -3988,7 +5417,7 @@ var AaveV3Adapter = class {
     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]
@@ -4004,7 +5433,7 @@ var AaveV3Adapter = class {
   }
   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]
@@ -4019,7 +5448,7 @@ var AaveV3Adapter = class {
   }
   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]
@@ -4034,7 +5463,7 @@ var AaveV3Adapter = class {
     };
   }
   async buildWithdraw(params) {
-    const data = encodeFunctionData11({
+    const data = encodeFunctionData14({
       abi: POOL_ABI,
       functionName: "withdraw",
       args: [params.asset, params.amount, params.to]
@@ -4049,7 +5478,7 @@ var AaveV3Adapter = class {
   }
   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]
@@ -4076,8 +5505,8 @@ var AaveV3Adapter = class {
     const aTokenAddress = result[8];
     const variableDebtTokenAddress = result[10];
     const [supplyRaw, borrowRaw] = await multicallRead(this.rpcUrl, [
-      [aTokenAddress, encodeFunctionData11({ abi: ERC20_ABI2, functionName: "totalSupply" })],
-      [variableDebtTokenAddress, encodeFunctionData11({ abi: ERC20_ABI2, functionName: "totalSupply" })]
+      [aTokenAddress, encodeFunctionData14({ abi: ERC20_ABI2, functionName: "totalSupply" })],
+      [variableDebtTokenAddress, encodeFunctionData14({ abi: ERC20_ABI2, functionName: "totalSupply" })]
     ]);
     const totalSupply = decodeU256(supplyRaw ?? null);
     const totalBorrow = decodeU256(borrowRaw ?? null);
@@ -4088,24 +5517,24 @@ var AaveV3Adapter = class {
     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) {
@@ -4137,19 +5566,19 @@ var AaveV3Adapter = class {
     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);
@@ -4159,8 +5588,8 @@ var AaveV3Adapter = class {
         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();
@@ -4233,7 +5662,7 @@ var AaveV3Adapter = class {
   }
   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,
@@ -4248,8 +5677,8 @@ var AaveV3Adapter = class {
     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,
@@ -4260,7 +5689,7 @@ var AaveV3Adapter = class {
     };
   }
 };
-var POOL_ABI2 = parseAbi12([
+var 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)",
@@ -4273,7 +5702,7 @@ var POOL_ABI2 = parseAbi12([
   //            [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)"
 ]);
-var ERC20_ABI22 = parseAbi12([
+var ERC20_ABI22 = parseAbi15([
   "function totalSupply() external view returns (uint256)"
 ]);
 function u256ToF642(v) {
@@ -4296,7 +5725,7 @@ var AaveV2Adapter = class {
     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]
@@ -4312,7 +5741,7 @@ var AaveV2Adapter = class {
   }
   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]
@@ -4327,7 +5756,7 @@ var AaveV2Adapter = class {
   }
   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]
@@ -4342,7 +5771,7 @@ var AaveV2Adapter = class {
     };
   }
   async buildWithdraw(params) {
-    const data = encodeFunctionData12({
+    const data = encodeFunctionData15({
       abi: POOL_ABI2,
       functionName: "withdraw",
       args: [params.asset, params.amount, params.to]
@@ -4357,7 +5786,7 @@ var AaveV2Adapter = class {
   }
   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,
@@ -4403,7 +5832,7 @@ var AaveV2Adapter = class {
   }
   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,
@@ -4418,8 +5847,8 @@ var AaveV2Adapter = class {
     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,
@@ -4430,7 +5859,7 @@ var AaveV2Adapter = class {
     };
   }
 };
-var ORACLE_ABI2 = parseAbi13([
+var 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)"
@@ -4451,7 +5880,7 @@ var AaveOracleAdapter = class {
     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,
@@ -4478,7 +5907,7 @@ var AaveOracleAdapter = class {
     };
   }
   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,
@@ -4507,7 +5936,7 @@ var AaveOracleAdapter = class {
     });
   }
 };
-var CTOKEN_ABI = parseAbi14([
+var CTOKEN_ABI = parseAbi17([
   "function supplyRatePerBlock() external view returns (uint256)",
   "function borrowRatePerBlock() external view returns (uint256)",
   "function totalSupply() external view returns (uint256)",
@@ -4534,7 +5963,7 @@ var CompoundV2Adapter = class {
     return this.protocolName;
   }
   async buildSupply(params) {
-    const data = encodeFunctionData13({
+    const data = encodeFunctionData16({
       abi: CTOKEN_ABI,
       functionName: "mint",
       args: [params.amount]
@@ -4548,7 +5977,7 @@ var CompoundV2Adapter = class {
     };
   }
   async buildBorrow(params) {
-    const data = encodeFunctionData13({
+    const data = encodeFunctionData16({
       abi: CTOKEN_ABI,
       functionName: "borrow",
       args: [params.amount]
@@ -4562,7 +5991,7 @@ var CompoundV2Adapter = class {
     };
   }
   async buildRepay(params) {
-    const data = encodeFunctionData13({
+    const data = encodeFunctionData16({
       abi: CTOKEN_ABI,
       functionName: "repayBorrow",
       args: [params.amount]
@@ -4576,7 +6005,7 @@ var CompoundV2Adapter = class {
     };
   }
   async buildWithdraw(params) {
-    const data = encodeFunctionData13({
+    const data = encodeFunctionData16({
       abi: CTOKEN_ABI,
       functionName: "redeem",
       args: [params.amount]
@@ -4591,7 +6020,7 @@ var CompoundV2Adapter = class {
   }
   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}`);
@@ -4625,7 +6054,7 @@ var CompoundV2Adapter = class {
     );
   }
 };
-var COMET_ABI = parseAbi15([
+var 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)",
@@ -4651,7 +6080,7 @@ var CompoundV3Adapter = class {
     return this.protocolName;
   }
   async buildSupply(params) {
-    const data = encodeFunctionData14({
+    const data = encodeFunctionData17({
       abi: COMET_ABI,
       functionName: "supply",
       args: [params.asset, params.amount]
@@ -4665,7 +6094,7 @@ var CompoundV3Adapter = class {
     };
   }
   async buildBorrow(params) {
-    const data = encodeFunctionData14({
+    const data = encodeFunctionData17({
       abi: COMET_ABI,
       functionName: "withdraw",
       args: [params.asset, params.amount]
@@ -4679,7 +6108,7 @@ var CompoundV3Adapter = class {
     };
   }
   async buildRepay(params) {
-    const data = encodeFunctionData14({
+    const data = encodeFunctionData17({
       abi: COMET_ABI,
       functionName: "supply",
       args: [params.asset, params.amount]
@@ -4693,7 +6122,7 @@ var CompoundV3Adapter = class {
     };
   }
   async buildWithdraw(params) {
-    const data = encodeFunctionData14({
+    const data = encodeFunctionData17({
       abi: COMET_ABI,
       functionName: "withdraw",
       args: [params.asset, params.amount]
@@ -4708,7 +6137,7 @@ var CompoundV3Adapter = class {
   }
   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,
@@ -4747,7 +6176,7 @@ var CompoundV3Adapter = class {
     );
   }
 };
-var EULER_VAULT_ABI = parseAbi16([
+var 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)",
@@ -4773,7 +6202,7 @@ var EulerV2Adapter = class {
     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]
@@ -4787,7 +6216,7 @@ var EulerV2Adapter = class {
     };
   }
   async buildBorrow(params) {
-    const data = encodeFunctionData15({
+    const data = encodeFunctionData18({
       abi: EULER_VAULT_ABI,
       functionName: "borrow",
       args: [params.amount, params.on_behalf_of]
@@ -4801,7 +6230,7 @@ var EulerV2Adapter = class {
     };
   }
   async buildRepay(params) {
-    const data = encodeFunctionData15({
+    const data = encodeFunctionData18({
       abi: EULER_VAULT_ABI,
       functionName: "repay",
       args: [params.amount, params.on_behalf_of]
@@ -4815,7 +6244,7 @@ var EulerV2Adapter = class {
     };
   }
   async buildWithdraw(params) {
-    const data = encodeFunctionData15({
+    const data = encodeFunctionData18({
       abi: EULER_VAULT_ABI,
       functionName: "withdraw",
       args: [params.amount, params.to, params.to]
@@ -4830,7 +6259,7 @@ var EulerV2Adapter = class {
   }
   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}`);
@@ -4864,7 +6293,7 @@ var EulerV2Adapter = class {
     );
   }
 };
-var MORPHO_ABI = parseAbi17([
+var 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)",
@@ -4872,29 +6301,29 @@ var MORPHO_ABI = parseAbi17([
   "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)"
 ]);
-var META_MORPHO_ABI = parseAbi17([
+var 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)"
 ]);
-var IRM_ABI = parseAbi17([
+var 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)"
 ]);
 var SECONDS_PER_YEAR3 = 365.25 * 24 * 3600;
-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
@@ -4906,7 +6335,7 @@ function decodeMarket(data) {
 function decodeMarketParams(data) {
   if (!data) return null;
   try {
-    return decodeFunctionResult4({
+    return decodeFunctionResult7({
       abi: MORPHO_ABI,
       functionName: "idToMarketParams",
       data
@@ -4934,7 +6363,7 @@ var MorphoBlueAdapter = class {
   }
   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"]
@@ -4949,7 +6378,7 @@ var MorphoBlueAdapter = class {
   }
   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]
@@ -4964,7 +6393,7 @@ var MorphoBlueAdapter = class {
   }
   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"]
@@ -4979,7 +6408,7 @@ var MorphoBlueAdapter = class {
   }
   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]
@@ -4998,7 +6427,7 @@ var MorphoBlueAdapter = class {
       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}`);
     });
@@ -5015,7 +6444,7 @@ var MorphoBlueAdapter = class {
       };
     }
     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}`);
     });
@@ -5024,8 +6453,8 @@ var MorphoBlueAdapter = class {
     }
     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}`);
     });
@@ -5042,7 +6471,7 @@ var MorphoBlueAdapter = class {
     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}`);
       });
@@ -5068,18 +6497,18 @@ var MorphoBlueAdapter = class {
     );
   }
 };
-var BORROWER_OPS_ABI = parseAbi18([
+var 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"
 ]);
-var TROVE_MANAGER_ABI = parseAbi18([
+var 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)"
 ]);
-var HINT_HELPERS_ABI = parseAbi18([
+var HINT_HELPERS_ABI = parseAbi21([
   "function getApproxHint(uint256 _collIndex, uint256 _interestRate, uint256 _numTrials, uint256 _inputRandomSeed) external view returns (uint256 hintId, uint256 diff, uint256 latestRandomSeed)"
 ]);
-var SORTED_TROVES_ABI = parseAbi18([
+var SORTED_TROVES_ABI = parseAbi21([
   "function findInsertPosition(uint256 _annualInterestRate, uint256 _prevId, uint256 _nextId) external view returns (uint256 prevId, uint256 nextId)"
 ]);
 var FelixCdpAdapter = class {
@@ -5107,7 +6536,7 @@ var FelixCdpAdapter = class {
     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,
@@ -5130,7 +6559,7 @@ var FelixCdpAdapter = class {
     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: [
@@ -5159,7 +6588,7 @@ var FelixCdpAdapter = class {
   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: [
@@ -5182,7 +6611,7 @@ var FelixCdpAdapter = class {
     };
   }
   async buildClose(params) {
-    const data = encodeFunctionData17({
+    const data = encodeFunctionData20({
       abi: BORROWER_OPS_ABI,
       functionName: "closeTrove",
       args: [params.cdp_id]
@@ -5198,7 +6627,7 @@ var FelixCdpAdapter = class {
   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,
@@ -5216,13 +6645,13 @@ var FelixCdpAdapter = class {
       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
@@ -5231,7 +6660,7 @@ var FelixCdpAdapter = class {
     };
   }
 };
-var PRICE_FEED_ABI = parseAbi19([
+var PRICE_FEED_ABI = parseAbi222([
   "function fetchPrice() external view returns (uint256 price, bool isNewOracleFailureDetected)",
   "function lastGoodPrice() external view returns (uint256)"
 ]);
@@ -5257,7 +6686,7 @@ var FelixOracleAdapter = class {
     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({
@@ -5296,7 +6725,7 @@ var FelixOracleAdapter = class {
     return results;
   }
 };
-var ERC4626_ABI = parseAbi20([
+var ERC4626_ABI = parseAbi23([
   "function asset() external view returns (address)",
   "function totalAssets() external view returns (uint256)",
   "function totalSupply() external view returns (uint256)",
@@ -5320,7 +6749,7 @@ var ERC4626VaultAdapter = class {
     return this.protocolName;
   }
   async buildDeposit(assets, receiver) {
-    const data = encodeFunctionData18({
+    const data = encodeFunctionData21({
       abi: ERC4626_ABI,
       functionName: "deposit",
       args: [assets, receiver]
@@ -5334,7 +6763,7 @@ var ERC4626VaultAdapter = class {
     };
   }
   async buildWithdraw(assets, receiver, owner) {
-    const data = encodeFunctionData18({
+    const data = encodeFunctionData21({
       abi: ERC4626_ABI,
       functionName: "withdraw",
       args: [assets, receiver, owner]
@@ -5349,7 +6778,7 @@ var ERC4626VaultAdapter = class {
   }
   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,
@@ -5360,7 +6789,7 @@ var ERC4626VaultAdapter = class {
   }
   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,
@@ -5372,7 +6801,7 @@ var ERC4626VaultAdapter = class {
   }
   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,
@@ -5384,7 +6813,7 @@ var ERC4626VaultAdapter = class {
   }
   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}`);
@@ -5405,7 +6834,7 @@ var ERC4626VaultAdapter = class {
     };
   }
 };
-var GENERIC_LST_ABI = parseAbi21([
+var GENERIC_LST_ABI = parseAbi24([
   "function stake() external payable returns (uint256)",
   "function unstake(uint256 amount) external returns (uint256)"
 ]);
@@ -5422,7 +6851,7 @@ var GenericLstAdapter = class {
     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,
@@ -5432,7 +6861,7 @@ var GenericLstAdapter = class {
     };
   }
   async buildUnstake(params) {
-    const data = encodeFunctionData19({
+    const data = encodeFunctionData222({
       abi: GENERIC_LST_ABI,
       functionName: "unstake",
       args: [params.amount]
@@ -5449,11 +6878,11 @@ var GenericLstAdapter = class {
     throw DefiError.unsupported(`[${this.protocolName}] getInfo requires RPC`);
   }
 };
-var STHYPE_ABI = parseAbi222([
+var STHYPE_ABI = parseAbi25([
   "function submit(address referral) external payable returns (uint256)",
   "function requestWithdrawals(uint256[] amounts, address owner) external returns (uint256[] requestIds)"
 ]);
-var ERC20_ABI3 = parseAbi222([
+var ERC20_ABI3 = parseAbi25([
   "function totalSupply() external view returns (uint256)"
 ]);
 var StHypeAdapter = class {
@@ -5473,10 +6902,10 @@ var StHypeAdapter = class {
     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`,
@@ -5487,7 +6916,7 @@ var StHypeAdapter = class {
     };
   }
   async buildUnstake(params) {
-    const data = encodeFunctionData20({
+    const data = encodeFunctionData23({
       abi: STHYPE_ABI,
       functionName: "requestWithdrawals",
       args: [[params.amount], params.recipient]
@@ -5502,7 +6931,7 @@ var StHypeAdapter = class {
   }
   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,
@@ -5513,19 +6942,19 @@ var StHypeAdapter = class {
     });
     return {
       protocol: this.protocolName,
-      staked_token: zeroAddress9,
+      staked_token: zeroAddress12,
       liquid_token: tokenAddr,
       exchange_rate: 1,
       total_staked: totalSupply
     };
   }
 };
-var KINETIQ_ABI = parseAbi23([
+var KINETIQ_ABI = parseAbi26([
   "function stake() external payable returns (uint256)",
   "function requestUnstake(uint256 amount) external returns (uint256)",
   "function totalStaked() external view returns (uint256)"
 ]);
-var ORACLE_ABI3 = parseAbi23([
+var ORACLE_ABI3 = parseAbi26([
   "function getAssetPrice(address asset) external view returns (uint256)"
 ]);
 var WHYPE = "0x5555555555555555555555555555555555555555";
@@ -5547,7 +6976,7 @@ var KinetiqAdapter = class {
     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,
@@ -5557,7 +6986,7 @@ var KinetiqAdapter = class {
     };
   }
   async buildUnstake(params) {
-    const data = encodeFunctionData21({
+    const data = encodeFunctionData24({
       abi: KINETIQ_ABI,
       functionName: "requestUnstake",
       args: [params.amount]
@@ -5572,7 +7001,7 @@ var KinetiqAdapter = class {
   }
   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,
@@ -5587,22 +7016,22 @@ var KinetiqAdapter = class {
     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
     };
   }
 };
-var HLP_ABI = parseAbi24([
+var HLP_ABI = parseAbi27([
   "function deposit(uint256 amount) external returns (uint256)",
   "function withdraw(uint256 shares) external returns (uint256)"
 ]);
-var RYSK_ABI = parseAbi25([
+var 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)"
 ]);
-var ERC721_ABI = parseAbi26([
+var ERC721_ABI = parseAbi29([
   "function name() returns (string)",
   "function symbol() returns (string)",
   "function totalSupply() returns (uint256)",
@@ -5622,7 +7051,7 @@ var ERC721Adapter = class {
   }
   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}`);
@@ -5641,7 +7070,7 @@ var ERC721Adapter = class {
   }
   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}`);
@@ -5657,7 +7086,7 @@ var ERC721Adapter = class {
   }
   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}`);
     });
@@ -5678,6 +7107,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":
@@ -5738,11 +7169,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`);
@@ -5781,6 +7214,22 @@ function createOracleFromCdp(entry, _asset, rpcUrl) {
 function createMerchantMoeLB(entry, rpcUrl) {
   return new MerchantMoeLBAdapter(entry, rpcUrl);
 }
+function createKittenSwapFarming(entry, rpcUrl) {
+  const farmingCenter = entry.contracts?.["farming_center"];
+  if (!farmingCenter) {
+    throw new DefiError("CONTRACT_ERROR", `[${entry.name}] Missing 'farming_center' contract address`);
+  }
+  const eternalFarming = entry.contracts?.["eternal_farming"];
+  if (!eternalFarming) {
+    throw new DefiError("CONTRACT_ERROR", `[${entry.name}] Missing 'eternal_farming' contract address`);
+  }
+  const positionManager = entry.contracts?.["position_manager"];
+  if (!positionManager) {
+    throw new DefiError("CONTRACT_ERROR", `[${entry.name}] Missing 'position_manager' contract address`);
+  }
+  const factory = entry.contracts?.["factory"];
+  return new KittenSwapFarmingAdapter(entry.name, farmingCenter, eternalFarming, positionManager, rpcUrl, factory);
+}
 var DexSpotPrice = class {
   /**
    * Get the spot price for `token` denominated in `quoteToken` (e.g. USDC).
@@ -5853,7 +7302,7 @@ function registerDex(parent, getOpts, makeExecutor2) {
     const result = await executor.execute(tx);
     printOutput(result, getOpts());
   });
-  dex.command("lp-add").description("Add liquidity to a pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--amount-a <amount>", "Amount of token A in wei").requiredOption("--amount-b <amount>", "Amount of token B in wei").option("--recipient <address>", "Recipient address").action(async (opts) => {
+  dex.command("lp-add").description("Add liquidity to a pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--amount-a <amount>", "Amount of token A in wei").requiredOption("--amount-b <amount>", "Amount of token B in wei").option("--recipient <address>", "Recipient address").option("--tick-lower <tick>", "Lower tick for concentrated LP (default: full range)").option("--tick-upper <tick>", "Upper tick for concentrated LP (default: full range)").option("--range <percent>", "\xB1N% concentrated range around current price (e.g. --range 2 for \xB12%)").option("--pool <name_or_address>", "Pool name (e.g. WHYPE/USDC) or address").action(async (opts) => {
     const executor = makeExecutor2();
     const chainName = parent.opts().chain ?? "hyperevm";
     const registry = Registry.loadEmbedded();
@@ -5863,13 +7312,26 @@ function registerDex(parent, getOpts, makeExecutor2) {
     const tokenA = opts.tokenA.startsWith("0x") ? opts.tokenA : registry.resolveToken(chainName, opts.tokenA).address;
     const tokenB = opts.tokenB.startsWith("0x") ? opts.tokenB : registry.resolveToken(chainName, opts.tokenB).address;
     const recipient = opts.recipient ?? process.env.DEFI_WALLET_ADDRESS ?? "0x0000000000000000000000000000000000000001";
+    let poolAddr;
+    if (opts.pool) {
+      if (opts.pool.startsWith("0x")) {
+        poolAddr = opts.pool;
+      } else {
+        const poolInfo = registry.resolvePool(opts.protocol, opts.pool);
+        poolAddr = poolInfo.address;
+      }
+    }
     const tx = await adapter.buildAddLiquidity({
       protocol: protocol.name,
       token_a: tokenA,
       token_b: tokenB,
       amount_a: BigInt(opts.amountA),
       amount_b: BigInt(opts.amountB),
-      recipient
+      recipient,
+      tick_lower: opts.tickLower !== void 0 ? parseInt(opts.tickLower) : void 0,
+      tick_upper: opts.tickUpper !== void 0 ? parseInt(opts.tickUpper) : void 0,
+      range_pct: opts.range !== void 0 ? parseFloat(opts.range) : void 0,
+      pool: poolAddr
     });
     const result = await executor.execute(tx);
     printOutput(result, getOpts());
@@ -5918,57 +7380,96 @@ function registerDex(parent, getOpts, makeExecutor2) {
 
 // src/commands/gauge.ts
 import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+function resolveAccount() {
+  const walletAddr = process.env["DEFI_WALLET_ADDRESS"];
+  if (walletAddr) return walletAddr;
+  const privateKey = process.env["DEFI_PRIVATE_KEY"];
+  if (privateKey) return privateKeyToAccount2(privateKey).address;
+  return void 0;
+}
 function registerGauge(parent, getOpts, makeExecutor2) {
-  const gauge = parent.command("gauge").description("Gauge operations: deposit, withdraw, claim, lock, vote (ve(3,3))");
-  gauge.command("deposit").description("Deposit LP tokens into a gauge").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--gauge <address>", "Gauge contract address").requiredOption("--amount <amount>", "LP token amount in wei").option("--ve-nft <tokenId>", "veNFT token ID for boosted rewards").action(async (opts) => {
-    const executor = makeExecutor2();
+  const gauge = parent.command("gauge").description("Gauge operations: find, deposit, withdraw, claim, earned");
+  gauge.command("discover").description("Find all pools with emission gauges (scans V2 + CL factories)").requiredOption("--protocol <protocol>", "Protocol slug").action(async (opts) => {
+    const chainName = parent.opts().chain ?? "hyperevm";
     const registry = Registry.loadEmbedded();
+    const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createGauge(protocol);
-    const tokenId = opts.veNft ? BigInt(opts.veNft) : void 0;
-    const tx = await adapter.buildDeposit(opts.gauge, BigInt(opts.amount), tokenId);
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
+    const adapter = createGauge(protocol, chain.effectiveRpcUrl());
+    if (!adapter.discoverGaugedPools) throw new Error(`${protocol.name} does not support gauge discovery`);
+    const pools = await adapter.discoverGaugedPools();
+    printOutput(pools, getOpts());
   });
-  gauge.command("withdraw").description("Withdraw LP tokens from a gauge").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--gauge <address>", "Gauge contract address").requiredOption("--amount <amount>", "LP token amount in wei").action(async (opts) => {
-    const executor = makeExecutor2();
+  gauge.command("find").description("Find gauge address for a pool via voter contract").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--pool <address>", "Pool address").action(async (opts) => {
+    const chainName = parent.opts().chain ?? "hyperevm";
     const registry = Registry.loadEmbedded();
+    const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createGauge(protocol);
-    const tx = await adapter.buildWithdraw(opts.gauge, BigInt(opts.amount));
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
+    const adapter = createGauge(protocol, chain.effectiveRpcUrl());
+    if (!adapter.resolveGauge) throw new Error(`${protocol.name} does not support gauge lookup`);
+    const gaugeAddr = await adapter.resolveGauge(opts.pool);
+    printOutput({ pool: opts.pool, gauge: gaugeAddr, protocol: protocol.name }, getOpts());
+  });
+  gauge.command("earned").description("Check pending rewards for a gauge").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--gauge <address>", "Gauge contract address").option("--token-id <id>", "NFT tokenId (for CL gauges like Hybra)").action(async (opts) => {
+    const chainName = parent.opts().chain ?? "hyperevm";
+    const registry = Registry.loadEmbedded();
+    const chain = registry.getChain(chainName);
+    const protocol = registry.getProtocol(opts.protocol);
+    const adapter = createGauge(protocol, chain.effectiveRpcUrl());
+    if (opts.tokenId) {
+      if (!adapter.getPendingRewardsByTokenId) throw new Error(`${protocol.name} does not support NFT rewards`);
+      const earned = await adapter.getPendingRewardsByTokenId(opts.gauge, BigInt(opts.tokenId));
+      printOutput({ gauge: opts.gauge, token_id: opts.tokenId, earned: earned.toString() }, getOpts());
+    } else {
+      const account = resolveAccount();
+      if (!account) throw new Error("DEFI_WALLET_ADDRESS or DEFI_PRIVATE_KEY required");
+      const rewards = await adapter.getPendingRewards(opts.gauge, account);
+      printOutput(rewards.map((r) => ({ token: r.token, amount: r.amount.toString() })), getOpts());
+    }
   });
-  gauge.command("claim").description("Claim earned rewards from a gauge").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--gauge <address>", "Gauge contract address").action(async (opts) => {
+  gauge.command("deposit").description("Deposit LP tokens or NFT into a gauge").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--gauge <address>", "Gauge contract address").option("--amount <amount>", "LP token amount in wei (for V2 gauges)").option("--token-id <id>", "NFT tokenId (for CL gauges like Hybra)").action(async (opts) => {
     const executor = makeExecutor2();
+    const chainName = parent.opts().chain ?? "hyperevm";
     const registry = Registry.loadEmbedded();
+    const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createGauge(protocol, executor.rpcUrl);
-    const privateKey = process.env["DEFI_PRIVATE_KEY"];
-    const account = privateKey ? privateKeyToAccount2(privateKey).address : void 0;
-    const tx = await adapter.buildClaimRewards(opts.gauge, account);
+    const adapter = createGauge(protocol, chain.effectiveRpcUrl());
+    const amount = opts.amount ? BigInt(opts.amount) : 0n;
+    const tokenId = opts.tokenId ? BigInt(opts.tokenId) : void 0;
+    const tx = await adapter.buildDeposit(opts.gauge, amount, tokenId);
     const result = await executor.execute(tx);
     printOutput(result, getOpts());
   });
-  gauge.command("lock").description("Create a veNFT lock").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--amount <amount>", "Amount to lock in wei").option("--days <days>", "Lock duration in days", "365").action(async (opts) => {
+  gauge.command("withdraw").description("Withdraw LP tokens or NFT from a gauge").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--gauge <address>", "Gauge contract address").option("--amount <amount>", "LP token amount in wei (for V2 gauges)").option("--token-id <id>", "NFT tokenId (for CL gauges like Hybra)").action(async (opts) => {
     const executor = makeExecutor2();
+    const chainName = parent.opts().chain ?? "hyperevm";
     const registry = Registry.loadEmbedded();
+    const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createGauge(protocol);
-    const tx = await adapter.buildCreateLock(BigInt(opts.amount), parseInt(opts.days) * 86400);
+    const adapter = createGauge(protocol, chain.effectiveRpcUrl());
+    const amount = opts.amount ? BigInt(opts.amount) : 0n;
+    const tokenId = opts.tokenId ? BigInt(opts.tokenId) : void 0;
+    const tx = await adapter.buildWithdraw(opts.gauge, amount, tokenId);
     const result = await executor.execute(tx);
     printOutput(result, getOpts());
   });
-  gauge.command("vote").description("Vote on gauge emissions with veNFT").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--ve-nft <tokenId>", "veNFT token ID").requiredOption("--pools <pools>", "Pool addresses (comma-separated)").requiredOption("--weights <weights>", "Vote weights (comma-separated)").action(async (opts) => {
+  gauge.command("claim").description("Claim earned rewards from a gauge").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--gauge <address>", "Gauge contract address").option("--token-id <id>", "NFT tokenId (for CL gauges like Hybra)").action(async (opts) => {
     const executor = makeExecutor2();
+    const chainName = parent.opts().chain ?? "hyperevm";
     const registry = Registry.loadEmbedded();
+    const chain = registry.getChain(chainName);
     const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createGauge(protocol);
-    const pools = opts.pools.split(",");
-    const weights = opts.weights.split(",").map((w) => BigInt(w));
-    const tx = await adapter.buildVote(BigInt(opts.veNft), pools, weights);
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
+    const adapter = createGauge(protocol, chain.effectiveRpcUrl());
+    if (opts.tokenId) {
+      if (!adapter.buildClaimRewardsByTokenId) throw new Error(`${protocol.name} does not support NFT claim`);
+      const tx = await adapter.buildClaimRewardsByTokenId(opts.gauge, BigInt(opts.tokenId));
+      const result = await executor.execute(tx);
+      printOutput(result, getOpts());
+    } else {
+      const account = resolveAccount();
+      const tx = await adapter.buildClaimRewards(opts.gauge, account);
+      const result = await executor.execute(tx);
+      printOutput(result, getOpts());
+    }
   });
 }
 
@@ -6215,9 +7716,7 @@ function resolveAsset(registry, chain, asset) {
   return registry.resolveToken(chain, asset).address;
 }
 async function collectLendingRates(registry, chainName, rpc, assetAddr) {
-  const protos = registry.getProtocolsForChain(chainName).filter(
-    (p) => p.category === ProtocolCategory.Lending && (p.interface === "aave_v3" || p.interface === "aave_v3_isolated")
-  );
+  const protos = registry.getProtocolsForChain(chainName).filter((p) => p.category === ProtocolCategory.Lending);
   const results = [];
   let first = true;
   for (const proto of protos) {
@@ -6305,7 +7804,7 @@ async function runYieldScan(registry, asset, output) {
       } catch {
         return [];
       }
-      const protos = registry.getProtocolsForChain(chainName).filter((p) => p.category === ProtocolCategory.Lending && p.interface === "aave_v3");
+      const protos = registry.getProtocolsForChain(chainName).filter((p) => p.category === ProtocolCategory.Lending);
       if (protos.length === 0) return [];
       const rpc = chain.effectiveRpcUrl();
       const rates = [];
@@ -6388,7 +7887,7 @@ async function scanRatesForExecute(registry, asset) {
       } catch {
         return [];
       }
-      const protos = registry.getProtocolsForChain(chainName).filter((p) => p.category === ProtocolCategory.Lending && p.interface === "aave_v3");
+      const protos = registry.getProtocolsForChain(chainName).filter((p) => p.category === ProtocolCategory.Lending);
       if (protos.length === 0) return [];
       const rpc = chain.effectiveRpcUrl();
       const rates = [];
@@ -6420,7 +7919,26 @@ async function scanRatesForExecute(registry, asset) {
 }
 function registerYield(parent, getOpts, makeExecutor2) {
   const yieldCmd = parent.command("yield").description("Yield operations: compare, scan, optimize, execute");
-  yieldCmd.command("compare").description("Compare lending rates across protocols for an asset").requiredOption("--asset <token>", "Token symbol or address").action(async (opts) => {
+  yieldCmd.option("--asset <token>", "Token symbol or address", "USDC").action(async (opts) => {
+    try {
+      const registry = Registry.loadEmbedded();
+      const chainName = (parent.opts().chain ?? "hyperevm").toLowerCase();
+      const chain = registry.getChain(chainName);
+      const rpc = chain.effectiveRpcUrl();
+      const assetAddr = resolveAsset(registry, chainName, opts.asset);
+      const results = await collectLendingRates(registry, chainName, rpc, assetAddr);
+      results.sort((a, b) => b.supply_apy - a.supply_apy);
+      const bestSupply = results[0]?.protocol ?? null;
+      const bestBorrow = results.reduce((best, r) => {
+        if (!best || r.borrow_variable_apy < best.borrow_variable_apy) return r;
+        return best;
+      }, null)?.protocol ?? null;
+      printOutput({ asset: opts.asset, chain: chainName, rates: results, best_supply: bestSupply, best_borrow: bestBorrow }, getOpts());
+    } catch (err) {
+      printOutput({ error: String(err) }, getOpts());
+    }
+  });
+  yieldCmd.command("compare").description("Compare lending rates across protocols for an asset").option("--asset <token>", "Token symbol or address", "USDC").action(async (opts) => {
     try {
       const registry = Registry.loadEmbedded();
       const chainName = (parent.opts().chain ?? "hyperevm").toLowerCase();
@@ -6596,7 +8114,7 @@ function registerYield(parent, getOpts, makeExecutor2) {
           return;
         }
       } else {
-        const candidates = registry.getProtocolsForChain(chainName).filter((p) => p.category === ProtocolCategory.Lending && p.interface === "aave_v3");
+        const candidates = registry.getProtocolsForChain(chainName).filter((p) => p.category === ProtocolCategory.Lending);
         if (candidates.length === 0) {
           printOutput({ error: `No aave_v3 lending protocol found on ${chainName}` }, getOpts());
           process.exit(1);
@@ -6788,20 +8306,20 @@ function registerYield(parent, getOpts, makeExecutor2) {
 }
 
 // src/commands/portfolio.ts
-import { encodeFunctionData as encodeFunctionData25, parseAbi as parseAbi28 } from "viem";
+import { encodeFunctionData as encodeFunctionData28, parseAbi as parseAbi31 } from "viem";
 
 // src/portfolio-tracker.ts
 import { mkdirSync, writeFileSync, readdirSync as readdirSync2, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
 import { homedir } from "os";
 import { resolve as resolve2 } from "path";
-import { encodeFunctionData as encodeFunctionData24, parseAbi as parseAbi27 } from "viem";
-var ERC20_ABI4 = parseAbi27([
+import { encodeFunctionData as encodeFunctionData27, parseAbi as parseAbi30 } from "viem";
+var ERC20_ABI4 = parseAbi30([
   "function balanceOf(address owner) external view returns (uint256)"
 ]);
-var ORACLE_ABI4 = parseAbi27([
+var ORACLE_ABI4 = parseAbi30([
   "function getAssetPrice(address asset) external view returns (uint256)"
 ]);
-var POOL_ABI3 = parseAbi27([
+var POOL_ABI3 = parseAbi30([
   "function getUserAccountData(address user) external view returns (uint256 totalCollateralBase, uint256 totalDebtBase, uint256 availableBorrowsBase, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor)"
 ]);
 function decodeU256Word(data, wordOffset = 0) {
@@ -6830,7 +8348,7 @@ async function takeSnapshot(chainName, wallet, registry) {
     tokenEntries.push({ symbol: t.symbol, address: entry.address, decimals: entry.decimals });
     calls.push([
       entry.address,
-      encodeFunctionData24({ abi: ERC20_ABI4, functionName: "balanceOf", args: [user] })
+      encodeFunctionData27({ abi: ERC20_ABI4, functionName: "balanceOf", args: [user] })
     ]);
     callLabels.push(`balance:${t.symbol}`);
   }
@@ -6838,7 +8356,7 @@ async function takeSnapshot(chainName, wallet, registry) {
   for (const p of lendingProtocols) {
     calls.push([
       p.contracts["pool"],
-      encodeFunctionData24({ abi: POOL_ABI3, functionName: "getUserAccountData", args: [user] })
+      encodeFunctionData27({ abi: POOL_ABI3, functionName: "getUserAccountData", args: [user] })
     ]);
     callLabels.push(`lending:${p.name}`);
   }
@@ -6848,7 +8366,7 @@ async function takeSnapshot(chainName, wallet, registry) {
   if (oracleAddr) {
     calls.push([
       oracleAddr,
-      encodeFunctionData24({ abi: ORACLE_ABI4, functionName: "getAssetPrice", args: [wrappedNative] })
+      encodeFunctionData27({ abi: ORACLE_ABI4, functionName: "getAssetPrice", args: [wrappedNative] })
     ]);
     callLabels.push("price:native");
   }
@@ -6986,13 +8504,13 @@ function calculatePnL(current, previous) {
 }
 
 // src/commands/portfolio.ts
-var ERC20_ABI5 = parseAbi28([
+var ERC20_ABI5 = parseAbi31([
   "function balanceOf(address owner) external view returns (uint256)"
 ]);
-var POOL_ABI4 = parseAbi28([
+var POOL_ABI4 = parseAbi31([
   "function getUserAccountData(address user) external view returns (uint256 totalCollateralBase, uint256 totalDebtBase, uint256 availableBorrowsBase, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor)"
 ]);
-var ORACLE_ABI5 = parseAbi28([
+var ORACLE_ABI5 = parseAbi31([
   "function getAssetPrice(address asset) external view returns (uint256)"
 ]);
 function decodeU2562(data, wordOffset = 0) {
@@ -7032,7 +8550,7 @@ function registerPortfolio(parent, getOpts) {
       if (entry.address === "0x0000000000000000000000000000000000000000") continue;
       calls.push([
         entry.address,
-        encodeFunctionData25({ abi: ERC20_ABI5, functionName: "balanceOf", args: [user] })
+        encodeFunctionData28({ abi: ERC20_ABI5, functionName: "balanceOf", args: [user] })
       ]);
       callLabels.push(`balance:${symbol}`);
     }
@@ -7040,7 +8558,7 @@ function registerPortfolio(parent, getOpts) {
     for (const p of lendingProtocols) {
       calls.push([
         p.contracts["pool"],
-        encodeFunctionData25({ abi: POOL_ABI4, functionName: "getUserAccountData", args: [user] })
+        encodeFunctionData28({ abi: POOL_ABI4, functionName: "getUserAccountData", args: [user] })
       ]);
       callLabels.push(`lending:${p.name}`);
     }
@@ -7050,7 +8568,7 @@ function registerPortfolio(parent, getOpts) {
     if (oracleAddr) {
       calls.push([
         oracleAddr,
-        encodeFunctionData25({ abi: ORACLE_ABI5, functionName: "getAssetPrice", args: [wrappedNative] })
+        encodeFunctionData28({ abi: ORACLE_ABI5, functionName: "getAssetPrice", args: [wrappedNative] })
       ]);
       callLabels.push("price:native");
     }
@@ -7412,14 +8930,14 @@ function registerAlert(parent, getOpts) {
 }
 
 // src/commands/scan.ts
-import { encodeFunctionData as encodeFunctionData26, parseAbi as parseAbi29 } from "viem";
-var AAVE_ORACLE_ABI = parseAbi29([
+import { encodeFunctionData as encodeFunctionData29, parseAbi as parseAbi33 } from "viem";
+var AAVE_ORACLE_ABI = parseAbi33([
   "function getAssetPrice(address asset) external view returns (uint256)"
 ]);
-var UNIV2_ROUTER_ABI = parseAbi29([
+var UNIV2_ROUTER_ABI = parseAbi33([
   "function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory)"
 ]);
-var VTOKEN_ABI = parseAbi29([
+var VTOKEN_ABI = parseAbi33([
   "function exchangeRateStored() external view returns (uint256)"
 ]);
 var STABLECOINS = /* @__PURE__ */ new Set(["USDC", "USDT", "DAI", "USDT0"]);
@@ -7529,7 +9047,7 @@ function registerScan(parent, getOpts) {
               callTypes.push({ kind: "oracle", oracle: oracle.name, token: token.symbol, oracleDecimals: oracle.decimals });
               calls.push([
                 oracle.addr,
-                encodeFunctionData26({ abi: AAVE_ORACLE_ABI, functionName: "getAssetPrice", args: [token.address] })
+                encodeFunctionData29({ abi: AAVE_ORACLE_ABI, functionName: "getAssetPrice", args: [token.address] })
               ]);
             }
           }
@@ -7540,7 +9058,7 @@ function registerScan(parent, getOpts) {
               callTypes.push({ kind: "dex", token: token.symbol, outDecimals: quoteStable.decimals });
               calls.push([
                 dexRouter,
-                encodeFunctionData26({ abi: UNIV2_ROUTER_ABI, functionName: "getAmountsOut", args: [amountIn, path] })
+                encodeFunctionData29({ abi: UNIV2_ROUTER_ABI, functionName: "getAmountsOut", args: [amountIn, path] })
               ]);
             }
           }
@@ -7549,7 +9067,7 @@ function registerScan(parent, getOpts) {
           callTypes.push({ kind: "stable", from: "USDC", to: "USDT", outDecimals: usdt.decimals });
           calls.push([
             dexRouter,
-            encodeFunctionData26({
+            encodeFunctionData29({
               abi: UNIV2_ROUTER_ABI,
               functionName: "getAmountsOut",
               args: [BigInt(10) ** BigInt(usdc.decimals), [usdc.address, usdt.address]]
@@ -7558,7 +9076,7 @@ function registerScan(parent, getOpts) {
           callTypes.push({ kind: "stable", from: "USDT", to: "USDC", outDecimals: usdc.decimals });
           calls.push([
             dexRouter,
-            encodeFunctionData26({
+            encodeFunctionData29({
               abi: UNIV2_ROUTER_ABI,
               functionName: "getAmountsOut",
               args: [BigInt(10) ** BigInt(usdt.decimals), [usdt.address, usdc.address]]
@@ -7569,7 +9087,7 @@ function registerScan(parent, getOpts) {
           for (const fork of compoundForks) {
             for (const { key, addr } of fork.vtokens) {
               callTypes.push({ kind: "exchangeRate", protocol: fork.name, vtoken: key });
-              calls.push([addr, encodeFunctionData26({ abi: VTOKEN_ABI, functionName: "exchangeRateStored", args: [] })]);
+              calls.push([addr, encodeFunctionData29({ abi: VTOKEN_ABI, functionName: "exchangeRateStored", args: [] })]);
             }
           }
         }
@@ -7787,22 +9305,22 @@ async function runAllChains(registry, patterns, oracleThreshold, stableThreshold
         for (const oracle of oracles) {
           for (const token of scanTokens) {
             cts.push({ kind: "oracle", oracle: oracle.name, token: token.symbol, dec: oracle.decimals });
-            calls.push([oracle.addr, encodeFunctionData26({ abi: AAVE_ORACLE_ABI, functionName: "getAssetPrice", args: [token.address] })]);
+            calls.push([oracle.addr, encodeFunctionData29({ abi: AAVE_ORACLE_ABI, functionName: "getAssetPrice", args: [token.address] })]);
           }
         }
         if (dexRouter) {
           for (const token of scanTokens) {
             const path = wrappedNative && token.address.toLowerCase() === wrappedNative.toLowerCase() ? [token.address, quoteStable.address] : wrappedNative ? [token.address, wrappedNative, quoteStable.address] : [token.address, quoteStable.address];
             cts.push({ kind: "dex", token: token.symbol, dec: quoteStable.decimals });
-            calls.push([dexRouter, encodeFunctionData26({ abi: UNIV2_ROUTER_ABI, functionName: "getAmountsOut", args: [BigInt(10) ** BigInt(token.decimals), path] })]);
+            calls.push([dexRouter, encodeFunctionData29({ abi: UNIV2_ROUTER_ABI, functionName: "getAmountsOut", args: [BigInt(10) ** BigInt(token.decimals), path] })]);
           }
         }
       }
       if (doStable && usdc && usdt && dexRouter) {
         cts.push({ kind: "stable", from: "USDC", to: "USDT", dec: usdt.decimals });
-        calls.push([dexRouter, encodeFunctionData26({ abi: UNIV2_ROUTER_ABI, functionName: "getAmountsOut", args: [BigInt(10) ** BigInt(usdc.decimals), [usdc.address, usdt.address]] })]);
+        calls.push([dexRouter, encodeFunctionData29({ abi: UNIV2_ROUTER_ABI, functionName: "getAmountsOut", args: [BigInt(10) ** BigInt(usdc.decimals), [usdc.address, usdt.address]] })]);
         cts.push({ kind: "stable", from: "USDT", to: "USDC", dec: usdc.decimals });
-        calls.push([dexRouter, encodeFunctionData26({ abi: UNIV2_ROUTER_ABI, functionName: "getAmountsOut", args: [BigInt(10) ** BigInt(usdt.decimals), [usdt.address, usdc.address]] })]);
+        calls.push([dexRouter, encodeFunctionData29({ abi: UNIV2_ROUTER_ABI, functionName: "getAmountsOut", args: [BigInt(10) ** BigInt(usdt.decimals), [usdt.address, usdc.address]] })]);
       }
       if (calls.length === 0) return null;
       const ct0 = Date.now();
@@ -7930,14 +9448,14 @@ function registerArb(parent, getOpts, makeExecutor2) {
 }
 
 // src/commands/positions.ts
-import { encodeFunctionData as encodeFunctionData27, parseAbi as parseAbi30 } from "viem";
-var ERC20_ABI6 = parseAbi30([
+import { encodeFunctionData as encodeFunctionData30, parseAbi as parseAbi34 } from "viem";
+var ERC20_ABI6 = parseAbi34([
   "function balanceOf(address owner) external view returns (uint256)"
 ]);
-var POOL_ABI5 = parseAbi30([
+var POOL_ABI5 = parseAbi34([
   "function getUserAccountData(address user) external view returns (uint256 totalCollateralBase, uint256 totalDebtBase, uint256 availableBorrowsBase, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor)"
 ]);
-var ORACLE_ABI6 = parseAbi30([
+var ORACLE_ABI6 = parseAbi34([
   "function getAssetPrice(address asset) external view returns (uint256)"
 ]);
 function round22(x) {
@@ -7966,7 +9484,7 @@ async function scanSingleChain(chainName, rpc, user, tokens, lendingPools, oracl
       callTypes.push({ kind: "token", symbol: token.symbol, decimals: token.decimals });
       calls.push([
         token.address,
-        encodeFunctionData27({ abi: ERC20_ABI6, functionName: "balanceOf", args: [user] })
+        encodeFunctionData30({ abi: ERC20_ABI6, functionName: "balanceOf", args: [user] })
       ]);
     }
   }
@@ -7974,14 +9492,14 @@ async function scanSingleChain(chainName, rpc, user, tokens, lendingPools, oracl
     callTypes.push({ kind: "lending", protocol: name, iface });
     calls.push([
       pool,
-      encodeFunctionData27({ abi: POOL_ABI5, functionName: "getUserAccountData", args: [user] })
+      encodeFunctionData30({ abi: POOL_ABI5, functionName: "getUserAccountData", args: [user] })
     ]);
   }
   if (oracleAddr) {
     callTypes.push({ kind: "native_price" });
     calls.push([
       oracleAddr,
-      encodeFunctionData27({ abi: ORACLE_ABI6, functionName: "getAssetPrice", args: [wrappedNative] })
+      encodeFunctionData30({ abi: ORACLE_ABI6, functionName: "getAssetPrice", args: [wrappedNative] })
     ]);
   }
   if (calls.length === 0) return null;
@@ -8274,14 +9792,14 @@ function registerPrice(parent, getOpts) {
 }
 
 // src/commands/wallet.ts
-import { createPublicClient as createPublicClient19, http as http19, formatEther } from "viem";
+import { createPublicClient as createPublicClient23, http as http23, formatEther } from "viem";
 function registerWallet(parent, getOpts) {
   const wallet = parent.command("wallet").description("Wallet management");
   wallet.command("balance").description("Show native token balance").requiredOption("--address <address>", "Wallet address to query").action(async (opts) => {
     const chainName = parent.opts().chain ?? "hyperevm";
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
-    const client = createPublicClient19({ transport: http19(chain.effectiveRpcUrl()) });
+    const client = createPublicClient23({ transport: http23(chain.effectiveRpcUrl()) });
     const balance = await client.getBalance({ address: opts.address });
     printOutput({
       chain: chain.name,
@@ -8298,14 +9816,14 @@ function registerWallet(parent, getOpts) {
 }
 
 // src/commands/token.ts
-import { createPublicClient as createPublicClient20, http as http20, maxUint256 } from "viem";
+import { createPublicClient as createPublicClient24, http as http24, maxUint256 } from "viem";
 function registerToken(parent, getOpts, makeExecutor2) {
   const token = parent.command("token").description("Token operations: approve, allowance, transfer, balance");
   token.command("balance").description("Query token balance for an address").requiredOption("--token <token>", "Token symbol or address").requiredOption("--owner <address>", "Wallet address to query").action(async (opts) => {
     const chainName = parent.opts().chain ?? "hyperevm";
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
-    const client = createPublicClient20({ transport: http20(chain.effectiveRpcUrl()) });
+    const client = createPublicClient24({ transport: http24(chain.effectiveRpcUrl()) });
     const tokenAddr = opts.token.startsWith("0x") ? opts.token : registry.resolveToken(chainName, opts.token).address;
     const [balance, symbol, decimals] = await Promise.all([
       client.readContract({ address: tokenAddr, abi: erc20Abi, functionName: "balanceOf", args: [opts.owner] }),
@@ -8334,7 +9852,7 @@ function registerToken(parent, getOpts, makeExecutor2) {
     const chainName = parent.opts().chain ?? "hyperevm";
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
-    const client = createPublicClient20({ transport: http20(chain.effectiveRpcUrl()) });
+    const client = createPublicClient24({ transport: http24(chain.effectiveRpcUrl()) });
     const tokenAddr = opts.token.startsWith("0x") ? opts.token : registry.resolveToken(chainName, opts.token).address;
     const allowance = await client.readContract({
       address: tokenAddr,
@@ -8356,8 +9874,8 @@ function registerToken(parent, getOpts, makeExecutor2) {
 }
 
 // src/commands/whales.ts
-import { encodeFunctionData as encodeFunctionData28, parseAbi as parseAbi31 } from "viem";
-var POOL_ABI6 = parseAbi31([
+import { encodeFunctionData as encodeFunctionData31, parseAbi as parseAbi35 } from "viem";
+var POOL_ABI6 = parseAbi35([
   "function getUserAccountData(address user) external view returns (uint256 totalCollateralBase, uint256 totalDebtBase, uint256 availableBorrowsBase, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor)"
 ]);
 function round24(x) {
@@ -8468,7 +9986,7 @@ function registerWhales(parent, getOpts) {
         for (const { pool } of lendingPools) {
           calls.push([
             pool,
-            encodeFunctionData28({ abi: POOL_ABI6, functionName: "getUserAccountData", args: [whale.address] })
+            encodeFunctionData31({ abi: POOL_ABI6, functionName: "getUserAccountData", args: [whale.address] })
           ]);
         }
       }
@@ -8896,11 +10414,11 @@ function registerBridge(parent, getOpts) {
         const amountUsdc = Number(BigInt(opts.amount)) / 1e6;
         const { fee, maxFeeSubunits } = await getCctpFeeEstimate(srcDomain, dstDomain, amountUsdc);
         const recipientPadded = `0x${"0".repeat(24)}${recipient.replace("0x", "").toLowerCase()}`;
-        const { encodeFunctionData: encodeFunctionData30, parseAbi: parseAbi34 } = await import("viem");
-        const tokenMessengerAbi = parseAbi34([
+        const { encodeFunctionData: encodeFunctionData34, parseAbi: parseAbi37 } = await import("viem");
+        const tokenMessengerAbi = parseAbi37([
           "function depositForBurn(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken, bytes32 destinationCaller, uint256 maxFee, uint32 minFinalityThreshold) external returns (uint64 nonce)"
         ]);
-        const data = encodeFunctionData30({
+        const data = encodeFunctionData34({
           abi: tokenMessengerAbi,
           functionName: "depositForBurn",
           args: [
@@ -9093,6 +10611,124 @@ function registerFarm(parent, getOpts, makeExecutor2) {
   });
 }
 
+// src/commands/farming.ts
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+function registerFarming(parent, getOpts, makeExecutor2) {
+  const farming = parent.command("farming").description("Algebra eternal farming operations (KittenSwap): enter, exit, collect rewards, claim, discover");
+  farming.command("enter").description("Enter farming: stake an NFT position to start earning rewards").requiredOption("--protocol <protocol>", "Protocol slug (e.g. kittenswap)").requiredOption("--pool <address>", "Pool address").requiredOption("--token-id <id>", "NFT position token ID").option("--owner <address>", "Owner address to receive claimed rewards (defaults to DEFI_WALLET_ADDRESS or private key address)").action(async (opts) => {
+    const executor = makeExecutor2();
+    const registry = Registry.loadEmbedded();
+    const protocol = registry.getProtocol(opts.protocol);
+    const chainName = parent.opts().chain;
+    const chain = registry.getChain(chainName ?? "hyperevm");
+    const rpcUrl = chain.effectiveRpcUrl();
+    const adapter = createKittenSwapFarming(protocol, rpcUrl);
+    const owner = resolveOwner(opts.owner);
+    const tx = await adapter.buildEnterFarming(
+      BigInt(opts.tokenId),
+      opts.pool,
+      owner
+    );
+    const result = await executor.execute(tx);
+    printOutput(result, getOpts());
+  });
+  farming.command("exit").description("Exit farming: unstake an NFT position").requiredOption("--protocol <protocol>", "Protocol slug (e.g. kittenswap)").requiredOption("--pool <address>", "Pool address").requiredOption("--token-id <id>", "NFT position token ID").action(async (opts) => {
+    const executor = makeExecutor2();
+    const registry = Registry.loadEmbedded();
+    const protocol = registry.getProtocol(opts.protocol);
+    const chainName = parent.opts().chain;
+    const chain = registry.getChain(chainName ?? "hyperevm");
+    const rpcUrl = chain.effectiveRpcUrl();
+    const adapter = createKittenSwapFarming(protocol, rpcUrl);
+    const tx = await adapter.buildExitFarming(
+      BigInt(opts.tokenId),
+      opts.pool
+    );
+    const result = await executor.execute(tx);
+    printOutput(result, getOpts());
+  });
+  farming.command("rewards").description("Collect + claim farming rewards for a staked position (collectRewards + claimReward multicall)").requiredOption("--protocol <protocol>", "Protocol slug (e.g. kittenswap)").requiredOption("--pool <address>", "Pool address").requiredOption("--token-id <id>", "NFT position token ID").option("--owner <address>", "Owner address to receive claimed rewards (defaults to DEFI_WALLET_ADDRESS or private key address)").action(async (opts) => {
+    const executor = makeExecutor2();
+    const registry = Registry.loadEmbedded();
+    const protocol = registry.getProtocol(opts.protocol);
+    const chainName = parent.opts().chain;
+    const chain = registry.getChain(chainName ?? "hyperevm");
+    const rpcUrl = chain.effectiveRpcUrl();
+    const adapter = createKittenSwapFarming(protocol, rpcUrl);
+    const owner = resolveOwner(opts.owner);
+    const tx = await adapter.buildCollectRewards(
+      BigInt(opts.tokenId),
+      opts.pool,
+      owner
+    );
+    const result = await executor.execute(tx);
+    printOutput(result, getOpts());
+  });
+  farming.command("claim").description("Claim accumulated farming rewards (KITTEN + WHYPE) without changing position").requiredOption("--protocol <protocol>", "Protocol slug (e.g. kittenswap)").option("--owner <address>", "Owner address to receive rewards (defaults to DEFI_WALLET_ADDRESS or private key address)").action(async (opts) => {
+    const executor = makeExecutor2();
+    const registry = Registry.loadEmbedded();
+    const protocol = registry.getProtocol(opts.protocol);
+    const chainName = parent.opts().chain;
+    const chain = registry.getChain(chainName ?? "hyperevm");
+    const rpcUrl = chain.effectiveRpcUrl();
+    const adapter = createKittenSwapFarming(protocol, rpcUrl);
+    const owner = resolveOwner(opts.owner);
+    const tx = await adapter.buildClaimReward(owner);
+    const result = await executor.execute(tx);
+    printOutput(result, getOpts());
+  });
+  farming.command("pending").description("Query pending farming rewards for a position (read-only)").requiredOption("--protocol <protocol>", "Protocol slug (e.g. kittenswap)").requiredOption("--pool <address>", "Pool address").requiredOption("--token-id <id>", "NFT position token ID").action(async (opts) => {
+    const registry = Registry.loadEmbedded();
+    const protocol = registry.getProtocol(opts.protocol);
+    const chainName = parent.opts().chain;
+    const chain = registry.getChain(chainName ?? "hyperevm");
+    const rpcUrl = chain.effectiveRpcUrl();
+    const adapter = createKittenSwapFarming(protocol, rpcUrl);
+    const rewards = await adapter.getPendingRewards(
+      BigInt(opts.tokenId),
+      opts.pool
+    );
+    printOutput(
+      {
+        tokenId: opts.tokenId,
+        pool: opts.pool,
+        reward_kitten: rewards.reward.toString(),
+        bonus_reward_whype: rewards.bonusReward.toString()
+      },
+      getOpts()
+    );
+  });
+  farming.command("discover").description("Discover all pools with active KittenSwap farming incentives").requiredOption("--protocol <protocol>", "Protocol slug (e.g. kittenswap)").action(async (opts) => {
+    const registry = Registry.loadEmbedded();
+    const protocol = registry.getProtocol(opts.protocol);
+    const chainName = parent.opts().chain;
+    const chain = registry.getChain(chainName ?? "hyperevm");
+    const rpcUrl = chain.effectiveRpcUrl();
+    const adapter = createKittenSwapFarming(protocol, rpcUrl);
+    const pools = await adapter.discoverFarmingPools();
+    const output = pools.map((p) => ({
+      pool: p.pool,
+      nonce: p.key.nonce.toString(),
+      total_reward: p.totalReward.toString(),
+      bonus_reward: p.bonusReward.toString(),
+      active: p.active
+    }));
+    printOutput(output, getOpts());
+  });
+}
+function resolveOwner(optOwner) {
+  if (optOwner) return optOwner;
+  const walletAddr = process.env["DEFI_WALLET_ADDRESS"];
+  if (walletAddr) return walletAddr;
+  const privateKey = process.env["DEFI_PRIVATE_KEY"];
+  if (privateKey) {
+    return privateKeyToAccount3(privateKey).address;
+  }
+  throw new Error(
+    "--owner, DEFI_WALLET_ADDRESS, or DEFI_PRIVATE_KEY is required to resolve reward recipient"
+  );
+}
+
 // src/commands/setup.ts
 import pc2 from "picocolors";
 import { createInterface } from "readline";
@@ -9141,8 +10777,8 @@ function isValidPrivateKey(s) {
 }
 async function deriveAddress(privateKey) {
   try {
-    const { privateKeyToAccount: privateKeyToAccount3 } = await import("viem/accounts");
-    const account = privateKeyToAccount3(privateKey);
+    const { privateKeyToAccount: privateKeyToAccount4 } = await import("viem/accounts");
+    const account = privateKeyToAccount4(privateKey);
     return account.address;
   } catch {
     return null;
@@ -9349,7 +10985,7 @@ var BANNER = `
   \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2551    \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551
   \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D
 
-  2 chains \xB7 30 protocols \xB7 by HypurrQuant
+  2 chains \xB7 23 protocols \xB7 by HypurrQuant
 
   Scan exploits, swap tokens, bridge assets, track whales,
   compare yields \u2014 all from your terminal.
@@ -9389,6 +11025,7 @@ registerSwap(program, getOutputMode, makeExecutor);
 registerBridge(program, getOutputMode);
 registerNft(program, getOutputMode);
 registerFarm(program, getOutputMode, makeExecutor);
+registerFarming(program, getOutputMode, makeExecutor);
 registerLB(program, getOutputMode, makeExecutor);
 registerSetup(program);
 program.command("agent").description("Agent mode: read JSON commands from stdin (for AI agents)").action(async () => {
@@ -9400,13 +11037,13 @@ program.command("agent").description("Agent mode: read JSON commands from stdin
 
 // src/landing.ts
 import pc3 from "picocolors";
-import { encodeFunctionData as encodeFunctionData29, parseAbi as parseAbi33, formatUnits } from "viem";
+import { encodeFunctionData as encodeFunctionData33, parseAbi as parseAbi36, formatUnits } from "viem";
 var HYPEREVM_DISPLAY = ["HYPE", "WHYPE", "USDC", "USDT0", "USDe", "kHYPE", "wstHYPE"];
 var MANTLE_DISPLAY = ["MNT", "WMNT", "USDC", "USDT", "WETH", "mETH"];
-var balanceOfAbi = parseAbi33([
+var balanceOfAbi = parseAbi36([
   "function balanceOf(address account) view returns (uint256)"
 ]);
-var getEthBalanceAbi = parseAbi33([
+var getEthBalanceAbi = parseAbi36([
   "function getEthBalance(address addr) view returns (uint256)"
 ]);
 async function fetchBalances(rpcUrl, wallet, tokens) {
@@ -9415,7 +11052,7 @@ async function fetchBalances(rpcUrl, wallet, tokens) {
     if (isNative) {
       return [
         MULTICALL3_ADDRESS,
-        encodeFunctionData29({
+        encodeFunctionData33({
           abi: getEthBalanceAbi,
           functionName: "getEthBalance",
           args: [wallet]
@@ -9424,7 +11061,7 @@ async function fetchBalances(rpcUrl, wallet, tokens) {
     }
     return [
       t.address,
-      encodeFunctionData29({
+      encodeFunctionData33({
         abi: balanceOfAbi,
         functionName: "balanceOf",
         args: [wallet]
@@ -9598,6 +11235,7 @@ async function main() {
       "bridge",
       "nft",
       "farm",
+      "farming",
       "lb",
       "agent",
       "setup",