@hypurrquant/defi-cli 1.0.0 → 1.0.1

package/README.md

@@ -4,7 +4,7 @@
 [![npm downloads](https://img.shields.io/npm/dw/@hypurrquant/defi-cli.svg)](https://www.npmjs.com/package/@hypurrquant/defi-cli)
 [![license](https://img.shields.io/npm/l/@hypurrquant/defi-cli.svg)](https://github.com/hypurrquant/defi-cli/blob/main/LICENSE)
 
-Multi-chain DeFi CLI — **7 chains · 48 protocols · 5 aggregators**. Lending, LP farming with emission claim, DEX swap via aggregator, cross-chain bridge.
+Multi-chain DeFi CLI — **5 chains · 39 protocols · 5 aggregators**. Lending, LP farming with emission claim, DEX swap via aggregator, cross-chain bridge.
 
 ```bash
 npm install -g @hypurrquant/defi-cli
@@ -23,8 +23,6 @@ npx -y @hypurrquant/defi-cli --json status
 | Base | 8453 | 🟢 production | 5 |
 | BNB | 56 | 🟡 staged | 16 |
 | Monad | 143 | 🟡 staged | 4 |
-| Arbitrum | 42161 | 🟡 staged | 3 |
-| Ethereum | 1 | 🟡 staged | 6 |
 
 🟢 = full lifecycle broadcast verified (mint/supply → claim → withdraw)
 🟡 = configs + read-only paths verified, awaiting funded broadcast
@@ -68,21 +66,15 @@ npx -y @hypurrquant/defi-cli --json status
 ### Monad (4)
 `uniswap-v2-monad`, `uniswap-v3-monad`, `traderjoe-monad` (LB), `morpho-blue-monad`
 
-### Ethereum (6)
-`aave-v2-ethereum`, `aave-v3-ethereum`, `compound-v3-ethereum`, `morpho-blue-ethereum`, `uniswap-v2-ethereum`, `uniswap-v3-ethereum`
-
-### Arbitrum (3)
-`aave-v3-arbitrum`, `compound-v3-arbitrum`, `uniswap-v3-arbitrum`
-
 ## DEX Aggregators (Live-verified)
 
-| Aggregator | HyperEVM | Mantle | Base | BNB | Ethereum | Arbitrum |
-|---|---|---|---|---|---|---|
-| KyberSwap | ✅ | ❌ | ✅ | ✅ | ✅ | ✅ |
-| OpenOcean | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| LiquidSwap | ✅ | — | — | — | — | — |
-| LI.FI | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Relay | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Aggregator | HyperEVM | Mantle | Base | BNB | Monad |
+|---|---|---|---|---|---|
+| KyberSwap | ✅ | ❌ | ✅ | ✅ | — |
+| OpenOcean | ✅ | ✅ | ✅ | ✅ | — |
+| LiquidSwap | ✅ | — | — | — | — |
+| LI.FI | ✅ | ✅ | ✅ | ✅ | — |
+| Relay | ✅ | ✅ | ✅ | ✅ | — |
 
 ## Setup
 
@@ -169,7 +161,7 @@ defi --chain base lp claim --protocol aerodrome-cl \
 # Pick the cheapest provider per chain
 defi --chain mantle swap --provider lifi --from MOE --to WMNT --amount <wei> --broadcast
 defi --chain base swap --provider kyber --from WETH --to USDC --amount <wei> --broadcast
-defi --chain ethereum swap --provider relay --from WETH --to USDC --amount <wei> --broadcast
+defi --chain bnb swap --provider relay --from WBNB --to USDT --amount <wei> --broadcast
 ```
 
 ## Agent-First Design
@@ -229,7 +221,7 @@ Or copy `skills/defi-cli/` into your Claude Code skills directory.
 ## Global Flags
 
 ```bash
---chain <name>      # hyperevm | mantle | base | bnb | monad | arbitrum | ethereum
+--chain <name>      # hyperevm | mantle | base | bnb | monad
 --json              # JSON output
 --ndjson            # NDJSON streaming
 --fields <a,b>      # Output field filter

package/dist/mcp-server.js

@@ -7543,7 +7543,7 @@ server.tool(
   "defi_status",
   "Show chain and protocol status: lists all protocols deployed on a chain with contract addresses and categories",
   {
-    chain: z.string().optional().describe("Chain name (default: hyperevm). E.g. hyperevm, ethereum, arbitrum, base")
+    chain: z.string().optional().describe("Chain name (default: hyperevm). One of: hyperevm, mantle, base, bnb, monad")
   },
   async ({ chain }) => {
     try {
@@ -7800,8 +7800,8 @@ server.tool(
   "defi_bridge",
   "Get a cross-chain bridge quote via LI.FI, deBridge DLN, or Circle CCTP. Returns estimated output amount and fees",
   {
-    from_chain: z.string().describe("Source chain name, e.g. ethereum, arbitrum, base"),
-    to_chain: z.string().describe("Destination chain name, e.g. hyperevm, arbitrum"),
+    from_chain: z.string().describe("Source chain name (supported source chains: hyperevm, mantle, base, bnb, monad)"),
+    to_chain: z.string().describe("Destination chain name. CCTP V2 destinations include ethereum, arbitrum, optimism, polygon, avalanche; LI.FI/deBridge accept any chain"),
     token: z.string().optional().describe("Token symbol to bridge (default: USDC). Use native for native token"),
     amount: z.string().describe("Amount in human-readable units, e.g. '100' for 100 USDC"),
     recipient: z.string().optional().describe("Recipient address on destination chain")
@@ -8465,6 +8465,352 @@ server.tool(
     };
   }
 );
+server.tool(
+  "defi_lp_compound",
+  "V3 fee auto-compound: collect accrued LP fees and re-add them as liquidity in one tx. Requires NFT tokenId. Returns simulated/confirmed tx with collected fee amounts.",
+  {
+    chain: z.string().describe("Chain name (e.g. base, hyperevm, mantle)"),
+    protocol: z.string().describe("Protocol slug (e.g. uniswap-v3-base, hyperswap, project-x)"),
+    token_id: z.string().describe("NFT tokenId of the LP position to compound"),
+    slippage_bps: z.number().optional().describe("Slippage tolerance in bps (default: 50 = 0.5%)"),
+    address: z.string().optional().describe("Recipient address (defaults to DEFI_WALLET_ADDRESS)"),
+    broadcast: z.boolean().optional().describe("Broadcast tx (default: false = dry-run)")
+  },
+  async ({ chain, protocol, token_id, slippage_bps, address, broadcast }) => {
+    try {
+      const chainName = chain.toLowerCase();
+      const registry = getRegistry();
+      const chainConfig = registry.getChain(chainName);
+      const rpcUrl = chainConfig.effectiveRpcUrl();
+      const proto = registry.getProtocol(protocol);
+      const recipient = address ?? process.env["DEFI_WALLET_ADDRESS"];
+      if (!recipient) throw new Error("address required (or set DEFI_WALLET_ADDRESS)");
+      const adapter = createDex(proto, rpcUrl);
+      if (!("buildCompound" in adapter) || typeof adapter.buildCompound !== "function") {
+        throw new Error(`[${proto.name}] adapter does not support compound (V3 fee-only protocols only)`);
+      }
+      const compoundOpts = slippage_bps !== void 0 ? { slippageBps: slippage_bps } : void 0;
+      const tx = await adapter.buildCompound(BigInt(token_id), recipient, compoundOpts);
+      const executor = makeExecutor(broadcast ?? false, rpcUrl, chainConfig.explorer_url);
+      const result = await executor.execute(tx);
+      return {
+        content: [{ type: "text", text: ok(result, { chain: chainName, protocol, token_id, broadcast: broadcast ?? false }) }]
+      };
+    } catch (e) {
+      return { content: [{ type: "text", text: err(e instanceof Error ? e.message : String(e), { chain, protocol, token_id }) }], isError: true };
+    }
+  }
+);
+server.tool(
+  "defi_lp_claim",
+  "Claim LP rewards from a pool. Auto-dispatches by protocol interface: V3 fees (NPM.collect), gauge emission (Solidly/Hybra/Ramses CL), Merchant Moe LB hooks, KittenSwap eternal farming, off-chain Nest tickets. Requires either token-id (CL/NFT positions) or gauge (V2-style staking) plus pool for LB.",
+  {
+    chain: z.string().describe("Chain name"),
+    protocol: z.string().describe("Protocol slug"),
+    pool: z.string().optional().describe("Pool address (required for LB / KittenSwap farming)"),
+    gauge: z.string().optional().describe("Gauge address (required for solidly/hybra)"),
+    token_id: z.string().optional().describe("NFT tokenId (CL gauge or farming positions)"),
+    bins: z.string().optional().describe("Comma-separated bin IDs (Merchant Moe LB; auto-detected if omitted)"),
+    address: z.string().optional().describe("Wallet address (defaults to DEFI_WALLET_ADDRESS)"),
+    redeem_type: z.number().optional().describe("Hybra: 0=instant exit (penalty), 1=2yr veHYBR lock (default)"),
+    broadcast: z.boolean().optional().describe("Broadcast tx (default: false = dry-run)")
+  },
+  async ({ chain, protocol, pool, gauge, token_id, bins, address, redeem_type, broadcast }) => {
+    try {
+      const chainName = chain.toLowerCase();
+      const registry = getRegistry();
+      const chainConfig = registry.getChain(chainName);
+      const rpcUrl = chainConfig.effectiveRpcUrl();
+      const proto = registry.getProtocol(protocol);
+      const account = address ?? process.env["DEFI_WALLET_ADDRESS"];
+      if (!account) throw new Error("address required (or set DEFI_WALLET_ADDRESS)");
+      const iface = proto.interface;
+      const executor = makeExecutor(broadcast ?? false, rpcUrl, chainConfig.explorer_url);
+      const { createKittenSwapFarming: createKittenSwapFarming2, createMerchantMoeLB: createMerchantMoeLB2, createGauge: createGauge2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports2));
+      const isV3Fee = proto.reward_strategy === "lp_fee_only" || iface === "uniswap_v3" && token_id && !gauge;
+      if (isV3Fee) {
+        if (!token_id) throw new Error("token_id required for V3 fee collection");
+        const adapter = createDex(proto, rpcUrl);
+        if (!("buildCollectFees" in adapter) || typeof adapter.buildCollectFees !== "function") {
+          throw new Error(`[${proto.name}] adapter does not support buildCollectFees`);
+        }
+        const tx = await adapter.buildCollectFees(BigInt(token_id), account);
+        const result = await executor.execute(tx);
+        return { content: [{ type: "text", text: ok(result, { chain: chainName, protocol, kind: "v3_fee", broadcast: broadcast ?? false }) }] };
+      }
+      if (iface === "algebra_v3" && proto.contracts?.["farming_center"]) {
+        if (!pool) throw new Error("pool required for KittenSwap farming claim");
+        if (!token_id) throw new Error("token_id required for KittenSwap farming claim");
+        const adapter = createKittenSwapFarming2(proto, rpcUrl);
+        const tx = await adapter.buildCollectRewards(BigInt(token_id), pool, account);
+        const result = await executor.execute(tx);
+        return { content: [{ type: "text", text: ok(result, { chain: chainName, protocol, kind: "kittenswap_farming", broadcast: broadcast ?? false }) }] };
+      }
+      if (iface === "uniswap_v2" && proto.contracts?.["lb_factory"]) {
+        if (!pool) throw new Error("pool required for Merchant Moe LB claim");
+        const adapter = createMerchantMoeLB2(proto, rpcUrl);
+        const binIds = bins ? bins.split(",").map((s) => parseInt(s.trim(), 10)) : void 0;
+        const tx = await adapter.buildClaimRewards(account, pool, binIds);
+        const result = await executor.execute(tx);
+        return { content: [{ type: "text", text: ok(result, { chain: chainName, protocol, kind: "lb", broadcast: broadcast ?? false }) }] };
+      }
+      if (["solidly_v2", "solidly_cl", "algebra_v3", "hybra"].includes(iface) || iface === "uniswap_v3" && proto.contracts?.["voter"]) {
+        if (!gauge) throw new Error("gauge required for gauge-based claim");
+        const adapter = createGauge2(proto, rpcUrl);
+        let tx;
+        if (token_id && iface === "uniswap_v3" && proto.reward_strategy === "auto_stake" && "buildClaimRewardsViaNPMPeriodReward" in adapter && typeof adapter.buildClaimRewardsViaNPMPeriodReward === "function") {
+          const npm = proto.contracts?.["position_manager"];
+          if (!npm) throw new Error(`${proto.name} requires contracts.position_manager for NPM-based claim`);
+          tx = await adapter.buildClaimRewardsViaNPMPeriodReward(npm, BigInt(token_id), account, { gauge });
+        } else if (token_id) {
+          if (!adapter.buildClaimRewardsByTokenId) throw new Error(`${proto.name} does not support NFT-based claim`);
+          const claimOpts = redeem_type !== void 0 ? { redeemType: redeem_type } : void 0;
+          tx = await adapter.buildClaimRewardsByTokenId(gauge, BigInt(token_id), claimOpts);
+        } else {
+          tx = await adapter.buildClaimRewards(gauge, account);
+        }
+        const result = await executor.execute(tx);
+        return { content: [{ type: "text", text: ok(result, { chain: chainName, protocol, kind: "gauge", broadcast: broadcast ?? false }) }] };
+      }
+      throw new Error(`No claim method found for protocol interface '${iface}'`);
+    } catch (e) {
+      return { content: [{ type: "text", text: err(e instanceof Error ? e.message : String(e), { chain, protocol }) }], isError: true };
+    }
+  }
+);
+server.tool(
+  "defi_lp_farm",
+  "Add liquidity and auto-stake into gauge/farming for emissions. Two-step flow: mint LP NFT, then deposit into gauge (Solidly/Hybra) or enterFarming (KittenSwap eternal). Merchant Moe LB hooks need no staking.",
+  {
+    chain: z.string().describe("Chain name"),
+    protocol: z.string().describe("Protocol slug"),
+    token_a: z.string().describe("First token symbol or address"),
+    token_b: z.string().describe("Second token symbol or address"),
+    amount_a: z.string().describe("Amount of token A in wei"),
+    amount_b: z.string().describe("Amount of token B in wei"),
+    pool: z.string().optional().describe("Pool name (e.g. WHYPE/USDC) or address"),
+    gauge: z.string().optional().describe("Gauge address (auto-resolved if omitted)"),
+    recipient: z.string().optional().describe("Recipient/owner (defaults to DEFI_WALLET_ADDRESS)"),
+    tick_lower: z.number().optional().describe("Lower tick (CL)"),
+    tick_upper: z.number().optional().describe("Upper tick (CL)"),
+    range_pct: z.number().optional().describe("\xB1N% concentrated range around current price"),
+    broadcast: z.boolean().optional().describe("Broadcast tx (default: false = dry-run)")
+  },
+  async ({ chain, protocol, token_a, token_b, amount_a, amount_b, pool, gauge, recipient, tick_lower, tick_upper, range_pct, broadcast }) => {
+    try {
+      const chainName = chain.toLowerCase();
+      const registry = getRegistry();
+      const chainConfig = registry.getChain(chainName);
+      const rpcUrl = chainConfig.effectiveRpcUrl();
+      const proto = registry.getProtocol(protocol);
+      const owner = recipient ?? process.env["DEFI_WALLET_ADDRESS"] ?? "0x0000000000000000000000000000000000000001";
+      const tokenA = resolveToken(registry, chainName, token_a);
+      const tokenB = resolveToken(registry, chainName, token_b);
+      let poolAddr;
+      if (pool) {
+        poolAddr = pool.startsWith("0x") ? pool : registry.resolvePool(protocol, pool).address;
+      }
+      const dexAdapter = createDex(proto, rpcUrl);
+      const addTx = await dexAdapter.buildAddLiquidity({
+        protocol: proto.name,
+        token_a: tokenA,
+        token_b: tokenB,
+        amount_a: BigInt(amount_a),
+        amount_b: BigInt(amount_b),
+        recipient: owner,
+        tick_lower,
+        tick_upper,
+        range_pct,
+        pool: poolAddr
+      });
+      const executor = makeExecutor(broadcast ?? false, rpcUrl, chainConfig.explorer_url);
+      const addResult = await executor.execute(addTx);
+      const steps = [{ step: "lp_add", ...addResult }];
+      if (addResult.status !== "confirmed" && addResult.status !== "simulated") {
+        return { content: [{ type: "text", text: ok({ steps, note: "LP add did not succeed; staking skipped." }, { chain: chainName, protocol, broadcast: broadcast ?? false }) }] };
+      }
+      const mintedTokenId = addResult.details?.minted_token_id ? BigInt(addResult.details.minted_token_id) : void 0;
+      const iface = proto.interface;
+      const { createKittenSwapFarming: createKittenSwapFarming2, createGauge: createGauge2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports2));
+      if (iface === "algebra_v3" && proto.contracts?.["farming_center"]) {
+        if (!mintedTokenId) {
+          steps.push({ step: "stake_farming", skipped: "no tokenId in dry-run mode" });
+        } else if (!poolAddr) {
+          throw new Error("pool required for KittenSwap farming");
+        } else {
+          const farmAdapter = createKittenSwapFarming2(proto, rpcUrl);
+          const stakeTx = await farmAdapter.buildEnterFarming(mintedTokenId, poolAddr, owner);
+          const stakeResult = await executor.execute(stakeTx);
+          steps.push({ step: "stake_farming", ...stakeResult });
+        }
+        return { content: [{ type: "text", text: ok({ steps }, { chain: chainName, protocol, broadcast: broadcast ?? false }) }] };
+      }
+      const isGaugeStakeable = ["solidly_v2", "solidly_cl", "hybra"].includes(iface) || iface === "uniswap_v3" && proto.contracts?.["voter"];
+      if (isGaugeStakeable) {
+        if (!mintedTokenId && iface !== "solidly_v2") {
+          steps.push({ step: "stake_gauge", skipped: "no tokenId in dry-run mode" });
+          return { content: [{ type: "text", text: ok({ steps }, { chain: chainName, protocol, broadcast: broadcast ?? false }) }] };
+        }
+        let gaugeAddr = gauge;
+        const gaugeAdapter = createGauge2(proto, rpcUrl);
+        if (!gaugeAddr && poolAddr && gaugeAdapter.resolveGauge) {
+          try {
+            gaugeAddr = await gaugeAdapter.resolveGauge(poolAddr);
+          } catch {
+          }
+        }
+        if (!gaugeAddr) throw new Error("gauge required (could not auto-resolve)");
+        let amountArg = 0n;
+        if (iface === "solidly_v2" && poolAddr) {
+          const { createPublicClient: createPublicClient24, http: httpTransport, parseAbi: parseAbi31 } = await import("viem");
+          const erc20Abi3 = parseAbi31(["function balanceOf(address) view returns (uint256)"]);
+          const lpClient = createPublicClient24({ transport: httpTransport(rpcUrl) });
+          amountArg = await lpClient.readContract({
+            address: poolAddr,
+            abi: erc20Abi3,
+            functionName: "balanceOf",
+            args: [owner]
+          });
+          if (amountArg === 0n) {
+            steps.push({ step: "stake_gauge", skipped: "LP balance 0 after mint" });
+            return { content: [{ type: "text", text: ok({ steps }, { chain: chainName, protocol, broadcast: broadcast ?? false }) }] };
+          }
+        }
+        const lpTokenArg = iface === "solidly_v2" ? poolAddr : void 0;
+        const stakeTx = await gaugeAdapter.buildDeposit(gaugeAddr, amountArg, mintedTokenId, lpTokenArg);
+        const stakeResult = await executor.execute(stakeTx);
+        steps.push({ step: "stake_gauge", ...stakeResult });
+        return { content: [{ type: "text", text: ok({ steps }, { chain: chainName, protocol, broadcast: broadcast ?? false }) }] };
+      }
+      if (iface === "uniswap_v2" && proto.contracts?.["lb_factory"]) {
+        steps.push({ step: "stake_gauge", skipped: "Merchant Moe LB hooks auto-handle rewards" });
+        return { content: [{ type: "text", text: ok({ steps }, { chain: chainName, protocol, broadcast: broadcast ?? false }) }] };
+      }
+      steps.push({ step: "stake_gauge", skipped: "No staking adapter for this interface" });
+      return { content: [{ type: "text", text: ok({ steps }, { chain: chainName, protocol, broadcast: broadcast ?? false }) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: err(e instanceof Error ? e.message : String(e), { chain, protocol }) }], isError: true };
+    }
+  }
+);
+server.tool(
+  "defi_lp_positions",
+  "Show all LP positions for a wallet across protocols on a chain. Includes Merchant Moe LB bins (with pending MOE), V3/Algebra/Hybra NFT positions. Auto-detects user's actual bin IDs for LB pools.",
+  {
+    chain: z.string().describe("Chain name"),
+    protocol: z.string().optional().describe("Filter to a single protocol slug"),
+    pool: z.string().optional().describe("Filter to a specific pool address"),
+    bins: z.string().optional().describe("Comma-separated bin IDs (LB; auto-detected if omitted)"),
+    address: z.string().optional().describe("Wallet address (defaults to DEFI_WALLET_ADDRESS)")
+  },
+  async ({ chain, protocol, pool, bins, address }) => {
+    try {
+      const chainName = chain.toLowerCase();
+      const registry = getRegistry();
+      const chainConfig = registry.getChain(chainName);
+      const rpcUrl = chainConfig.effectiveRpcUrl();
+      const user = address ?? process.env["DEFI_WALLET_ADDRESS"];
+      if (!user) throw new Error("address required (or set DEFI_WALLET_ADDRESS)");
+      const { createMerchantMoeLB: createMerchantMoeLB2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports2));
+      const { createPublicClient: createPublicClient24, http: httpTransport, parseAbi: parseAbi31 } = await import("viem");
+      const allProtocols = registry.getProtocolsForChain(chainName);
+      const protocols = protocol ? [registry.getProtocol(protocol)] : allProtocols;
+      const results = [];
+      await Promise.allSettled(
+        protocols.map(async (proto) => {
+          try {
+            if (proto.interface === "uniswap_v2" && proto.contracts?.["lb_factory"]) {
+              const adapter = createMerchantMoeLB2(proto, rpcUrl);
+              const binIds = bins ? bins.split(",").map((s) => parseInt(s.trim(), 10)) : void 0;
+              const poolsToScan = pool ? [pool] : (await adapter.discoverRewardedPools()).map((p) => p.pool);
+              for (const poolAddr of poolsToScan) {
+                try {
+                  const userBins = binIds ?? await adapter.findUserBinsWithBalance(poolAddr, user);
+                  if (userBins.length === 0) continue;
+                  const positions = await adapter.getUserPositions(user, poolAddr, userBins);
+                  if (positions.length === 0) continue;
+                  const pending = await adapter.getPendingRewards(user, poolAddr, userBins).catch(() => []);
+                  const totalPending = pending.reduce((s, r) => s + (r.amount ?? 0n), 0n);
+                  for (const pos of positions) {
+                    results.push({
+                      protocol: proto.slug,
+                      type: "lb",
+                      pool: poolAddr,
+                      ...pos,
+                      pending_reward: totalPending.toString(),
+                      pending_reward_token: pending[0]?.token
+                    });
+                  }
+                } catch {
+                }
+              }
+            }
+            const npm = proto.contracts?.["position_manager"];
+            if (npm && ["uniswap_v3", "algebra_v3", "hybra"].includes(proto.interface)) {
+              const npmAbi = parseAbi31([
+                "function balanceOf(address) view returns (uint256)",
+                "function tokenOfOwnerByIndex(address, uint256) view returns (uint256)",
+                "function positions(uint256) view returns (uint96 nonce, address op, address t0, address t1, uint24 fee, int24 tl, int24 tu, uint128 liq, uint256 a, uint256 b, uint128 o0, uint128 o1)"
+              ]);
+              const ramsesAbi = parseAbi31([
+                "function positions(uint256) view returns (address t0, address t1, int24 ts, int24 tl, int24 tu, uint128 liq, uint256 a, uint256 b, uint128 o0, uint128 o1)"
+              ]);
+              const client = createPublicClient24({ transport: httpTransport(rpcUrl) });
+              let count;
+              try {
+                count = await client.readContract({ address: npm, abi: npmAbi, functionName: "balanceOf", args: [user] });
+              } catch {
+                return;
+              }
+              const max = Math.min(Number(count), 50);
+              for (let i = 0; i < max; i++) {
+                try {
+                  const tokenId = await client.readContract({
+                    address: npm,
+                    abi: npmAbi,
+                    functionName: "tokenOfOwnerByIndex",
+                    args: [user, BigInt(i)]
+                  });
+                  let liq = 0n;
+                  let token0;
+                  let token1;
+                  let tickLower;
+                  let tickUpper;
+                  try {
+                    const r = await client.readContract({ address: npm, abi: ramsesAbi, functionName: "positions", args: [tokenId] });
+                    [token0, token1, , tickLower, tickUpper, liq] = r;
+                  } catch {
+                    const r = await client.readContract({ address: npm, abi: npmAbi, functionName: "positions", args: [tokenId] });
+                    [, , token0, token1, , tickLower, tickUpper, liq] = r;
+                  }
+                  if (liq > 0n) {
+                    results.push({
+                      protocol: proto.slug,
+                      type: "v3_nft",
+                      token_id: tokenId.toString(),
+                      token0,
+                      token1,
+                      liquidity: liq.toString(),
+                      tick_lower: tickLower,
+                      tick_upper: tickUpper
+                    });
+                  }
+                } catch {
+                }
+              }
+            }
+          } catch {
+          }
+        })
+      );
+      return {
+        content: [{ type: "text", text: ok({ chain: chainName, positions: results, total: results.length }, { wallet: user, scanned_protocols: protocols.length }) }]
+      };
+    } catch (e) {
+      return { content: [{ type: "text", text: err(e instanceof Error ? e.message : String(e), { chain }) }], isError: true };
+    }
+  }
+);
 var transport = new StdioServerTransport();
 await server.connect(transport);
 //# sourceMappingURL=mcp-server.js.map