@hypurrquant/defi-cli 0.3.3 → 0.3.5

package/dist/index.js

@@ -1208,7 +1208,7 @@ var Executor = class _Executor {
       const [maxFee, priorityFee] = await this.fetchEip1559Fees(rpcUrl);
       return {
         tx_hash: void 0,
-        status: "simulated",
+        status: TxStatus.Simulated,
         gas_used: gasEstimate > 0n ? Number(gasEstimate) : void 0,
         description: tx.description,
         details: {
@@ -1228,7 +1228,7 @@ var Executor = class _Executor {
       const revertReason = extractRevertReason(errMsg);
       return {
         tx_hash: void 0,
-        status: "simulation_failed",
+        status: TxStatus.SimulationFailed,
         gas_used: tx.gas_estimate,
         description: tx.description,
         details: {
@@ -1250,7 +1250,7 @@ var Executor = class _Executor {
       }
       return {
         tx_hash: void 0,
-        status: "dry_run",
+        status: TxStatus.DryRun,
         gas_used: tx.gas_estimate,
         description: tx.description,
         details: {
@@ -1335,7 +1335,7 @@ 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";
+    const status = receipt.status === "success" ? TxStatus.Confirmed : TxStatus.Failed;
     let mintedTokenId;
     if (receipt.status === "success" && receipt.logs) {
       const TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
@@ -1903,6 +1903,9 @@ function registerSchema(parent, getOpts) {
   });
 }
 
+// src/commands/lp.ts
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+
 // ../defi-protocols/dist/index.js
 import { encodeFunctionData as encodeFunctionData4, parseAbi as parseAbi4, createPublicClient as createPublicClient4, http as http4, decodeAbiParameters } from "viem";
 import { encodeFunctionData as encodeFunctionData22, parseAbi as parseAbi22, createPublicClient as createPublicClient22, http as http22, decodeFunctionResult as decodeFunctionResult2, decodeAbiParameters as decodeAbiParameters2 } from "viem";
@@ -4091,128 +4094,6 @@ var masterchefAbi = parseAbi11([
   "function getNumberOfFarms() view returns (uint256)",
   "function getPidByPool(address pool) view returns (uint256)"
 ]);
-var MasterChefAdapter = class {
-  protocolName;
-  masterchef;
-  rpcUrl;
-  constructor(entry, rpcUrl) {
-    this.protocolName = entry.name;
-    const masterchef = entry.contracts?.["masterchef"];
-    if (!masterchef) {
-      throw new DefiError("CONTRACT_ERROR", "Missing 'masterchef' contract");
-    }
-    this.masterchef = masterchef;
-    this.rpcUrl = rpcUrl;
-  }
-  name() {
-    return this.protocolName;
-  }
-  /**
-   * Deposit LP tokens into a MasterChef farm.
-   * `gauge` is the pool address (unused for calldata — MasterChef is the target).
-   * `tokenId` carries the farm pid.
-   */
-  async buildDeposit(gauge, amount, tokenId) {
-    const pid = tokenId ?? 0n;
-    const data = encodeFunctionData11({
-      abi: masterchefAbi,
-      functionName: "deposit",
-      args: [pid, amount]
-    });
-    return {
-      description: `[${this.protocolName}] Deposit ${amount} LP to farm pid=${pid} (pool ${gauge})`,
-      to: this.masterchef,
-      data,
-      value: 0n,
-      gas_estimate: 2e5
-    };
-  }
-  /**
-   * Withdraw LP tokens from a MasterChef farm.
-   * `gauge` is used to look up the pid description only; call site should pass pid via tokenId
-   * on the deposit flow. Here pid defaults to 0 — callers should encode the pid in the gauge
-   * address slot or wrap this adapter with a pid-aware helper.
-   */
-  async buildWithdraw(gauge, amount) {
-    const pid = 0n;
-    const data = encodeFunctionData11({
-      abi: masterchefAbi,
-      functionName: "withdraw",
-      args: [pid, amount]
-    });
-    return {
-      description: `[${this.protocolName}] Withdraw ${amount} LP from farm pid=${pid} (pool ${gauge})`,
-      to: this.masterchef,
-      data,
-      value: 0n,
-      gas_estimate: 2e5
-    };
-  }
-  /** Withdraw LP tokens specifying a pid explicitly (MasterChef extension beyond IGauge). */
-  async buildWithdrawPid(pid, amount) {
-    const data = encodeFunctionData11({
-      abi: masterchefAbi,
-      functionName: "withdraw",
-      args: [pid, amount]
-    });
-    return {
-      description: `[${this.protocolName}] Withdraw ${amount} LP from farm pid=${pid}`,
-      to: this.masterchef,
-      data,
-      value: 0n,
-      gas_estimate: 2e5
-    };
-  }
-  /** Claim pending MOE rewards. IGauge interface provides no pid — defaults to pid=0. */
-  async buildClaimRewards(gauge) {
-    const pid = 0n;
-    const data = encodeFunctionData11({
-      abi: masterchefAbi,
-      functionName: "claim",
-      args: [[pid]]
-    });
-    return {
-      description: `[${this.protocolName}] Claim MOE rewards for farm pid=${pid} (pool ${gauge})`,
-      to: this.masterchef,
-      data,
-      value: 0n,
-      gas_estimate: 2e5
-    };
-  }
-  /** Claim pending MOE rewards for a specific pid (MasterChef extension beyond IGauge). */
-  async buildClaimRewardsPid(pid) {
-    const data = encodeFunctionData11({
-      abi: masterchefAbi,
-      functionName: "claim",
-      args: [[pid]]
-    });
-    return {
-      description: `[${this.protocolName}] Claim MOE rewards for farm pid=${pid}`,
-      to: this.masterchef,
-      data,
-      value: 0n,
-      gas_estimate: 2e5
-    };
-  }
-  /** Get pending MOE rewards for a user. Requires rpcUrl. */
-  async getPendingRewards(_gauge, user) {
-    if (!this.rpcUrl) {
-      throw DefiError.unsupported(`[${this.protocolName}] getPendingRewards requires RPC`);
-    }
-    const client = createPublicClient7({ transport: http7(this.rpcUrl) });
-    const rewards = await client.readContract({
-      address: this.masterchef,
-      abi: masterchefAbi,
-      functionName: "pendingRewards",
-      args: [user, [0n]]
-    });
-    return rewards.map((amount) => ({
-      token: this.masterchef,
-      symbol: "MOE",
-      amount
-    }));
-  }
-};
 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)",
@@ -6834,46 +6715,6 @@ var GENERIC_LST_ABI = parseAbi24([
   "function stake() external payable returns (uint256)",
   "function unstake(uint256 amount) external returns (uint256)"
 ]);
-var GenericLstAdapter = class {
-  protocolName;
-  staking;
-  constructor(entry, _rpcUrl) {
-    this.protocolName = entry.name;
-    const staking = entry.contracts?.["staking"];
-    if (!staking) throw DefiError.contractError("Missing 'staking' contract");
-    this.staking = staking;
-  }
-  name() {
-    return this.protocolName;
-  }
-  async buildStake(params) {
-    const data = encodeFunctionData222({ abi: GENERIC_LST_ABI, functionName: "stake" });
-    return {
-      description: `[${this.protocolName}] Stake ${params.amount} HYPE`,
-      to: this.staking,
-      data,
-      value: params.amount,
-      gas_estimate: 2e5
-    };
-  }
-  async buildUnstake(params) {
-    const data = encodeFunctionData222({
-      abi: GENERIC_LST_ABI,
-      functionName: "unstake",
-      args: [params.amount]
-    });
-    return {
-      description: `[${this.protocolName}] Unstake ${params.amount}`,
-      to: this.staking,
-      data,
-      value: 0n,
-      gas_estimate: 2e5
-    };
-  }
-  async getInfo() {
-    throw DefiError.unsupported(`[${this.protocolName}] getInfo requires RPC`);
-  }
-};
 var STHYPE_ABI = parseAbi25([
   "function submit(address referral) external payable returns (uint256)",
   "function requestWithdrawals(uint256[] amounts, address owner) external returns (uint256[] requestIds)"
@@ -6881,70 +6722,6 @@ var STHYPE_ABI = parseAbi25([
 var ERC20_ABI3 = parseAbi25([
   "function totalSupply() external view returns (uint256)"
 ]);
-var StHypeAdapter = class {
-  protocolName;
-  staking;
-  sthypeToken;
-  rpcUrl;
-  constructor(entry, rpcUrl) {
-    this.protocolName = entry.name;
-    this.rpcUrl = rpcUrl;
-    const staking = entry.contracts?.["staking"];
-    if (!staking) throw DefiError.contractError("Missing 'staking' contract");
-    this.staking = staking;
-    this.sthypeToken = entry.contracts?.["sthype_token"];
-  }
-  name() {
-    return this.protocolName;
-  }
-  async buildStake(params) {
-    const data = encodeFunctionData23({
-      abi: STHYPE_ABI,
-      functionName: "submit",
-      args: [zeroAddress12]
-    });
-    return {
-      description: `[${this.protocolName}] Stake ${params.amount} HYPE for stHYPE`,
-      to: this.staking,
-      data,
-      value: params.amount,
-      gas_estimate: 2e5
-    };
-  }
-  async buildUnstake(params) {
-    const data = encodeFunctionData23({
-      abi: STHYPE_ABI,
-      functionName: "requestWithdrawals",
-      args: [[params.amount], params.recipient]
-    });
-    return {
-      description: `[${this.protocolName}] Request unstake ${params.amount} stHYPE`,
-      to: this.staking,
-      data,
-      value: 0n,
-      gas_estimate: 2e5
-    };
-  }
-  async getInfo() {
-    if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-    const client = createPublicClient19({ transport: http19(this.rpcUrl) });
-    const tokenAddr = this.sthypeToken ?? this.staking;
-    const totalSupply = await client.readContract({
-      address: tokenAddr,
-      abi: ERC20_ABI3,
-      functionName: "totalSupply"
-    }).catch((e) => {
-      throw DefiError.rpcError(`[${this.protocolName}] totalSupply failed: ${e}`);
-    });
-    return {
-      protocol: this.protocolName,
-      staked_token: zeroAddress12,
-      liquid_token: tokenAddr,
-      exchange_rate: 1,
-      total_staked: totalSupply
-    };
-  }
-};
 var KINETIQ_ABI = parseAbi26([
   "function stake() external payable returns (uint256)",
   "function requestUnstake(uint256 amount) external returns (uint256)",
@@ -6953,72 +6730,6 @@ var KINETIQ_ABI = parseAbi26([
 var ORACLE_ABI3 = parseAbi26([
   "function getAssetPrice(address asset) external view returns (uint256)"
 ]);
-var WHYPE = "0x5555555555555555555555555555555555555555";
-var HYPERLEND_ORACLE = "0xc9fb4fbe842d57ea1df3e641a281827493a63030";
-var KinetiqAdapter = class {
-  protocolName;
-  staking;
-  liquidToken;
-  rpcUrl;
-  constructor(entry, rpcUrl) {
-    this.protocolName = entry.name;
-    this.rpcUrl = rpcUrl;
-    const staking = entry.contracts?.["staking"];
-    if (!staking) throw DefiError.contractError("Missing 'staking' contract address");
-    this.staking = staking;
-    this.liquidToken = entry.contracts?.["khype_token"] ?? staking;
-  }
-  name() {
-    return this.protocolName;
-  }
-  async buildStake(params) {
-    const data = encodeFunctionData24({ abi: KINETIQ_ABI, functionName: "stake" });
-    return {
-      description: `[${this.protocolName}] Stake ${params.amount} HYPE for kHYPE`,
-      to: this.staking,
-      data,
-      value: params.amount,
-      gas_estimate: 3e5
-    };
-  }
-  async buildUnstake(params) {
-    const data = encodeFunctionData24({
-      abi: KINETIQ_ABI,
-      functionName: "requestUnstake",
-      args: [params.amount]
-    });
-    return {
-      description: `[${this.protocolName}] Request unstake ${params.amount} kHYPE`,
-      to: this.staking,
-      data,
-      value: 0n,
-      gas_estimate: 3e5
-    };
-  }
-  async getInfo() {
-    if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-    const client = createPublicClient20({ transport: http20(this.rpcUrl) });
-    const totalStaked = await client.readContract({
-      address: this.staking,
-      abi: KINETIQ_ABI,
-      functionName: "totalStaked"
-    }).catch((e) => {
-      throw DefiError.rpcError(`[${this.protocolName}] totalStaked failed: ${e}`);
-    });
-    const [khypePrice, hypePrice] = await Promise.all([
-      client.readContract({ address: HYPERLEND_ORACLE, abi: ORACLE_ABI3, functionName: "getAssetPrice", args: [this.liquidToken] }).catch(() => 0n),
-      client.readContract({ address: HYPERLEND_ORACLE, abi: ORACLE_ABI3, functionName: "getAssetPrice", args: [WHYPE] }).catch(() => 0n)
-    ]);
-    const rateF64 = hypePrice > 0n && khypePrice > 0n ? Number(khypePrice * 10n ** 18n / hypePrice) / 1e18 : 1;
-    return {
-      protocol: this.protocolName,
-      staked_token: zeroAddress13,
-      liquid_token: this.liquidToken,
-      exchange_rate: rateF64,
-      total_staked: totalStaked
-    };
-  }
-};
 var HLP_ABI = parseAbi27([
   "function deposit(uint256 amount) external returns (uint256)",
   "function withdraw(uint256 shares) external returns (uint256)"
@@ -7035,59 +6746,6 @@ var ERC721_ABI = parseAbi29([
   "function balanceOf(address owner) returns (uint256)",
   "function tokenURI(uint256 tokenId) returns (string)"
 ]);
-var ERC721Adapter = class {
-  protocolName;
-  rpcUrl;
-  constructor(entry, rpcUrl) {
-    this.protocolName = entry.name;
-    this.rpcUrl = rpcUrl;
-  }
-  name() {
-    return this.protocolName;
-  }
-  async getCollectionInfo(collection) {
-    if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-    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}`);
-      }),
-      client.readContract({ address: collection, abi: ERC721_ABI, functionName: "symbol" }).catch((e) => {
-        throw DefiError.rpcError(`[${this.protocolName}] symbol failed: ${e}`);
-      }),
-      client.readContract({ address: collection, abi: ERC721_ABI, functionName: "totalSupply" }).catch(() => void 0)
-    ]);
-    return {
-      address: collection,
-      name: collectionName,
-      symbol,
-      total_supply: totalSupply
-    };
-  }
-  async getTokenInfo(collection, tokenId) {
-    if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-    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}`);
-      }),
-      client.readContract({ address: collection, abi: ERC721_ABI, functionName: "tokenURI", args: [tokenId] }).catch(() => void 0)
-    ]);
-    return {
-      collection,
-      token_id: tokenId,
-      owner,
-      token_uri: tokenUri
-    };
-  }
-  async getBalance(owner, collection) {
-    if (!this.rpcUrl) throw DefiError.rpcError("No RPC URL configured");
-    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}`);
-    });
-  }
-};
 function createDex(entry, rpcUrl) {
   switch (entry.interface) {
     case "uniswap_v3":
@@ -7151,19 +6809,6 @@ function createVault(entry, rpcUrl) {
       throw DefiError.unsupported(`Vault interface '${entry.interface}' not yet implemented`);
   }
 }
-function createLiquidStaking(entry, rpcUrl) {
-  switch (entry.interface) {
-    case "kinetiq_staking":
-      return new KinetiqAdapter(entry, rpcUrl);
-    case "sthype_staking":
-      return new StHypeAdapter(entry, rpcUrl);
-    case "hyperbeat_lst":
-    case "kintsu":
-      return new GenericLstAdapter(entry, rpcUrl);
-    default:
-      return new GenericLstAdapter(entry, rpcUrl);
-  }
-}
 function createGauge(entry, rpcUrl) {
   if (entry.interface === "hybra" || entry.contracts?.["gauge_manager"]) {
     return new HybraGaugeAdapter(entry, rpcUrl);
@@ -7177,19 +6822,6 @@ function createGauge(entry, rpcUrl) {
       throw DefiError.unsupported(`Gauge interface '${entry.interface}' not supported`);
   }
 }
-function createMasterChef(entry, rpcUrl) {
-  return new MasterChefAdapter(entry, rpcUrl);
-}
-function createNft(entry, rpcUrl) {
-  switch (entry.interface) {
-    case "erc721":
-      return new ERC721Adapter(entry, rpcUrl);
-    case "marketplace":
-      throw DefiError.unsupported(`NFT marketplace '${entry.name}' is not queryable as ERC-721. Use a specific collection address.`);
-    default:
-      throw DefiError.unsupported(`NFT interface '${entry.interface}' not supported`);
-  }
-}
 function createOracleFromLending(entry, rpcUrl) {
   switch (entry.interface) {
     case "aave_v3":
@@ -7263,61 +6895,131 @@ var DexSpotPrice = class {
   }
 };
 
-// src/commands/dex.ts
-function registerDex(parent, getOpts, makeExecutor2) {
-  const dex = parent.command("dex").description("DEX operations: swap, quote, compare");
-  dex.command("quote").description("Get a swap quote without executing").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-in <token>", "Input token symbol or address").requiredOption("--token-out <token>", "Output token symbol or address").requiredOption("--amount <amount>", "Amount of input token in wei").action(async (opts) => {
+// src/commands/lp.ts
+function resolveAccount(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 privateKeyToAccount2(privateKey).address;
+  throw new Error("--address, DEFI_WALLET_ADDRESS, or DEFI_PRIVATE_KEY is required");
+}
+function resolvePoolAddress(registry, protocolSlug, pool) {
+  if (pool.startsWith("0x")) return pool;
+  return registry.resolvePool(protocolSlug, pool).address;
+}
+function registerLP(parent, getOpts, makeExecutor2) {
+  const lp = parent.command("lp").description("Unified LP operations: discover, add, farm, claim, remove, positions");
+  lp.command("discover").description("Scan all protocols for fee + emission pools (gauges, farming, LB rewards)").option("--protocol <protocol>", "Filter to a single protocol slug").option("--emission-only", "Only show emission (gauge/farming) pools, skip fee-only").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 = createDex(protocol, chain.effectiveRpcUrl());
-    const tokenIn = opts.tokenIn.startsWith("0x") ? opts.tokenIn : registry.resolveToken(chainName, opts.tokenIn).address;
-    const tokenOut = opts.tokenOut.startsWith("0x") ? opts.tokenOut : registry.resolveToken(chainName, opts.tokenOut).address;
-    const result = await adapter.quote({ protocol: protocol.name, token_in: tokenIn, token_out: tokenOut, amount_in: BigInt(opts.amount) });
-    printOutput(result, getOpts());
+    const rpcUrl = chain.effectiveRpcUrl();
+    const allProtocols = registry.getProtocolsForChain(chainName);
+    const protocols = opts.protocol ? [registry.getProtocol(opts.protocol)] : allProtocols;
+    const results = [];
+    await Promise.allSettled(
+      protocols.map(async (protocol) => {
+        try {
+          if (["solidly_v2", "solidly_cl", "algebra_v3", "hybra"].includes(protocol.interface)) {
+            const adapter = createGauge(protocol, rpcUrl);
+            if (adapter.discoverGaugedPools) {
+              const pools = await adapter.discoverGaugedPools();
+              for (const p of pools) {
+                results.push({
+                  protocol: protocol.slug,
+                  pool: p.pool,
+                  pair: `${p.token0}/${p.token1}`,
+                  type: "EMISSION",
+                  source: "gauge"
+                });
+              }
+            }
+          }
+          if (protocol.interface === "algebra_v3" && protocol.contracts?.["farming_center"]) {
+            const adapter = createKittenSwapFarming(protocol, rpcUrl);
+            const pools = await adapter.discoverFarmingPools();
+            for (const p of pools) {
+              results.push({
+                protocol: protocol.slug,
+                pool: p.pool,
+                type: "EMISSION",
+                source: "farming",
+                total_reward: p.totalReward.toString(),
+                bonus_reward: p.bonusReward.toString(),
+                active: p.active
+              });
+            }
+          }
+          if (protocol.interface === "uniswap_v2" && protocol.contracts?.["lb_factory"]) {
+            const adapter = createMerchantMoeLB(protocol, rpcUrl);
+            const pools = await adapter.discoverRewardedPools();
+            for (const p of pools) {
+              if (!opts.emissionOnly || !p.stopped) {
+                results.push({
+                  protocol: protocol.slug,
+                  pool: p.pool,
+                  pair: `${p.symbolX}/${p.symbolY}`,
+                  type: "EMISSION",
+                  source: "lb_hooks",
+                  stopped: p.stopped,
+                  moePerDay: p.moePerDay,
+                  aprPercent: p.aprPercent,
+                  rangeTvlUsd: p.rangeTvlUsd,
+                  isTopPool: p.isTopPool
+                });
+              }
+            }
+          }
+        } catch {
+        }
+      })
+    );
+    if (opts.emissionOnly) {
+      printOutput(results.filter((r) => r.type === "EMISSION"), getOpts());
+    } else {
+      printOutput(results, getOpts());
+    }
   });
-  dex.command("swap").description("Execute a token swap").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-in <token>", "Input token").requiredOption("--token-out <token>", "Output token").requiredOption("--amount <amount>", "Amount in wei").option("--slippage <bps>", "Slippage tolerance in bps", "50").option("--recipient <address>", "Recipient address").action(async (opts) => {
+  lp.command("add").description("Add liquidity to a pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--amount-a <amount>", "Amount of token A in wei").requiredOption("--amount-b <amount>", "Amount of token B in wei").option("--pool <name_or_address>", "Pool name (e.g. WHYPE/USDC) or address").option("--recipient <address>", "Recipient address").option("--tick-lower <tick>", "Lower tick for concentrated LP (default: full range)").option("--tick-upper <tick>", "Upper tick for concentrated LP (default: full range)").option("--range <percent>", "\xB1N% concentrated range around current price (e.g. --range 2)").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 = createDex(protocol, chain.effectiveRpcUrl());
-    const tokenIn = opts.tokenIn.startsWith("0x") ? opts.tokenIn : registry.resolveToken(chainName, opts.tokenIn).address;
-    const tokenOut = opts.tokenOut.startsWith("0x") ? opts.tokenOut : registry.resolveToken(chainName, opts.tokenOut).address;
-    const recipient = opts.recipient ?? process.env.DEFI_WALLET_ADDRESS ?? "0x0000000000000000000000000000000000000001";
-    const tx = await adapter.buildSwap({
+    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";
+    const poolAddr = opts.pool ? resolvePoolAddress(registry, opts.protocol, opts.pool) : void 0;
+    const tx = await adapter.buildAddLiquidity({
       protocol: protocol.name,
-      token_in: tokenIn,
-      token_out: tokenOut,
-      amount_in: BigInt(opts.amount),
-      slippage: { bps: parseInt(opts.slippage) },
-      recipient
+      token_a: tokenA,
+      token_b: tokenB,
+      amount_a: BigInt(opts.amountA),
+      amount_b: BigInt(opts.amountB),
+      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());
   });
-  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) => {
+  lp.command("farm").description("Add liquidity and auto-stake into gauge/farming for emissions").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--amount-a <amount>", "Amount of token A in wei").requiredOption("--amount-b <amount>", "Amount of token B in wei").option("--pool <name_or_address>", "Pool name (e.g. WHYPE/USDC) or address").option("--gauge <address>", "Gauge address (required for solidly/hybra if not resolved automatically)").option("--recipient <address>", "Recipient / owner address").option("--tick-lower <tick>", "Lower tick for concentrated LP").option("--tick-upper <tick>", "Upper tick for concentrated LP").option("--range <percent>", "\xB1N% concentrated range around current price").action(async (opts) => {
     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 = createDex(protocol, chain.effectiveRpcUrl());
+    const rpcUrl = chain.effectiveRpcUrl();
+    const recipient = opts.recipient ?? process.env["DEFI_WALLET_ADDRESS"] ?? "0x0000000000000000000000000000000000000001";
+    const poolAddr = opts.pool ? resolvePoolAddress(registry, opts.protocol, opts.pool) : void 0;
     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({
+    const dexAdapter = createDex(protocol, rpcUrl);
+    const addTx = await dexAdapter.buildAddLiquidity({
       protocol: protocol.name,
       token_a: tokenA,
       token_b: tokenB,
@@ -7329,143 +7031,202 @@ function registerDex(parent, getOpts, makeExecutor2) {
       range_pct: opts.range !== void 0 ? parseFloat(opts.range) : void 0,
       pool: poolAddr
     });
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
+    process.stderr.write("Step 1/2: Adding liquidity...\n");
+    const addResult = await executor.execute(addTx);
+    printOutput({ step: "lp_add", ...addResult }, getOpts());
+    if (addResult.status !== "confirmed" && addResult.status !== "simulated") {
+      process.stderr.write("Step 2/2: Skipped \u2014 LP add did not succeed.\n");
+      return;
+    }
+    const mintedTokenId = addResult.details?.minted_token_id ? BigInt(addResult.details.minted_token_id) : void 0;
+    const iface = protocol.interface;
+    if (iface === "algebra_v3" && protocol.contracts?.["farming_center"]) {
+      if (!mintedTokenId) {
+        process.stderr.write("Step 2/2: Skipped staking (no tokenId \u2014 run in --broadcast mode to get minted NFT)\n");
+        return;
+      }
+      if (!poolAddr) throw new Error("--pool is required for lp farm with KittenSwap (needed for farming center)");
+      process.stderr.write("Step 2/2: Staking into KittenSwap eternal farming...\n");
+      const farmAdapter = createKittenSwapFarming(protocol, rpcUrl);
+      const stakeTx = await farmAdapter.buildEnterFarming(mintedTokenId, poolAddr, recipient);
+      const stakeResult = await executor.execute(stakeTx);
+      printOutput({ step: "stake_farming", ...stakeResult }, getOpts());
+      return;
+    }
+    if (["solidly_v2", "solidly_cl", "hybra"].includes(iface)) {
+      if (!mintedTokenId && iface !== "solidly_v2") {
+        process.stderr.write("Step 2/2: Skipped staking (no tokenId \u2014 run in --broadcast mode to get minted NFT)\n");
+        return;
+      }
+      let gaugeAddr = opts.gauge;
+      if (!gaugeAddr && poolAddr) {
+        try {
+          const gaugeAdapter2 = createGauge(protocol, rpcUrl);
+          if (gaugeAdapter2.resolveGauge) {
+            gaugeAddr = await gaugeAdapter2.resolveGauge(poolAddr);
+          }
+        } catch {
+        }
+      }
+      if (!gaugeAddr) throw new Error("--gauge <address> is required for staking (could not auto-resolve gauge)");
+      process.stderr.write("Step 2/2: Staking into gauge...\n");
+      const gaugeAdapter = createGauge(protocol, rpcUrl);
+      const tokenIdArg = mintedTokenId;
+      const amountArg = iface === "solidly_v2" ? BigInt("115792089237316195423570985008687907853269984665640564039457584007913129639935") : 0n;
+      const lpTokenArg = iface === "solidly_v2" ? poolAddr : void 0;
+      const stakeTx = await gaugeAdapter.buildDeposit(gaugeAddr, amountArg, tokenIdArg, lpTokenArg);
+      const stakeResult = await executor.execute(stakeTx);
+      printOutput({ step: "stake_gauge", ...stakeResult }, getOpts());
+      return;
+    }
+    if (iface === "uniswap_v2" && protocol.contracts?.["lb_factory"]) {
+      process.stderr.write("Step 2/2: Merchant Moe LB hooks handle rewards automatically \u2014 no staking needed.\n");
+      return;
+    }
+    process.stderr.write("Step 2/2: No staking adapter found for this protocol interface \u2014 liquidity added only.\n");
   });
-  dex.command("lp-remove").description("Remove liquidity from a pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--liquidity <amount>", "Liquidity amount to remove in wei").option("--recipient <address>", "Recipient address").action(async (opts) => {
+  lp.command("claim").description("Claim rewards from a pool (fee or emission)").requiredOption("--protocol <protocol>", "Protocol slug").option("--pool <address>", "Pool address (required for farming/LB)").option("--gauge <address>", "Gauge contract address (required for solidly/hybra)").option("--token-id <id>", "NFT tokenId (for CL gauge or farming positions)").option("--bins <binIds>", "Comma-separated bin IDs (for Merchant Moe LB)").option("--address <address>", "Wallet address (defaults to DEFI_WALLET_ADDRESS)").action(async (opts) => {
     const executor = makeExecutor2();
     const chainName = parent.opts().chain ?? "hyperevm";
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
+    const rpcUrl = chain.effectiveRpcUrl();
     const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createDex(protocol, chain.effectiveRpcUrl());
+    const account = resolveAccount(opts.address);
+    const iface = protocol.interface;
+    if (iface === "algebra_v3" && protocol.contracts?.["farming_center"]) {
+      if (!opts.pool) throw new Error("--pool is required for KittenSwap farming claim");
+      if (!opts.tokenId) throw new Error("--token-id is required for KittenSwap farming claim");
+      const adapter = createKittenSwapFarming(protocol, rpcUrl);
+      const tx = await adapter.buildCollectRewards(
+        BigInt(opts.tokenId),
+        opts.pool,
+        account
+      );
+      const result = await executor.execute(tx);
+      printOutput(result, getOpts());
+      return;
+    }
+    if (iface === "uniswap_v2" && protocol.contracts?.["lb_factory"]) {
+      if (!opts.pool) throw new Error("--pool is required for Merchant Moe LB claim");
+      const adapter = createMerchantMoeLB(protocol, rpcUrl);
+      const binIds = opts.bins ? opts.bins.split(",").map((s) => parseInt(s.trim())) : void 0;
+      const tx = await adapter.buildClaimRewards(account, opts.pool, binIds);
+      const result = await executor.execute(tx);
+      printOutput(result, getOpts());
+      return;
+    }
+    if (["solidly_v2", "solidly_cl", "algebra_v3", "hybra"].includes(iface)) {
+      if (!opts.gauge) throw new Error("--gauge is required for gauge claim");
+      const adapter = createGauge(protocol, rpcUrl);
+      let tx;
+      if (opts.tokenId) {
+        if (!adapter.buildClaimRewardsByTokenId) throw new Error(`${protocol.name} does not support NFT-based claim`);
+        tx = await adapter.buildClaimRewardsByTokenId(opts.gauge, BigInt(opts.tokenId));
+      } else {
+        tx = await adapter.buildClaimRewards(opts.gauge, account);
+      }
+      const result = await executor.execute(tx);
+      printOutput(result, getOpts());
+      return;
+    }
+    throw new Error(`No claim method found for protocol interface '${iface}'`);
+  });
+  lp.command("remove").description("Auto-unstake (if staked) and remove liquidity from a pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-a <token>", "First token symbol or address").requiredOption("--token-b <token>", "Second token symbol or address").requiredOption("--liquidity <amount>", "Liquidity amount to remove in wei").option("--pool <address>", "Pool address (needed to resolve gauge)").option("--gauge <address>", "Gauge contract address (for solidly/hybra unstake)").option("--token-id <id>", "NFT tokenId (for CL gauge or farming positions)").option("--recipient <address>", "Recipient address").action(async (opts) => {
+    const executor = makeExecutor2();
+    const chainName = parent.opts().chain ?? "hyperevm";
+    const registry = Registry.loadEmbedded();
+    const chain = registry.getChain(chainName);
+    const rpcUrl = chain.effectiveRpcUrl();
+    const protocol = registry.getProtocol(opts.protocol);
+    const iface = protocol.interface;
+    const recipient = opts.recipient ?? process.env["DEFI_WALLET_ADDRESS"] ?? "0x0000000000000000000000000000000000000001";
     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";
-    const tx = await adapter.buildRemoveLiquidity({
+    const poolAddr = opts.pool ? opts.pool : void 0;
+    let didUnstake = false;
+    if (iface === "algebra_v3" && protocol.contracts?.["farming_center"] && opts.tokenId && poolAddr) {
+      process.stderr.write("Step 1/2: Exiting KittenSwap farming...\n");
+      const farmAdapter = createKittenSwapFarming(protocol, rpcUrl);
+      const exitTx = await farmAdapter.buildExitFarming(BigInt(opts.tokenId), poolAddr);
+      const exitResult = await executor.execute(exitTx);
+      printOutput({ step: "unstake_farming", ...exitResult }, getOpts());
+      if (exitResult.status !== "confirmed" && exitResult.status !== "simulated") {
+        process.stderr.write("Step 2/2: Skipped \u2014 unstake did not succeed.\n");
+        return;
+      }
+      didUnstake = true;
+    } else if (["solidly_v2", "solidly_cl", "hybra"].includes(iface)) {
+      let gaugeAddr = opts.gauge;
+      if (!gaugeAddr && poolAddr) {
+        try {
+          const gaugeAdapter = createGauge(protocol, rpcUrl);
+          if (gaugeAdapter.resolveGauge) {
+            gaugeAddr = await gaugeAdapter.resolveGauge(poolAddr);
+          }
+        } catch {
+        }
+      }
+      if (gaugeAddr) {
+        process.stderr.write("Step 1/2: Withdrawing from gauge...\n");
+        const gaugeAdapter = createGauge(protocol, rpcUrl);
+        const tokenId = opts.tokenId ? BigInt(opts.tokenId) : void 0;
+        const withdrawTx = await gaugeAdapter.buildWithdraw(gaugeAddr, BigInt(opts.liquidity), tokenId);
+        const withdrawResult = await executor.execute(withdrawTx);
+        printOutput({ step: "unstake_gauge", ...withdrawResult }, getOpts());
+        if (withdrawResult.status !== "confirmed" && withdrawResult.status !== "simulated") {
+          process.stderr.write("Step 2/2: Skipped \u2014 unstake did not succeed.\n");
+          return;
+        }
+        didUnstake = true;
+      }
+    }
+    if (!didUnstake) {
+      process.stderr.write("Step 1/2: No staking detected \u2014 skipping unstake.\n");
+    }
+    process.stderr.write("Step 2/2: Removing liquidity...\n");
+    const dexAdapter = createDex(protocol, rpcUrl);
+    const removeTx = await dexAdapter.buildRemoveLiquidity({
       protocol: protocol.name,
       token_a: tokenA,
       token_b: tokenB,
       liquidity: BigInt(opts.liquidity),
       recipient
     });
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
+    const removeResult = await executor.execute(removeTx);
+    printOutput({ step: "lp_remove", ...removeResult }, getOpts());
   });
-  dex.command("compare").description("Compare quotes across DEXes").requiredOption("--token-in <token>", "Input token").requiredOption("--token-out <token>", "Output token").requiredOption("--amount <amount>", "Amount in wei").action(async (opts) => {
+  lp.command("positions").description("Show all LP positions across protocols").option("--protocol <protocol>", "Filter to a single protocol slug").option("--pool <address>", "Filter to a specific pool address").option("--bins <binIds>", "Comma-separated bin IDs (for Merchant Moe LB, auto-detected if omitted)").option("--address <address>", "Wallet address (defaults to DEFI_WALLET_ADDRESS)").action(async (opts) => {
     const chainName = parent.opts().chain ?? "hyperevm";
     const registry = Registry.loadEmbedded();
     const chain = registry.getChain(chainName);
-    const tokenIn = opts.tokenIn.startsWith("0x") ? opts.tokenIn : registry.resolveToken(chainName, opts.tokenIn).address;
-    const tokenOut = opts.tokenOut.startsWith("0x") ? opts.tokenOut : registry.resolveToken(chainName, opts.tokenOut).address;
-    const dexProtocols = registry.getProtocolsByCategory("dex").filter((p) => p.chain === chainName);
+    const rpcUrl = chain.effectiveRpcUrl();
+    const user = resolveAccount(opts.address);
+    const allProtocols = registry.getProtocolsForChain(chainName);
+    const protocols = opts.protocol ? [registry.getProtocol(opts.protocol)] : allProtocols;
     const results = [];
-    await Promise.all(dexProtocols.map(async (p) => {
-      try {
-        const adapter = createDex(p, chain.effectiveRpcUrl());
-        const q = await adapter.quote({ protocol: p.name, token_in: tokenIn, token_out: tokenOut, amount_in: BigInt(opts.amount) });
-        results.push({ protocol: p.name, amount_out: q.amount_out });
-      } catch (e) {
-        results.push({ protocol: p.name, amount_out: 0n, error: e instanceof Error ? e.message : String(e) });
-      }
-    }));
-    results.sort((a, b) => b.amount_out > a.amount_out ? 1 : -1);
-    printOutput({ chain: chainName, quotes: results }, getOpts());
-  });
-}
-
-// 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: 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, 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("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, 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("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, 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("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, 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("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, 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());
-    }
+    await Promise.allSettled(
+      protocols.map(async (protocol) => {
+        try {
+          if (protocol.interface === "uniswap_v2" && protocol.contracts?.["lb_factory"]) {
+            if (!opts.pool) return;
+            const adapter = createMerchantMoeLB(protocol, rpcUrl);
+            const binIds = opts.bins ? opts.bins.split(",").map((s) => parseInt(s.trim())) : void 0;
+            const positions = await adapter.getUserPositions(user, opts.pool, binIds);
+            for (const pos of positions) {
+              results.push({
+                protocol: protocol.slug,
+                type: "lb",
+                pool: opts.pool,
+                ...pos
+              });
+            }
+          }
+        } catch {
+        }
+      })
+    );
+    printOutput(results, getOpts());
   });
 }
 
@@ -7627,44 +7388,6 @@ function registerCdp(parent, getOpts, makeExecutor2) {
   });
 }
 
-// src/commands/staking.ts
-function registerStaking(parent, getOpts, makeExecutor2) {
-  const staking = parent.command("staking").description("Liquid staking: stake, unstake, info");
-  staking.command("stake").description("Stake tokens via liquid staking").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--amount <amount>", "Amount in wei").option("--recipient <address>", "Recipient address").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 = createLiquidStaking(protocol, chain.effectiveRpcUrl());
-    const recipient = opts.recipient ?? process.env.DEFI_WALLET_ADDRESS ?? "0x0000000000000000000000000000000000000001";
-    const tx = await adapter.buildStake({ protocol: protocol.name, amount: BigInt(opts.amount), recipient });
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-  staking.command("unstake").description("Unstake tokens").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--amount <amount>", "Amount in wei").option("--recipient <address>", "Recipient address").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 = createLiquidStaking(protocol, chain.effectiveRpcUrl());
-    const recipient = opts.recipient ?? process.env.DEFI_WALLET_ADDRESS ?? "0x0000000000000000000000000000000000000001";
-    const tx = await adapter.buildUnstake({ protocol: protocol.name, amount: BigInt(opts.amount), recipient });
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-  staking.command("info").description("Show staking info and rates").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 = createLiquidStaking(protocol, chain.effectiveRpcUrl());
-    const info = await adapter.getInfo();
-    printOutput(info, getOpts());
-  });
-}
-
 // src/commands/vault.ts
 function registerVault(parent, getOpts, makeExecutor2) {
   const vault = parent.command("vault").description("Vault operations: deposit, withdraw, info");
@@ -9408,53 +9131,6 @@ async function runAllChains(registry, patterns, oracleThreshold, stableThreshold
   };
 }
 
-// src/commands/arb.ts
-function registerArb(parent, getOpts, makeExecutor2) {
-  parent.command("arb").description("Detect arbitrage opportunities across DEXes").option("--token-in <token>", "Base token (default: WHYPE)", "WHYPE").option("--token-out <token>", "Quote token (default: USDC)", "USDC").option("--amount <amount>", "Test amount in wei", "1000000000000000000").option("--execute", "Execute best arb (default: analysis only)").option("--min-profit <bps>", "Min profit in bps to execute", "10").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const rpcUrl = chain.effectiveRpcUrl();
-    const tokenIn = opts.tokenIn.startsWith("0x") ? opts.tokenIn : registry.resolveToken(chainName, opts.tokenIn).address;
-    const tokenOut = opts.tokenOut.startsWith("0x") ? opts.tokenOut : registry.resolveToken(chainName, opts.tokenOut).address;
-    const amountIn = BigInt(opts.amount);
-    const dexProtocols = registry.getProtocolsByCategory("dex").filter((p) => p.chain === chainName);
-    const quotes = [];
-    for (const p of dexProtocols) {
-      try {
-        const adapter = createDex(p, rpcUrl);
-        const buyQuote = await adapter.quote({ protocol: p.name, token_in: tokenIn, token_out: tokenOut, amount_in: amountIn });
-        if (buyQuote.amount_out === 0n) continue;
-        const sellQuote = await adapter.quote({ protocol: p.name, token_in: tokenOut, token_out: tokenIn, amount_in: buyQuote.amount_out });
-        const profitBps = Number((sellQuote.amount_out - amountIn) * 10000n / amountIn);
-        quotes.push({ protocol: p.name, buy: buyQuote.amount_out, sell: sellQuote.amount_out, profit_bps: profitBps });
-      } catch {
-      }
-    }
-    const opportunities = [];
-    for (let i = 0; i < quotes.length; i++) {
-      for (let j = 0; j < quotes.length; j++) {
-        if (i === j) continue;
-        const buyAmount = quotes[i].buy;
-        const sellAmount = quotes[j].sell;
-        if (sellAmount > amountIn) {
-          const profitBps = Number((sellAmount - amountIn) * 10000n / amountIn);
-          opportunities.push({ buy_on: quotes[i].protocol, sell_on: quotes[j].protocol, profit_bps: profitBps });
-        }
-      }
-    }
-    opportunities.sort((a, b) => b.profit_bps - a.profit_bps);
-    printOutput({
-      chain: chainName,
-      token_in: tokenIn,
-      token_out: tokenOut,
-      amount_in: amountIn,
-      single_dex: quotes,
-      cross_dex_opportunities: opportunities.slice(0, 5)
-    }, getOpts());
-  });
-}
-
 // src/commands/positions.ts
 import { encodeFunctionData as encodeFunctionData30, parseAbi as parseAbi34 } from "viem";
 var ERC20_ABI6 = parseAbi34([
@@ -10067,207 +9743,6 @@ function registerWhales(parent, getOpts) {
   });
 }
 
-// src/commands/compare.ts
-import { spawnSync } from "child_process";
-function round25(x) {
-  return Math.round(x * 100) / 100;
-}
-async function fetchPerpRates() {
-  let result = spawnSync("perp", ["--json", "arb", "scan", "--rates"], { encoding: "utf8", timeout: 3e4 });
-  if (result.error || result.status !== 0) {
-    result = spawnSync("npx", ["-y", "perp-cli@latest", "--json", "arb", "scan", "--rates"], {
-      encoding: "utf8",
-      timeout: 6e4
-    });
-  }
-  if (result.error || result.status !== 0) {
-    throw new Error("perp-cli not found or failed");
-  }
-  let data;
-  try {
-    data = JSON.parse(result.stdout);
-  } catch {
-    throw new Error("perp JSON parse error");
-  }
-  const d = data;
-  const symbolsRaw = d["data"]?.["symbols"] ?? d["symbols"];
-  const symbols = Array.isArray(symbolsRaw) ? symbolsRaw : [];
-  const results = [];
-  for (const sym of symbols) {
-    const symbol = sym["symbol"] ?? "?";
-    const maxSpread = sym["maxSpreadAnnual"] ?? 0;
-    const longEx = sym["longExchange"] ?? "?";
-    const shortEx = sym["shortExchange"] ?? "?";
-    if (Math.abs(maxSpread) > 0) {
-      results.push({
-        type: "perp_funding",
-        asset: symbol,
-        apy: round25(maxSpread),
-        detail: `long ${longEx} / short ${shortEx}`,
-        risk: Math.abs(maxSpread) > 50 ? "high" : Math.abs(maxSpread) > 20 ? "medium" : "low",
-        source: "perp-cli"
-      });
-    }
-    const rates = Array.isArray(sym["rates"]) ? sym["rates"] : [];
-    for (const rate of rates) {
-      const exchange = rate["exchange"] ?? "?";
-      const annual = rate["annualizedPct"] ?? 0;
-      if (Math.abs(annual) > 1) {
-        results.push({
-          type: "perp_rate",
-          asset: symbol,
-          apy: round25(annual),
-          detail: exchange,
-          risk: Math.abs(annual) > 50 ? "high" : Math.abs(annual) > 20 ? "medium" : "low",
-          source: "perp-cli"
-        });
-      }
-    }
-  }
-  return results;
-}
-async function fetchLendingRates(registry, asset) {
-  const chainKeys = Array.from(registry.chains.keys());
-  const tasks = chainKeys.map(async (ck) => {
-    try {
-      const chain = registry.getChain(ck);
-      const chainName = chain.name.toLowerCase();
-      let assetAddr;
-      try {
-        assetAddr = registry.resolveToken(chainName, asset).address;
-      } catch {
-        return [];
-      }
-      const protos = registry.getProtocolsForChain(chainName).filter((p) => p.category === ProtocolCategory.Lending && p.interface === "aave_v3");
-      if (protos.length === 0) return [];
-      const rpc = chain.effectiveRpcUrl();
-      const rates = [];
-      for (const proto of protos) {
-        try {
-          const lending = createLending(proto, rpc);
-          const r = await lending.getRates(assetAddr);
-          if (r.supply_apy > 0) {
-            rates.push({
-              type: "lending_supply",
-              asset,
-              apy: round25(r.supply_apy * 100),
-              detail: `${r.protocol} (${chain.name})`,
-              risk: "low",
-              source: "defi-cli"
-            });
-          }
-        } catch {
-        }
-      }
-      return rates;
-    } catch {
-      return [];
-    }
-  });
-  const nested = await Promise.all(tasks);
-  return nested.flat();
-}
-function registerCompare(parent, getOpts) {
-  parent.command("compare").description("Compare all yield sources: perp funding vs lending APY vs staking").option("--asset <token>", "Token symbol to compare (e.g. USDC, ETH)", "USDC").option("--no-perps", "Exclude perp funding rates").option("--no-lending", "Exclude lending rates").option("--min-apy <pct>", "Minimum absolute APY to show", "1.0").action(async (opts) => {
-    try {
-      const registry = Registry.loadEmbedded();
-      const asset = opts.asset ?? "USDC";
-      const includePerps = opts.perps !== false;
-      const includeLending = opts.lending !== false;
-      const minApy = parseFloat(opts.minApy ?? "1.0");
-      const t0 = Date.now();
-      const opportunities = [];
-      if (includePerps) {
-        try {
-          const perpData = await fetchPerpRates();
-          for (const opp of perpData) {
-            const apy = Math.abs(opp["apy"] ?? 0);
-            if (apy >= minApy) opportunities.push(opp);
-          }
-        } catch {
-        }
-      }
-      if (includeLending) {
-        const lendingData = await fetchLendingRates(registry, asset);
-        for (const opp of lendingData) {
-          const apy = Math.abs(opp["apy"] ?? 0);
-          if (apy >= minApy) opportunities.push(opp);
-        }
-      }
-      opportunities.sort((a, b) => {
-        const aApy = Math.abs(a["apy"] ?? 0);
-        const bApy = Math.abs(b["apy"] ?? 0);
-        return bApy - aApy;
-      });
-      const scanMs = Date.now() - t0;
-      printOutput(
-        {
-          asset,
-          scan_duration_ms: scanMs,
-          total_opportunities: opportunities.length,
-          opportunities
-        },
-        getOpts()
-      );
-    } catch (err) {
-      printOutput({ error: String(err) }, getOpts());
-      process.exit(1);
-    }
-  });
-}
-
-// src/commands/swap.ts
-var ODOS_API = "https://api.odos.xyz";
-function registerSwap(parent, getOpts, makeExecutor2) {
-  parent.command("swap").description("Aggregator swap: best price across all DEXes (ODOS)").requiredOption("--token-in <token>", "Input token symbol or address").requiredOption("--token-out <token>", "Output token symbol or address").requiredOption("--amount <amount>", "Amount of input token in wei").option("--slippage <bps>", "Slippage tolerance in basis points", "50").option("--recipient <address>", "Recipient address").action(async (opts) => {
-    const executor = makeExecutor2();
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const tokenIn = opts.tokenIn.startsWith("0x") ? opts.tokenIn : registry.resolveToken(chainName, opts.tokenIn).address;
-    const tokenOut = opts.tokenOut.startsWith("0x") ? opts.tokenOut : registry.resolveToken(chainName, opts.tokenOut).address;
-    const sender = opts.recipient ?? process.env.DEFI_WALLET_ADDRESS ?? "0x0000000000000000000000000000000000000001";
-    try {
-      const quoteRes = await fetch(`${ODOS_API}/sor/quote/v2`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          chainId: chain.chain_id,
-          inputTokens: [{ tokenAddress: tokenIn, amount: opts.amount }],
-          outputTokens: [{ tokenAddress: tokenOut, proportion: 1 }],
-          slippageLimitPercent: parseInt(opts.slippage) / 100,
-          userAddr: sender
-        })
-      });
-      const quote = await quoteRes.json();
-      if (!quote.pathId) {
-        printOutput({ error: "No ODOS route found", quote }, getOpts());
-        return;
-      }
-      const assembleRes = await fetch(`${ODOS_API}/sor/assemble`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ pathId: quote.pathId, userAddr: sender })
-      });
-      const assembled = await assembleRes.json();
-      if (assembled.transaction) {
-        const tx = {
-          description: `ODOS swap ${tokenIn} \u2192 ${tokenOut}`,
-          to: assembled.transaction.to,
-          data: assembled.transaction.data,
-          value: BigInt(assembled.transaction.value ?? 0)
-        };
-        const result = await executor.execute(tx);
-        printOutput({ ...result, odos_quote: quote }, getOpts());
-      } else {
-        printOutput({ error: "ODOS assembly failed", assembled }, getOpts());
-      }
-    } catch (e) {
-      printOutput({ error: `ODOS API error: ${e instanceof Error ? e.message : String(e)}` }, getOpts());
-    }
-  });
-}
-
 // src/commands/bridge.ts
 var LIFI_API = "https://li.quest/v1";
 var DLN_API = "https://dln.debridge.finance/v1.0/dln/order";
@@ -10493,249 +9968,208 @@ function registerBridge(parent, getOpts) {
   });
 }
 
-// src/commands/nft.ts
-function registerNft(parent, getOpts) {
-  const nft = parent.command("nft").description("NFT operations: collection info, ownership, balance");
-  nft.command("info").description("Get NFT collection info (name, symbol, total supply)").requiredOption("--collection <address>", "NFT collection contract address").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const nftProtocols = registry.getProtocolsByCategory("nft").filter((p) => p.chain === chainName);
-    const entry = nftProtocols[0] ?? { name: "ERC721", slug: "erc721", category: "nft", interface: "erc721", chain: chainName, contracts: { collection: opts.collection } };
-    try {
-      const adapter = createNft(entry, chain.effectiveRpcUrl());
-      const info = await adapter.getCollectionInfo(opts.collection);
-      printOutput(info, getOpts());
-    } catch (e) {
-      printOutput({ error: e instanceof Error ? e.message : String(e) }, getOpts());
-    }
-  });
-  nft.command("owner").description("Check who owns a specific NFT token ID").requiredOption("--collection <address>", "NFT collection contract address").requiredOption("--token-id <id>", "Token ID").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const nftProtocols = registry.getProtocolsByCategory("nft").filter((p) => p.chain === chainName);
-    const entry = nftProtocols[0] ?? { name: "ERC721", slug: "erc721", category: "nft", interface: "erc721", chain: chainName, contracts: { collection: opts.collection } };
-    try {
-      const adapter = createNft(entry, chain.effectiveRpcUrl());
-      const info = await adapter.getTokenInfo(opts.collection, BigInt(opts.tokenId));
-      printOutput(info, getOpts());
-    } catch (e) {
-      printOutput({ error: e instanceof Error ? e.message : String(e) }, getOpts());
-    }
-  });
-  nft.command("balance").description("Check how many NFTs an address holds in a collection").requiredOption("--collection <address>", "NFT collection contract address").requiredOption("--owner <address>", "Owner address to query").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const nftProtocols = registry.getProtocolsByCategory("nft").filter((p) => p.chain === chainName);
-    const entry = nftProtocols[0] ?? { name: "ERC721", slug: "erc721", category: "nft", interface: "erc721", chain: chainName, contracts: { collection: opts.collection } };
-    try {
-      const adapter = createNft(entry, chain.effectiveRpcUrl());
-      const balance = await adapter.getBalance(opts.owner, opts.collection);
-      printOutput({ collection: opts.collection, owner: opts.owner, balance }, getOpts());
-    } catch (e) {
-      printOutput({ error: e instanceof Error ? e.message : String(e) }, getOpts());
-    }
-  });
-  nft.command("uri").description("Get token URI for a specific NFT").requiredOption("--collection <address>", "NFT collection contract address").requiredOption("--token-id <id>", "Token ID").action(async (opts) => {
-    const chainName = parent.opts().chain ?? "hyperevm";
-    const registry = Registry.loadEmbedded();
-    const chain = registry.getChain(chainName);
-    const nftProtocols = registry.getProtocolsByCategory("nft").filter((p) => p.chain === chainName);
-    const entry = nftProtocols[0] ?? { name: "ERC721", slug: "erc721", category: "nft", interface: "erc721", chain: chainName, contracts: { collection: opts.collection } };
-    try {
-      const adapter = createNft(entry, chain.effectiveRpcUrl());
-      const info = await adapter.getTokenInfo(opts.collection, BigInt(opts.tokenId));
-      printOutput({ collection: opts.collection, token_id: opts.tokenId, token_uri: info.token_uri }, getOpts());
-    } catch (e) {
-      printOutput({ error: e instanceof Error ? e.message : String(e) }, getOpts());
-    }
+// src/commands/swap.ts
+var CHAIN_NAMES = {
+  hyperevm: { kyber: "hyperevm", openocean: "hyperevm" },
+  mantle: { openocean: "mantle" }
+};
+var KYBER_API = "https://aggregator-api.kyberswap.com";
+async function kyberGetQuote(chain, tokenIn, tokenOut, amountIn) {
+  const params = new URLSearchParams({ tokenIn, tokenOut, amountIn });
+  const url = `${KYBER_API}/${chain}/api/v1/routes?${params}`;
+  const res = await fetch(url, { headers: { "x-client-id": "defi-cli" } });
+  if (!res.ok) throw new Error(`KyberSwap quote failed: ${res.status} ${await res.text()}`);
+  const json = await res.json();
+  const data = json.data;
+  if (!data?.routeSummary) throw new Error(`KyberSwap: no route found`);
+  return data;
+}
+async function kyberBuildTx(chain, routeSummary, sender, recipient, slippageTolerance) {
+  const url = `${KYBER_API}/${chain}/api/v1/route/build`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "x-client-id": "defi-cli" },
+    body: JSON.stringify({ routeSummary, sender, recipient, slippageTolerance })
   });
+  if (!res.ok) throw new Error(`KyberSwap build failed: ${res.status} ${await res.text()}`);
+  const json = await res.json();
+  const data = json.data;
+  if (!data) throw new Error("KyberSwap: no build data");
+  return {
+    to: String(data.routerAddress),
+    data: String(data.data),
+    value: String(data.value ?? "0x0")
+  };
 }
-
-// src/commands/farm.ts
-function registerFarm(parent, getOpts, makeExecutor2) {
-  const farm = parent.command("farm").description("LP farm operations: deposit, withdraw, claim rewards (MasterChef)");
-  farm.command("deposit").description("Deposit LP tokens into a MasterChef farm").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--pid <pid>", "Farm pool ID").requiredOption("--amount <amount>", "LP token amount in wei").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 = createMasterChef(protocol, rpcUrl);
-    const tx = await adapter.buildDeposit(
-      protocol.contracts?.["masterchef"],
-      BigInt(opts.amount),
-      BigInt(opts.pid)
-    );
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-  farm.command("withdraw").description("Withdraw LP tokens from a MasterChef farm").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--pid <pid>", "Farm pool ID").requiredOption("--amount <amount>", "LP token amount in wei").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 = createMasterChef(protocol, rpcUrl);
-    const tx = await adapter.buildWithdrawPid(
-      BigInt(opts.pid),
-      BigInt(opts.amount)
-    );
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-  farm.command("claim").description("Claim pending rewards from a MasterChef farm").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--pid <pid>", "Farm pool 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 = createMasterChef(protocol, rpcUrl);
-    const tx = await adapter.buildClaimRewardsPid(
-      BigInt(opts.pid)
-    );
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-  farm.command("info").description("Show pending rewards and farm info").requiredOption("--protocol <protocol>", "Protocol slug").option("--pid <pid>", "Farm pool ID (optional)").option("--address <address>", "Wallet address to query (defaults to DEFI_WALLET_ADDRESS env)").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 = createMasterChef(protocol, rpcUrl);
-    const walletAddress = opts.address ?? process.env["DEFI_WALLET_ADDRESS"];
-    if (!walletAddress) {
-      throw new Error("--address or DEFI_WALLET_ADDRESS required");
-    }
-    const masterchef = protocol.contracts?.["masterchef"];
-    const rewards = await adapter.getPendingRewards(masterchef, walletAddress);
-    printOutput(rewards, getOpts());
+var OPENOCEAN_API = "https://open-api.openocean.finance/v4";
+async function openoceanSwap(chain, inTokenAddress, outTokenAddress, amountIn, slippagePct, account) {
+  const params = new URLSearchParams({
+    inTokenAddress,
+    outTokenAddress,
+    amount: amountIn,
+    gasPrice: "0.1",
+    slippage: slippagePct,
+    account
   });
+  const url = `${OPENOCEAN_API}/${chain}/swap?${params}`;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`OpenOcean swap failed: ${res.status} ${await res.text()}`);
+  const json = await res.json();
+  const data = json.data;
+  if (!data) throw new Error("OpenOcean: no swap data");
+  return {
+    to: String(data.to),
+    data: String(data.data),
+    value: String(data.value ?? "0x0"),
+    outAmount: String(data.outAmount ?? "0")
+  };
 }
-
-// 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) => {
+var LIQD_API = "https://api.liqd.ag/v2";
+var LIQD_ROUTER = "0x744489ee3d540777a66f2cf297479745e0852f7a";
+async function liquidSwapRoute(tokenIn, tokenOut, amountIn, slippagePct) {
+  const params = new URLSearchParams({ tokenIn, tokenOut, amountIn, slippage: slippagePct });
+  const url = `${LIQD_API}/route?${params}`;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`LiquidSwap route failed: ${res.status} ${await res.text()}`);
+  const json = await res.json();
+  const execution = json.execution;
+  if (!execution) throw new Error("LiquidSwap: no execution data in response");
+  const details = json.details;
+  return {
+    to: String(execution.to ?? LIQD_ROUTER),
+    data: String(execution.calldata),
+    value: String(execution.value ?? "0x0"),
+    outAmount: String(details?.amountOut ?? json.amountOut ?? "0")
+  };
+}
+function registerSwap(parent, getOpts, makeExecutor2) {
+  parent.command("swap").description("Swap tokens via DEX aggregator (KyberSwap, OpenOcean, LiquidSwap)").requiredOption("--from <token>", "Input token symbol or address").requiredOption("--to <token>", "Output token symbol or address").requiredOption("--amount <amount>", "Amount of input token in wei").option("--provider <name>", "Aggregator: kyber, openocean, liquid", "kyber").option("--slippage <bps>", "Slippage tolerance in bps", "50").action(async (opts) => {
     const executor = makeExecutor2();
+    const chainName = parent.opts().chain ?? "hyperevm";
     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());
+    const provider = opts.provider.toLowerCase();
+    const slippageBps = parseInt(opts.slippage, 10);
+    const fromAddr = opts.from.startsWith("0x") ? opts.from : registry.resolveToken(chainName, opts.from).address;
+    const toAddr = opts.to.startsWith("0x") ? opts.to : registry.resolveToken(chainName, opts.to).address;
+    const wallet = process.env["DEFI_WALLET_ADDRESS"] ?? "0x0000000000000000000000000000000000000001";
+    if (provider === "kyber") {
+      const chainNames = CHAIN_NAMES[chainName];
+      if (!chainNames?.kyber) {
+        printOutput({ error: `KyberSwap: unsupported chain '${chainName}'. Supported: hyperevm` }, getOpts());
+        return;
+      }
+      const kyberChain = chainNames.kyber;
+      try {
+        const quoteData = await kyberGetQuote(kyberChain, fromAddr, toAddr, opts.amount);
+        const routeSummary = quoteData.routeSummary;
+        const amountOut = String(routeSummary.amountOut ?? "0");
+        const txData = await kyberBuildTx(
+          kyberChain,
+          routeSummary,
+          wallet,
+          wallet,
+          slippageBps
+        );
+        const tx = {
+          description: `KyberSwap: swap ${opts.amount} of ${fromAddr} -> ${toAddr}`,
+          to: txData.to,
+          data: txData.data,
+          value: txData.value.startsWith("0x") ? BigInt(txData.value) : BigInt(txData.value || 0),
+          approvals: [{ token: fromAddr, spender: txData.to, amount: BigInt(opts.amount) }]
+        };
+        const result = await executor.execute(tx);
+        printOutput({
+          provider: "kyber",
+          chain: kyberChain,
+          from_token: fromAddr,
+          to_token: toAddr,
+          amount_in: opts.amount,
+          amount_out: amountOut,
+          router: txData.to,
+          ...result
+        }, getOpts());
+      } catch (e) {
+        printOutput({ error: `KyberSwap error: ${e instanceof Error ? e.message : String(e)}` }, getOpts());
+      }
+      return;
+    }
+    if (provider === "openocean") {
+      const chainNames = CHAIN_NAMES[chainName];
+      if (!chainNames) {
+        printOutput({ error: `OpenOcean: unsupported chain '${chainName}'. Supported: ${Object.keys(CHAIN_NAMES).join(", ")}` }, getOpts());
+        return;
+      }
+      const ooChain = chainNames.openocean;
+      const fromToken = opts.from.startsWith("0x") ? registry.tokens.get(chainName)?.find((t) => t.address.toLowerCase() === opts.from.toLowerCase()) : registry.tokens.get(chainName)?.find((t) => t.symbol.toLowerCase() === opts.from.toLowerCase());
+      const fromDecimals = fromToken?.decimals ?? 18;
+      const humanAmount = (Number(opts.amount) / 10 ** fromDecimals).toString();
+      const slippagePct = (slippageBps / 100).toFixed(2);
+      try {
+        const swap = await openoceanSwap(
+          ooChain,
+          fromAddr,
+          toAddr,
+          humanAmount,
+          slippagePct,
+          wallet
+        );
+        const tx = {
+          description: `OpenOcean: swap ${opts.amount} of ${fromAddr} -> ${toAddr}`,
+          to: swap.to,
+          data: swap.data,
+          value: swap.value.startsWith("0x") ? BigInt(swap.value) : BigInt(swap.value || 0),
+          approvals: [{ token: fromAddr, spender: swap.to, amount: BigInt(opts.amount) }]
+        };
+        const result = await executor.execute(tx);
+        printOutput({
+          provider: "openocean",
+          chain: ooChain,
+          from_token: fromAddr,
+          to_token: toAddr,
+          amount_in: opts.amount,
+          amount_out: swap.outAmount,
+          router: swap.to,
+          ...result
+        }, getOpts());
+      } catch (e) {
+        printOutput({ error: `OpenOcean error: ${e instanceof Error ? e.message : String(e)}` }, getOpts());
+      }
+      return;
+    }
+    if (provider === "liquid") {
+      if (chainName !== "hyperevm") {
+        printOutput({ error: `LiquidSwap only supports hyperevm, got '${chainName}'` }, getOpts());
+        return;
+      }
+      const slippagePct = (slippageBps / 100).toFixed(2);
+      try {
+        const route = await liquidSwapRoute(fromAddr, toAddr, opts.amount, slippagePct);
+        const tx = {
+          description: `LiquidSwap: swap ${opts.amount} of ${fromAddr} -> ${toAddr}`,
+          to: route.to,
+          data: route.data,
+          value: route.value.startsWith("0x") ? BigInt(route.value) : BigInt(route.value || 0),
+          approvals: [{ token: fromAddr, spender: route.to, amount: BigInt(opts.amount) }]
+        };
+        const result = await executor.execute(tx);
+        printOutput({
+          provider: "liquid",
+          chain: chainName,
+          from_token: fromAddr,
+          to_token: toAddr,
+          amount_in: opts.amount,
+          amount_out: route.outAmount,
+          router: route.to,
+          ...result
+        }, getOpts());
+      } catch (e) {
+        printOutput({ error: `LiquidSwap error: ${e instanceof Error ? e.message : String(e)}` }, getOpts());
+      }
+      return;
+    }
+    printOutput({ error: `Unknown provider '${opts.provider}'. Choose: kyber, openocean, liquid` }, 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";
@@ -10785,8 +10219,8 @@ function isValidPrivateKey(s) {
 }
 async function deriveAddress(privateKey) {
   try {
-    const { privateKeyToAccount: privateKeyToAccount4 } = await import("viem/accounts");
-    const account = privateKeyToAccount4(privateKey);
+    const { privateKeyToAccount: privateKeyToAccount3 } = await import("viem/accounts");
+    const account = privateKeyToAccount3(privateKey);
     return account.address;
   } catch {
     return null;
@@ -10881,107 +10315,6 @@ function registerSetup(program2) {
   });
 }
 
-// src/commands/lb.ts
-function registerLB(parent, getOpts, makeExecutor2) {
-  const lb = parent.command("lb").description("Merchant Moe Liquidity Book: add/remove liquidity, rewards, positions");
-  lb.command("add").description("Add liquidity to a Liquidity Book pair").requiredOption("--protocol <protocol>", "Protocol slug (e.g. merchantmoe-mantle)").requiredOption("--pool <address>", "LB pair address").requiredOption("--token-x <address>", "Token X address").requiredOption("--token-y <address>", "Token Y address").requiredOption("--bin-step <step>", "Bin step of the pair").option("--amount-x <wei>", "Amount of token X in wei", "0").option("--amount-y <wei>", "Amount of token Y in wei", "0").option("--bins <N>", "Number of bins on each side of active bin", "5").option("--active-id <id>", "Active bin id (defaults to on-chain query)").option("--recipient <address>", "Recipient 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 ?? "mantle");
-    const rpcUrl = chain.effectiveRpcUrl();
-    const adapter = createMerchantMoeLB(protocol, rpcUrl);
-    const recipient = opts.recipient ?? process.env["DEFI_WALLET_ADDRESS"] ?? "0x0000000000000000000000000000000000000001";
-    const tx = await adapter.buildAddLiquidity({
-      pool: opts.pool,
-      tokenX: opts.tokenX,
-      tokenY: opts.tokenY,
-      binStep: parseInt(opts.binStep),
-      amountX: BigInt(opts.amountX),
-      amountY: BigInt(opts.amountY),
-      numBins: parseInt(opts.bins),
-      activeIdDesired: opts.activeId ? parseInt(opts.activeId) : void 0,
-      recipient
-    });
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-  lb.command("remove").description("Remove liquidity from Liquidity Book bins").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--token-x <address>", "Token X address").requiredOption("--token-y <address>", "Token Y address").requiredOption("--bin-step <step>", "Bin step of the pair").requiredOption("--bins <binIds>", "Comma-separated bin IDs to remove from").requiredOption("--amounts <amounts>", "Comma-separated LB token amounts to remove per bin (wei)").option("--recipient <address>", "Recipient address").action(async (opts) => {
-    const executor = makeExecutor2();
-    const registry = Registry.loadEmbedded();
-    const protocol = registry.getProtocol(opts.protocol);
-    const adapter = createMerchantMoeLB(protocol);
-    const recipient = opts.recipient ?? process.env["DEFI_WALLET_ADDRESS"] ?? "0x0000000000000000000000000000000000000001";
-    const binIds = opts.bins.split(",").map((s) => parseInt(s.trim()));
-    const amounts = opts.amounts.split(",").map((s) => BigInt(s.trim()));
-    const tx = await adapter.buildRemoveLiquidity({
-      tokenX: opts.tokenX,
-      tokenY: opts.tokenY,
-      binStep: parseInt(opts.binStep),
-      binIds,
-      amounts,
-      recipient
-    });
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-  lb.command("rewards").description("Show pending MOE rewards for a pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--pool <address>", "LB pair address").option("--bins <binIds>", "Comma-separated bin IDs to check (auto-detected from rewarder range if omitted)").option("--address <address>", "Wallet address (defaults to DEFI_WALLET_ADDRESS)").action(async (opts) => {
-    const registry = Registry.loadEmbedded();
-    const protocol = registry.getProtocol(opts.protocol);
-    const chainName = parent.opts().chain;
-    const chain = registry.getChain(chainName ?? "mantle");
-    const rpcUrl = chain.effectiveRpcUrl();
-    const adapter = createMerchantMoeLB(protocol, rpcUrl);
-    const user = opts.address ?? process.env["DEFI_WALLET_ADDRESS"];
-    if (!user) throw new Error("--address or DEFI_WALLET_ADDRESS required");
-    const binIds = opts.bins ? opts.bins.split(",").map((s) => parseInt(s.trim())) : void 0;
-    const rewards = await adapter.getPendingRewards(user, opts.pool, binIds);
-    printOutput(rewards, getOpts());
-  });
-  lb.command("claim").description("Claim pending MOE rewards from a pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--pool <address>", "LB pair address").option("--bins <binIds>", "Comma-separated bin IDs to claim from (auto-detected from rewarder range if omitted)").option("--address <address>", "Wallet address (defaults to DEFI_WALLET_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 ?? "mantle");
-    const rpcUrl = chain.effectiveRpcUrl();
-    const adapter = createMerchantMoeLB(protocol, rpcUrl);
-    const user = opts.address ?? process.env["DEFI_WALLET_ADDRESS"];
-    if (!user) throw new Error("--address or DEFI_WALLET_ADDRESS required");
-    const binIds = opts.bins ? opts.bins.split(",").map((s) => parseInt(s.trim())) : void 0;
-    const tx = await adapter.buildClaimRewards(user, opts.pool, binIds);
-    const result = await executor.execute(tx);
-    printOutput(result, getOpts());
-  });
-  lb.command("discover").description("Find all rewarded LB pools on chain").requiredOption("--protocol <protocol>", "Protocol slug").option("--active-only", "Only show non-stopped pools").action(async (opts) => {
-    const registry = Registry.loadEmbedded();
-    const protocol = registry.getProtocol(opts.protocol);
-    const chainName = parent.opts().chain;
-    const chain = registry.getChain(chainName ?? "mantle");
-    const rpcUrl = chain.effectiveRpcUrl();
-    const adapter = createMerchantMoeLB(protocol, rpcUrl);
-    let pools = await adapter.discoverRewardedPools();
-    if (opts.activeOnly) {
-      pools = pools.filter((p) => !p.stopped);
-    }
-    printOutput(pools, getOpts());
-  });
-  lb.command("positions").description("Show user positions per bin in a LB pool").requiredOption("--protocol <protocol>", "Protocol slug").requiredOption("--pool <address>", "LB pair address").option("--bins <binIds>", "Comma-separated bin IDs to query (auto-detected from rewarder range or active \xB1 50 if omitted)").option("--address <address>", "Wallet address (defaults to DEFI_WALLET_ADDRESS)").action(async (opts) => {
-    const registry = Registry.loadEmbedded();
-    const protocol = registry.getProtocol(opts.protocol);
-    const chainName = parent.opts().chain;
-    const chain = registry.getChain(chainName ?? "mantle");
-    const rpcUrl = chain.effectiveRpcUrl();
-    const adapter = createMerchantMoeLB(protocol, rpcUrl);
-    const user = opts.address ?? process.env["DEFI_WALLET_ADDRESS"];
-    if (!user) throw new Error("--address or DEFI_WALLET_ADDRESS required");
-    const binIds = opts.bins ? opts.bins.split(",").map((s) => parseInt(s.trim())) : void 0;
-    const positions = await adapter.getUserPositions(user, opts.pool, binIds);
-    printOutput(positions, getOpts());
-  });
-}
-
 // src/cli.ts
 var _require = createRequire(import.meta.url);
 var _pkg = _require("../package.json");
@@ -10995,8 +10328,8 @@ var BANNER = `
 
   2 chains \xB7 21 protocols \xB7 by HypurrQuant
 
-  Scan exploits, swap tokens, bridge assets, track whales,
-  compare yields \u2014 all from your terminal.
+  Lending, LP provision, farming, gauges, vaults,
+  yield comparison \u2014 all from your terminal.
 `;
 var program = new Command().name("defi").description("DeFi CLI \u2014 Multi-chain DeFi toolkit").version(_pkg.version).addHelpText("before", BANNER).option("--json", "Output as JSON").option("--ndjson", "Output as newline-delimited JSON").option("--fields <fields>", "Select specific output fields (comma-separated)").option("--chain <chain>", "Target chain", "hyperevm").option("--dry-run", "Dry-run mode (default, no broadcast)", true).option("--broadcast", "Actually broadcast the transaction");
 function getOutputMode() {
@@ -11011,37 +10344,23 @@ function makeExecutor() {
 }
 registerStatus(program, getOutputMode);
 registerSchema(program, getOutputMode);
-registerDex(program, getOutputMode, makeExecutor);
-registerGauge(program, getOutputMode, makeExecutor);
+registerLP(program, getOutputMode, makeExecutor);
 registerLending(program, getOutputMode, makeExecutor);
 registerCdp(program, getOutputMode, makeExecutor);
-registerStaking(program, getOutputMode, makeExecutor);
 registerVault(program, getOutputMode, makeExecutor);
 registerYield(program, getOutputMode, makeExecutor);
 registerPortfolio(program, getOutputMode);
 registerMonitor(program, getOutputMode);
 registerAlert(program, getOutputMode);
 registerScan(program, getOutputMode);
-registerArb(program, getOutputMode, makeExecutor);
 registerPositions(program, getOutputMode);
 registerPrice(program, getOutputMode);
 registerWallet(program, getOutputMode);
 registerToken(program, getOutputMode, makeExecutor);
 registerWhales(program, getOutputMode);
-registerCompare(program, getOutputMode);
-registerSwap(program, getOutputMode, makeExecutor);
 registerBridge(program, getOutputMode);
-registerNft(program, getOutputMode);
-registerFarm(program, getOutputMode, makeExecutor);
-registerFarming(program, getOutputMode, makeExecutor);
-registerLB(program, getOutputMode, makeExecutor);
+registerSwap(program, getOutputMode, makeExecutor);
 registerSetup(program);
-program.command("agent").description("Agent mode: read JSON commands from stdin (for AI agents)").action(async () => {
-  const executor = makeExecutor();
-  process.stderr.write("Agent mode: reading JSON commands from stdin...\n");
-  process.stderr.write("Agent mode not yet fully implemented in TS port.\n");
-  process.exit(1);
-});
 export {
   program
 };