@spectratools/aborean-cli 0.3.0 → 0.6.0

package/dist/cli.js

@@ -4,10 +4,14 @@
 import { readFileSync } from "fs";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
-import { Cli as Cli4, z as z4 } from "incur";
+import { checksumAddress as checksumAddress6 } from "@spectratools/cli-shared";
+import { Cli as Cli8, z as z8 } from "incur";
+import { formatUnits as formatUnits4 } from "viem";
 
-// src/commands/gauges.ts
+// src/commands/cl.ts
+import { checksumAddress, isAddress } from "@spectratools/cli-shared";
 import { Cli, z } from "incur";
+import { formatUnits, parseUnits } from "viem";
 
 // src/contracts/abis/CLFactory.abi.json
 var CLFactory_abi_default = [
@@ -122,6 +126,73 @@ var CLFactory_abi_default = [
   }
 ];
 
+// src/contracts/abis/CLPool.abi.json
+var CLPool_abi_default = [
+  {
+    type: "function",
+    name: "slot0",
+    inputs: [],
+    outputs: [
+      { name: "sqrtPriceX96", type: "uint160", internalType: "uint160" },
+      { name: "tick", type: "int24", internalType: "int24" },
+      { name: "observationIndex", type: "uint16", internalType: "uint16" },
+      { name: "observationCardinality", type: "uint16", internalType: "uint16" },
+      { name: "observationCardinalityNext", type: "uint16", internalType: "uint16" },
+      { name: "unlocked", type: "bool", internalType: "bool" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "liquidity",
+    inputs: [],
+    outputs: [{ name: "", type: "uint128", internalType: "uint128" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "token0",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "token1",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tickSpacing",
+    inputs: [],
+    outputs: [{ name: "", type: "int24", internalType: "int24" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "factory",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "gauge",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "fee",
+    inputs: [],
+    outputs: [{ name: "", type: "uint24", internalType: "uint24" }],
+    stateMutability: "view"
+  }
+];
+
 // src/contracts/abis/Gauge.abi.json
 var Gauge_abi_default = [
   {
@@ -256,6 +327,68 @@ var Minter_abi_default = [
   }
 ];
 
+// src/contracts/abis/NonfungiblePositionManager.abi.json
+var NonfungiblePositionManager_abi_default = [
+  {
+    type: "function",
+    name: "positions",
+    inputs: [{ name: "tokenId", type: "uint256", internalType: "uint256" }],
+    outputs: [
+      { name: "nonce", type: "uint96", internalType: "uint96" },
+      { name: "operator", type: "address", internalType: "address" },
+      { name: "token0", type: "address", internalType: "address" },
+      { name: "token1", type: "address", internalType: "address" },
+      { name: "tickSpacing", type: "int24", internalType: "int24" },
+      { name: "tickLower", type: "int24", internalType: "int24" },
+      { name: "tickUpper", type: "int24", internalType: "int24" },
+      { name: "liquidity", type: "uint128", internalType: "uint128" },
+      { name: "feeGrowthInside0LastX128", type: "uint256", internalType: "uint256" },
+      { name: "feeGrowthInside1LastX128", type: "uint256", internalType: "uint256" },
+      { name: "tokensOwed0", type: "uint128", internalType: "uint128" },
+      { name: "tokensOwed1", type: "uint128", internalType: "uint128" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "owner", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tokenOfOwnerByIndex",
+    inputs: [
+      { name: "owner", type: "address", internalType: "address" },
+      { name: "index", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "factory",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "WETH9",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  }
+];
+
 // src/contracts/abis/PoolFactory.abi.json
 var PoolFactory_abi_default = [
   {
@@ -316,6 +449,64 @@ var PoolFactory_abi_default = [
   }
 ];
 
+// src/contracts/abis/QuoterV2.abi.json
+var QuoterV2_abi_default = [
+  {
+    type: "function",
+    name: "factory",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "WETH9",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "quoteExactInputSingle",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        internalType: "struct IQuoterV2.QuoteExactInputSingleParams",
+        components: [
+          { name: "tokenIn", type: "address", internalType: "address" },
+          { name: "tokenOut", type: "address", internalType: "address" },
+          { name: "amountIn", type: "uint256", internalType: "uint256" },
+          { name: "tickSpacing", type: "int24", internalType: "int24" },
+          { name: "sqrtPriceLimitX96", type: "uint160", internalType: "uint160" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "amountOut", type: "uint256", internalType: "uint256" },
+      { name: "sqrtPriceX96After", type: "uint160", internalType: "uint160" },
+      { name: "initializedTicksCrossed", type: "uint32", internalType: "uint32" },
+      { name: "gasEstimate", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "quoteExactInput",
+    inputs: [
+      { name: "path", type: "bytes", internalType: "bytes" },
+      { name: "amountIn", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [
+      { name: "amountOut", type: "uint256", internalType: "uint256" },
+      { name: "sqrtPriceX96AfterList", type: "uint160[]", internalType: "uint160[]" },
+      { name: "initializedTicksCrossedList", type: "uint32[]", internalType: "uint32[]" },
+      { name: "gasEstimate", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "nonpayable"
+  }
+];
+
 // src/contracts/abis/RewardsDistributor.abi.json
 var RewardsDistributor_abi_default = [
   {
@@ -369,6 +560,87 @@ var RewardsDistributor_abi_default = [
   }
 ];
 
+// src/contracts/abis/V2Pool.abi.json
+var V2Pool_abi_default = [
+  {
+    type: "function",
+    name: "token0",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "token1",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "stable",
+    inputs: [],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getReserves",
+    inputs: [],
+    outputs: [
+      { name: "_reserve0", type: "uint256", internalType: "uint256" },
+      { name: "_reserve1", type: "uint256", internalType: "uint256" },
+      { name: "_blockTimestampLast", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "poolFees",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "factory",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  }
+];
+
+// src/contracts/abis/V2Router.abi.json
+var V2Router_abi_default = [
+  {
+    type: "function",
+    name: "getAmountsOut",
+    inputs: [
+      { name: "amountIn", type: "uint256", internalType: "uint256" },
+      {
+        name: "routes",
+        type: "tuple[]",
+        internalType: "struct IRouter.Route[]",
+        components: [
+          { name: "from", type: "address", internalType: "address" },
+          { name: "to", type: "address", internalType: "address" },
+          { name: "stable", type: "bool", internalType: "bool" },
+          { name: "factory", type: "address", internalType: "address" }
+        ]
+      }
+    ],
+    outputs: [{ name: "amounts", type: "uint256[]", internalType: "uint256[]" }],
+    stateMutability: "view"
+  }
+];
+
 // src/contracts/abis/Voter.abi.json
 var Voter_abi_default = [
   {
@@ -668,10 +940,15 @@ var VotingReward_abi_default = [
 
 // src/contracts/abis.ts
 var clFactoryAbi = CLFactory_abi_default;
+var clPoolAbi = CLPool_abi_default;
 var gaugeAbi = Gauge_abi_default;
 var minterAbi = Minter_abi_default;
+var nonfungiblePositionManagerAbi = NonfungiblePositionManager_abi_default;
 var poolFactoryAbi = PoolFactory_abi_default;
+var quoterV2Abi = QuoterV2_abi_default;
 var rewardsDistributorAbi = RewardsDistributor_abi_default;
+var v2PoolAbi = V2Pool_abi_default;
+var v2RouterAbi = V2Router_abi_default;
 var voterAbi = Voter_abi_default;
 var votingEscrowAbi = VotingEscrow_abi_default;
 var votingRewardAbi = VotingReward_abi_default;
@@ -733,9 +1010,25 @@ var ABOREAN_CL_ADDRESSES = {
   /** CL swap router */
   swapRouter: "0xAda5d0E79681038A9547fe6a59f1413F3E720839"
 };
+var ABOREAN_VAULT_ADDRESSES = {
+  /** Factory for AutoCompounder relay vaults */
+  autoCompounderFactory: "0x35b320599C1434291a0003E40Fcd1e40fA9E0222",
+  /** Factory for AutoConverter relay vaults */
+  autoConverterFactory: "0xf114D2aCF8aAFDde833e0a8ba2dc5A3946614354",
+  /** veABX Maxi relay vault */
+  veAbxMaxiRelay: "0xcbeB1A72A31670AE5ba27798c124Fcf3Ca1971df",
+  /** ABX rewards relay vault */
+  abxRewardsRelay: "0x3E8D887Bba5D4A757FaE757883CA35882AB4a0ee"
+};
+var ABOREAN_LENDING_ADDRESSES = {
+  /** Morpho Blue core contract on Abstract */
+  morphoBlue: "0xc85CE8ffdA27b646D269516B8d0Fa6ec2E958B55"
+};
 var ABOREAN_ADDRESSES = {
   ...ABOREAN_V2_ADDRESSES,
-  ...ABOREAN_CL_ADDRESSES
+  ...ABOREAN_CL_ADDRESSES,
+  ...ABOREAN_VAULT_ADDRESSES,
+  ...ABOREAN_LENDING_ADDRESSES
 };
 
 // src/contracts/client.ts
@@ -761,57 +1054,594 @@ function createAboreanPublicClient(rpcUrl) {
   });
 }
 
-// src/commands/_common.ts
-import { checksumAddress, weiToEth } from "@spectratools/cli-shared";
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-function toChecksum(address) {
-  try {
-    return checksumAddress(address);
-  } catch {
-    return address;
+// src/commands/cl.ts
+var Q96 = 2n ** 96n;
+var MULTICALL_BATCH_SIZE = 100;
+var env = z.object({
+  ABSTRACT_RPC_URL: z.string().optional().describe("Abstract RPC URL override")
+});
+var tokenSchema = z.object({
+  address: z.string(),
+  symbol: z.string(),
+  decimals: z.number()
+});
+var poolRowSchema = z.object({
+  pool: z.string(),
+  pair: z.string(),
+  token0: tokenSchema,
+  token1: tokenSchema,
+  fee: z.number(),
+  feePercent: z.number(),
+  tickSpacing: z.number(),
+  liquidity: z.string(),
+  currentTick: z.number(),
+  sqrtPriceX96: z.string(),
+  activeLiquidityEstimate: z.object({
+    token0: z.string(),
+    token1: z.string(),
+    totalInToken0: z.number().nullable(),
+    totalInToken1: z.number().nullable()
+  }),
+  price: z.object({
+    token1PerToken0: z.number().nullable(),
+    token0PerToken1: z.number().nullable()
+  })
+});
+var quoteOutputSchema = z.object({
+  pool: z.string(),
+  selectedFee: z.number(),
+  selectedTickSpacing: z.number(),
+  tokenIn: tokenSchema,
+  tokenOut: tokenSchema,
+  amountIn: z.object({
+    raw: z.string(),
+    decimal: z.string()
+  }),
+  amountOut: z.object({
+    raw: z.string(),
+    decimal: z.string()
+  }),
+  execution: z.object({
+    sqrtPriceX96After: z.string(),
+    initializedTicksCrossed: z.number(),
+    gasEstimate: z.string()
+  }),
+  prices: z.object({
+    poolMidPriceOutPerIn: z.number().nullable(),
+    quotePriceOutPerIn: z.number().nullable(),
+    priceImpactPct: z.number().nullable()
+  })
+});
+var erc20MetadataAbi = [
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "string" }]
+  },
+  {
+    type: "function",
+    name: "decimals",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint8" }]
   }
+];
+function shortAddress(address) {
+  return `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
 }
-function asNum(value) {
-  return Number(value);
+function finiteOrNull(value) {
+  return Number.isFinite(value) ? value : null;
 }
-function relTime(unixSeconds) {
-  const ts = typeof unixSeconds === "bigint" ? Number(unixSeconds) : unixSeconds;
-  if (!Number.isFinite(ts) || ts <= 0) return "n/a";
-  const delta = ts - Math.floor(Date.now() / 1e3);
-  const abs = Math.abs(delta);
-  const hours = Math.floor(abs / 3600);
-  const minutes = Math.floor(abs % 3600 / 60);
-  const label = hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
-  return delta >= 0 ? `in ${label}` : `${label} ago`;
+function toTokenMetaFallback(address) {
+  return {
+    address,
+    symbol: shortAddress(checksumAddress(address)),
+    decimals: 18
+  };
 }
-function clampPositive(seconds) {
-  return seconds > 0 ? seconds : 0;
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) {
+    out.push(items.slice(i, i + size));
+  }
+  return out;
 }
-
-// src/commands/gauges.ts
-var env = z.object({
-  ABSTRACT_RPC_URL: z.string().optional().describe("Abstract RPC URL override")
-});
-async function discoverGaugePools(client) {
-  const [v2PoolCount, clPoolCount] = await Promise.all([
-    client.readContract({
-      abi: poolFactoryAbi,
-      address: ABOREAN_V2_ADDRESSES.poolFactory,
-      functionName: "allPoolsLength"
-    }),
-    client.readContract({
-      abi: clFactoryAbi,
-      address: ABOREAN_CL_ADDRESSES.clFactory,
-      functionName: "allPoolsLength"
-    })
-  ]);
-  const v2Indices = Array.from({ length: asNum(v2PoolCount) }, (_, i) => BigInt(i));
-  const clIndices = Array.from({ length: asNum(clPoolCount) }, (_, i) => BigInt(i));
-  const [v2Pools, clPools] = await Promise.all([
-    v2Indices.length ? client.multicall({
+async function multicallAllowFailure(client, contracts) {
+  const batches = chunk(contracts, MULTICALL_BATCH_SIZE);
+  const out = [];
+  for (const batch of batches) {
+    const res = await client.multicall({
+      allowFailure: true,
+      contracts: batch
+    });
+    out.push(...res);
+  }
+  return out;
+}
+async function multicallStrict(client, contracts) {
+  const batches = chunk(contracts, MULTICALL_BATCH_SIZE);
+  const out = [];
+  for (const batch of batches) {
+    const res = await client.multicall({
       allowFailure: false,
-      contracts: v2Indices.map((index) => ({
-        abi: poolFactoryAbi,
+      contracts: batch
+    });
+    out.push(...res);
+  }
+  return out;
+}
+function derivePrices(sqrtPriceX96, token0Decimals, token1Decimals) {
+  const sqrtRatio = Number(sqrtPriceX96) / 2 ** 96;
+  const rawPrice = sqrtRatio * sqrtRatio;
+  const decimalScale = 10 ** (token0Decimals - token1Decimals);
+  const token1PerToken0 = finiteOrNull(rawPrice * decimalScale);
+  const token0PerToken1 = token1PerToken0 === null || token1PerToken0 === 0 ? null : finiteOrNull(1 / token1PerToken0);
+  return {
+    token1PerToken0,
+    token0PerToken1
+  };
+}
+function estimateActiveLiquidity(liquidity, sqrtPriceX96, token0Decimals, token1Decimals, prices) {
+  if (sqrtPriceX96 === 0n) {
+    return {
+      token0: "0",
+      token1: "0",
+      totalInToken0: null,
+      totalInToken1: null
+    };
+  }
+  const reserve0Raw = liquidity * Q96 / sqrtPriceX96;
+  const reserve1Raw = liquidity * sqrtPriceX96 / Q96;
+  const reserve0 = Number(formatUnits(reserve0Raw, token0Decimals));
+  const reserve1 = Number(formatUnits(reserve1Raw, token1Decimals));
+  const totalInToken1 = prices.token1PerToken0 === null ? null : finiteOrNull(reserve1 + reserve0 * prices.token1PerToken0);
+  const totalInToken0 = prices.token0PerToken1 === null ? null : finiteOrNull(reserve0 + reserve1 * prices.token0PerToken1);
+  return {
+    token0: formatUnits(reserve0Raw, token0Decimals),
+    token1: formatUnits(reserve1Raw, token1Decimals),
+    totalInToken0,
+    totalInToken1
+  };
+}
+async function readTokenMetadata(client, tokenAddresses) {
+  const uniqueTokens = [...new Set(tokenAddresses.map((x) => x.toLowerCase()))];
+  if (uniqueTokens.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const contracts = uniqueTokens.flatMap((address) => [
+    {
+      abi: erc20MetadataAbi,
+      address,
+      functionName: "symbol"
+    },
+    {
+      abi: erc20MetadataAbi,
+      address,
+      functionName: "decimals"
+    }
+  ]);
+  const results = await multicallAllowFailure(client, contracts);
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0; i < uniqueTokens.length; i += 1) {
+    const address = uniqueTokens[i];
+    const symbolResult = results[i * 2];
+    const decimalsResult = results[i * 2 + 1];
+    const fallback = toTokenMetaFallback(address);
+    const symbol = symbolResult && symbolResult.status === "success" && typeof symbolResult.result === "string" ? symbolResult.result : fallback.symbol;
+    const decimals = decimalsResult && decimalsResult.status === "success" && typeof decimalsResult.result === "number" ? decimalsResult.result : fallback.decimals;
+    out.set(address, {
+      address: checksumAddress(address),
+      symbol,
+      decimals
+    });
+  }
+  return out;
+}
+async function listPoolAddresses(client) {
+  const count = await client.readContract({
+    abi: clFactoryAbi,
+    address: ABOREAN_CL_ADDRESSES.clFactory,
+    functionName: "allPoolsLength"
+  });
+  if (count === 0n) {
+    return [];
+  }
+  const poolIndexContracts = Array.from({ length: Number(count) }, (_, i) => ({
+    abi: clFactoryAbi,
+    address: ABOREAN_CL_ADDRESSES.clFactory,
+    functionName: "allPools",
+    args: [BigInt(i)]
+  }));
+  const poolAddresses = await multicallStrict(client, poolIndexContracts);
+  return poolAddresses;
+}
+async function readPoolStates(client, poolAddresses) {
+  if (poolAddresses.length === 0) {
+    return [];
+  }
+  const poolContracts = poolAddresses.flatMap((pool) => [
+    {
+      abi: clPoolAbi,
+      address: pool,
+      functionName: "token0"
+    },
+    {
+      abi: clPoolAbi,
+      address: pool,
+      functionName: "token1"
+    },
+    {
+      abi: clPoolAbi,
+      address: pool,
+      functionName: "tickSpacing"
+    },
+    {
+      abi: clPoolAbi,
+      address: pool,
+      functionName: "fee"
+    },
+    {
+      abi: clPoolAbi,
+      address: pool,
+      functionName: "liquidity"
+    },
+    {
+      abi: clPoolAbi,
+      address: pool,
+      functionName: "slot0"
+    }
+  ]);
+  const values = await multicallStrict(client, poolContracts);
+  return poolAddresses.map((pool, i) => ({
+    pool,
+    token0: values[i * 6],
+    token1: values[i * 6 + 1],
+    tickSpacing: Number(values[i * 6 + 2]),
+    fee: Number(values[i * 6 + 3]),
+    liquidity: values[i * 6 + 4],
+    slot0: values[i * 6 + 5]
+  }));
+}
+function toPoolRow(pool, tokenMeta) {
+  const token0 = tokenMeta.get(pool.token0) ?? toTokenMetaFallback(pool.token0);
+  const token1 = tokenMeta.get(pool.token1) ?? toTokenMetaFallback(pool.token1);
+  const prices = derivePrices(pool.slot0[0], token0.decimals, token1.decimals);
+  const activeLiquidityEstimate = estimateActiveLiquidity(
+    pool.liquidity,
+    pool.slot0[0],
+    token0.decimals,
+    token1.decimals,
+    prices
+  );
+  return {
+    pool: checksumAddress(pool.pool),
+    pair: `${token0.symbol}/${token1.symbol}`,
+    token0,
+    token1,
+    fee: pool.fee,
+    feePercent: pool.fee / 1e4,
+    tickSpacing: pool.tickSpacing,
+    liquidity: pool.liquidity.toString(),
+    currentTick: pool.slot0[1],
+    sqrtPriceX96: pool.slot0[0].toString(),
+    activeLiquidityEstimate,
+    price: prices
+  };
+}
+function normalizeAddress(address) {
+  return address.toLowerCase();
+}
+var cl = Cli.create("cl", {
+  description: "Concentrated liquidity (Slipstream) pools, positions, and quotes."
+});
+cl.command("pools", {
+  description: "List Slipstream pools with current state, prices, and active liquidity estimate.",
+  env,
+  output: z.object({
+    count: z.number(),
+    pools: z.array(poolRowSchema)
+  }),
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const pools2 = await listPoolAddresses(client);
+    const poolStates = await readPoolStates(client, pools2);
+    const tokenMeta = await readTokenMetadata(
+      client,
+      poolStates.flatMap((pool) => [pool.token0, pool.token1])
+    );
+    const rows = poolStates.map((pool) => toPoolRow(pool, tokenMeta));
+    return c.ok({
+      count: rows.length,
+      pools: rows
+    });
+  }
+});
+cl.command("pool", {
+  description: "Get detailed state for a Slipstream pool address.",
+  args: z.object({
+    pool: z.string().describe("Pool address")
+  }),
+  env,
+  output: z.object({
+    pool: poolRowSchema
+  }),
+  async run(c) {
+    if (!isAddress(c.args.pool)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: `Invalid pool address: "${c.args.pool}". Use a valid 0x-prefixed 20-byte hex address.`
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const checksummedPool = checksumAddress(c.args.pool);
+    const [poolState] = await readPoolStates(client, [checksummedPool]);
+    const tokenMeta = await readTokenMetadata(client, [poolState.token0, poolState.token1]);
+    return c.ok({
+      pool: toPoolRow(poolState, tokenMeta)
+    });
+  }
+});
+cl.command("positions", {
+  description: "List concentrated liquidity NFT positions for an owner.",
+  args: z.object({
+    owner: z.string().describe("Owner wallet address")
+  }),
+  env,
+  output: z.object({
+    owner: z.string(),
+    count: z.number(),
+    positions: z.array(
+      z.object({
+        tokenId: z.string(),
+        pair: z.string(),
+        token0: tokenSchema,
+        token1: tokenSchema,
+        tickSpacing: z.number(),
+        tickLower: z.number(),
+        tickUpper: z.number(),
+        liquidity: z.string(),
+        tokensOwed0: z.object({ raw: z.string(), decimal: z.string() }),
+        tokensOwed1: z.object({ raw: z.string(), decimal: z.string() })
+      })
+    )
+  }),
+  async run(c) {
+    if (!isAddress(c.args.owner)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: `Invalid owner address: "${c.args.owner}". Use a valid 0x-prefixed 20-byte hex address.`
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const owner = checksumAddress(c.args.owner);
+    const balance = await client.readContract({
+      abi: nonfungiblePositionManagerAbi,
+      address: ABOREAN_CL_ADDRESSES.nonfungiblePositionManager,
+      functionName: "balanceOf",
+      args: [owner]
+    });
+    if (balance === 0n) {
+      return c.ok({ owner, count: 0, positions: [] });
+    }
+    const tokenIdContracts = Array.from({ length: Number(balance) }, (_, i) => ({
+      abi: nonfungiblePositionManagerAbi,
+      address: ABOREAN_CL_ADDRESSES.nonfungiblePositionManager,
+      functionName: "tokenOfOwnerByIndex",
+      args: [owner, BigInt(i)]
+    }));
+    const tokenIds = await multicallStrict(client, tokenIdContracts);
+    const positionContracts = tokenIds.map((tokenId) => ({
+      abi: nonfungiblePositionManagerAbi,
+      address: ABOREAN_CL_ADDRESSES.nonfungiblePositionManager,
+      functionName: "positions",
+      args: [tokenId]
+    }));
+    const positionsRaw = await multicallStrict(client, positionContracts);
+    const tokenMeta = await readTokenMetadata(
+      client,
+      positionsRaw.flatMap((position) => [position[2], position[3]])
+    );
+    const positions = tokenIds.map((tokenId, i) => {
+      const position = positionsRaw[i];
+      const token0 = tokenMeta.get(position[2]) ?? toTokenMetaFallback(position[2]);
+      const token1 = tokenMeta.get(position[3]) ?? toTokenMetaFallback(position[3]);
+      return {
+        tokenId: tokenId.toString(),
+        pair: `${token0.symbol}/${token1.symbol}`,
+        token0,
+        token1,
+        tickSpacing: position[4],
+        tickLower: position[5],
+        tickUpper: position[6],
+        liquidity: position[7].toString(),
+        tokensOwed0: {
+          raw: position[10].toString(),
+          decimal: formatUnits(position[10], token0.decimals)
+        },
+        tokensOwed1: {
+          raw: position[11].toString(),
+          decimal: formatUnits(position[11], token1.decimals)
+        }
+      };
+    });
+    return c.ok({
+      owner,
+      count: positions.length,
+      positions
+    });
+  }
+});
+cl.command("quote", {
+  description: "Quote a single-hop Slipstream swap via QuoterV2.",
+  args: z.object({
+    tokenIn: z.string().describe("Input token address"),
+    tokenOut: z.string().describe("Output token address"),
+    amountIn: z.string().describe("Input amount in human-readable decimal units")
+  }),
+  options: z.object({
+    fee: z.coerce.number().int().positive().optional().describe("Optional fee tier filter")
+  }),
+  env,
+  output: quoteOutputSchema,
+  async run(c) {
+    const { tokenIn, tokenOut, amountIn } = c.args;
+    if (!isAddress(tokenIn) || !isAddress(tokenOut)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: "tokenIn and tokenOut must both be valid 0x-prefixed 20-byte addresses."
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const inAddress = checksumAddress(tokenIn);
+    const outAddress = checksumAddress(tokenOut);
+    const allPools = await listPoolAddresses(client);
+    const poolStates = await readPoolStates(client, allPools);
+    const pairPools = poolStates.filter((pool) => {
+      const a = normalizeAddress(pool.token0);
+      const b = normalizeAddress(pool.token1);
+      const tokenInNorm = normalizeAddress(inAddress);
+      const tokenOutNorm = normalizeAddress(outAddress);
+      return a === tokenInNorm && b === tokenOutNorm || a === tokenOutNorm && b === tokenInNorm;
+    });
+    const filteredPools = typeof c.options.fee === "number" ? pairPools.filter((pool) => pool.fee === c.options.fee) : pairPools;
+    if (filteredPools.length === 0) {
+      return c.error({
+        code: "POOL_NOT_FOUND",
+        message: typeof c.options.fee === "number" ? `No Slipstream pool found for pair ${inAddress}/${outAddress} at fee tier ${c.options.fee}.` : `No Slipstream pool found for pair ${inAddress}/${outAddress}.`
+      });
+    }
+    const selectedPool = [...filteredPools].sort((a, b) => {
+      if (a.liquidity === b.liquidity) return 0;
+      return a.liquidity > b.liquidity ? -1 : 1;
+    })[0];
+    const tokenMeta = await readTokenMetadata(client, [inAddress, outAddress]);
+    const inMeta = tokenMeta.get(inAddress) ?? toTokenMetaFallback(inAddress);
+    const outMeta = tokenMeta.get(outAddress) ?? toTokenMetaFallback(outAddress);
+    let amountInRaw;
+    try {
+      amountInRaw = parseUnits(amountIn, inMeta.decimals);
+    } catch {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: `Invalid amountIn: "${amountIn}" for token ${inMeta.symbol} (${inMeta.decimals} decimals).`
+      });
+    }
+    const quote = await client.readContract({
+      abi: quoterV2Abi,
+      address: ABOREAN_CL_ADDRESSES.quoterV2,
+      functionName: "quoteExactInputSingle",
+      args: [
+        {
+          tokenIn: inAddress,
+          tokenOut: outAddress,
+          amountIn: amountInRaw,
+          tickSpacing: selectedPool.tickSpacing,
+          sqrtPriceLimitX96: 0n
+        }
+      ]
+    });
+    const amountOutRaw = quote[0];
+    const amountOutDecimal = formatUnits(amountOutRaw, outMeta.decimals);
+    const amountInDecimal = formatUnits(amountInRaw, inMeta.decimals);
+    const quotePriceOutPerIn = Number(amountInDecimal) === 0 ? null : finiteOrNull(Number(amountOutDecimal) / Number(amountInDecimal));
+    const poolTokenMeta = await readTokenMetadata(client, [
+      selectedPool.token0,
+      selectedPool.token1
+    ]);
+    const poolToken0Meta = poolTokenMeta.get(selectedPool.token0) ?? toTokenMetaFallback(selectedPool.token0);
+    const poolToken1Meta = poolTokenMeta.get(selectedPool.token1) ?? toTokenMetaFallback(selectedPool.token1);
+    const poolPrices = derivePrices(
+      selectedPool.slot0[0],
+      poolToken0Meta.decimals,
+      poolToken1Meta.decimals
+    );
+    const inIsToken0 = normalizeAddress(inAddress) === normalizeAddress(selectedPool.token0);
+    const poolMidPriceOutPerIn = inIsToken0 ? poolPrices.token1PerToken0 : poolPrices.token0PerToken1;
+    const priceImpactPct = quotePriceOutPerIn === null || poolMidPriceOutPerIn === null || poolMidPriceOutPerIn === 0 ? null : finiteOrNull((poolMidPriceOutPerIn - quotePriceOutPerIn) / poolMidPriceOutPerIn * 100);
+    return c.ok({
+      pool: checksumAddress(selectedPool.pool),
+      selectedFee: selectedPool.fee,
+      selectedTickSpacing: selectedPool.tickSpacing,
+      tokenIn: inMeta,
+      tokenOut: outMeta,
+      amountIn: {
+        raw: amountInRaw.toString(),
+        decimal: amountInDecimal
+      },
+      amountOut: {
+        raw: amountOutRaw.toString(),
+        decimal: amountOutDecimal
+      },
+      execution: {
+        sqrtPriceX96After: quote[1].toString(),
+        initializedTicksCrossed: quote[2],
+        gasEstimate: quote[3].toString()
+      },
+      prices: {
+        poolMidPriceOutPerIn,
+        quotePriceOutPerIn,
+        priceImpactPct
+      }
+    });
+  }
+});
+
+// src/commands/gauges.ts
+import { Cli as Cli2, z as z2 } from "incur";
+
+// src/commands/_common.ts
+import { checksumAddress as checksumAddress2, weiToEth } from "@spectratools/cli-shared";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function toChecksum(address) {
+  try {
+    return checksumAddress2(address);
+  } catch {
+    return address;
+  }
+}
+function asNum(value) {
+  return Number(value);
+}
+function relTime(unixSeconds) {
+  const ts = typeof unixSeconds === "bigint" ? Number(unixSeconds) : unixSeconds;
+  if (!Number.isFinite(ts) || ts <= 0) return "n/a";
+  const delta = ts - Math.floor(Date.now() / 1e3);
+  const abs = Math.abs(delta);
+  const hours = Math.floor(abs / 3600);
+  const minutes = Math.floor(abs % 3600 / 60);
+  const label = hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
+  return delta >= 0 ? `in ${label}` : `${label} ago`;
+}
+function clampPositive(seconds) {
+  return seconds > 0 ? seconds : 0;
+}
+
+// src/commands/gauges.ts
+var env2 = z2.object({
+  ABSTRACT_RPC_URL: z2.string().optional().describe("Abstract RPC URL override")
+});
+async function discoverGaugePools(client) {
+  const [v2PoolCount, clPoolCount] = await Promise.all([
+    client.readContract({
+      abi: poolFactoryAbi,
+      address: ABOREAN_V2_ADDRESSES.poolFactory,
+      functionName: "allPoolsLength"
+    }),
+    client.readContract({
+      abi: clFactoryAbi,
+      address: ABOREAN_CL_ADDRESSES.clFactory,
+      functionName: "allPoolsLength"
+    })
+  ]);
+  const v2Indices = Array.from({ length: asNum(v2PoolCount) }, (_, i) => BigInt(i));
+  const clIndices = Array.from({ length: asNum(clPoolCount) }, (_, i) => BigInt(i));
+  const [v2Pools, clPools] = await Promise.all([
+    v2Indices.length ? client.multicall({
+      allowFailure: false,
+      contracts: v2Indices.map((index) => ({
+        abi: poolFactoryAbi,
         address: ABOREAN_V2_ADDRESSES.poolFactory,
         functionName: "allPools",
         args: [index]
@@ -827,39 +1657,39 @@ async function discoverGaugePools(client) {
       }))
     }) : Promise.resolve([])
   ]);
-  const pools = [...v2Pools, ...clPools];
-  if (!pools.length) return [];
+  const pools2 = [...v2Pools, ...clPools];
+  if (!pools2.length) return [];
   const gauges2 = await client.multicall({
     allowFailure: false,
-    contracts: pools.map((pool) => ({
+    contracts: pools2.map((pool) => ({
       abi: voterAbi,
       address: ABOREAN_V2_ADDRESSES.voter,
       functionName: "gauges",
       args: [pool]
     }))
   });
-  return pools.map((pool, index) => ({ pool, gauge: gauges2[index] })).filter(({ gauge }) => gauge.toLowerCase() !== ZERO_ADDRESS.toLowerCase());
+  return pools2.map((pool, index) => ({ pool, gauge: gauges2[index] })).filter(({ gauge }) => gauge.toLowerCase() !== ZERO_ADDRESS.toLowerCase());
 }
-var gauges = Cli.create("gauges", {
+var gauges = Cli2.create("gauges", {
   description: "Inspect Aborean gauge emissions, staking, and user positions."
 });
 gauges.command("list", {
   description: "List active gauges with pool, emissions, and staking stats.",
-  env,
-  output: z.object({
-    gauges: z.array(
-      z.object({
-        pool: z.string(),
-        gauge: z.string(),
-        rewardToken: z.string(),
-        rewardRate: z.string(),
-        totalStaked: z.string(),
-        claimableEmissions: z.string(),
-        periodFinish: z.number(),
-        periodFinishRelative: z.string()
+  env: env2,
+  output: z2.object({
+    gauges: z2.array(
+      z2.object({
+        pool: z2.string(),
+        gauge: z2.string(),
+        rewardToken: z2.string(),
+        rewardRate: z2.string(),
+        totalStaked: z2.string(),
+        claimableEmissions: z2.string(),
+        periodFinish: z2.number(),
+        periodFinishRelative: z2.string()
       })
     ),
-    count: z.number()
+    count: z2.number()
   }),
   examples: [{ description: "List all active gauges and current emissions state" }],
   async run(c) {
@@ -925,27 +1755,27 @@ gauges.command("list", {
 });
 gauges.command("info", {
   description: "Get detailed state for one gauge address.",
-  args: z.object({
-    gauge: z.string().describe("Gauge contract address")
+  args: z2.object({
+    gauge: z2.string().describe("Gauge contract address")
   }),
-  env,
-  output: z.object({
-    gauge: z.string(),
-    pool: z.string(),
-    isAlive: z.boolean(),
-    stakingToken: z.string(),
-    rewardToken: z.string(),
-    totalStaked: z.string(),
-    rewardRate: z.string(),
-    rewardPerTokenStored: z.string(),
-    fees0: z.string(),
-    fees1: z.string(),
-    left: z.string(),
-    periodFinish: z.number(),
-    periodFinishRelative: z.string(),
-    lastUpdateTime: z.number(),
-    bribeContract: z.string(),
-    feeContract: z.string()
+  env: env2,
+  output: z2.object({
+    gauge: z2.string(),
+    pool: z2.string(),
+    isAlive: z2.boolean(),
+    stakingToken: z2.string(),
+    rewardToken: z2.string(),
+    totalStaked: z2.string(),
+    rewardRate: z2.string(),
+    rewardPerTokenStored: z2.string(),
+    fees0: z2.string(),
+    fees1: z2.string(),
+    left: z2.string(),
+    periodFinish: z2.number(),
+    periodFinishRelative: z2.string(),
+    lastUpdateTime: z2.number(),
+    bribeContract: z2.string(),
+    feeContract: z2.string()
   }),
   examples: [
     {
@@ -1067,111 +1897,1468 @@ gauges.command("info", {
     });
   }
 });
-gauges.command("staked", {
-  description: "Show one address staking positions across all gauges.",
-  args: z.object({
-    address: z.string().describe("Wallet address to inspect")
+gauges.command("staked", {
+  description: "Show one address staking positions across all gauges.",
+  args: z2.object({
+    address: z2.string().describe("Wallet address to inspect")
+  }),
+  env: env2,
+  output: z2.object({
+    address: z2.string(),
+    positions: z2.array(
+      z2.object({
+        pool: z2.string(),
+        gauge: z2.string(),
+        rewardToken: z2.string(),
+        staked: z2.string(),
+        earned: z2.string()
+      })
+    ),
+    count: z2.number()
+  }),
+  examples: [
+    {
+      args: { address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" },
+      description: "List gauge positions for a wallet"
+    }
+  ],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const gaugePools = await discoverGaugePools(client);
+    if (!gaugePools.length) {
+      return c.ok({
+        address: toChecksum(c.args.address),
+        positions: [],
+        count: 0
+      });
+    }
+    const positionData = await client.multicall({
+      allowFailure: false,
+      contracts: gaugePools.flatMap(({ gauge }) => [
+        {
+          abi: gaugeAbi,
+          address: gauge,
+          functionName: "balanceOf",
+          args: [c.args.address]
+        },
+        {
+          abi: gaugeAbi,
+          address: gauge,
+          functionName: "earned",
+          args: [c.args.address]
+        },
+        {
+          abi: gaugeAbi,
+          address: gauge,
+          functionName: "rewardToken"
+        }
+      ])
+    });
+    const positions = gaugePools.map(({ pool, gauge }, index) => {
+      const offset = index * 3;
+      const staked = positionData[offset];
+      const earned = positionData[offset + 1];
+      const rewardToken = positionData[offset + 2];
+      return {
+        pool: toChecksum(pool),
+        gauge: toChecksum(gauge),
+        rewardToken: toChecksum(rewardToken),
+        staked,
+        earned
+      };
+    }).filter((position) => position.staked > 0n || position.earned > 0n).map((position) => ({
+      pool: position.pool,
+      gauge: position.gauge,
+      rewardToken: position.rewardToken,
+      staked: position.staked.toString(),
+      earned: position.earned.toString()
+    }));
+    return c.ok({
+      address: toChecksum(c.args.address),
+      positions,
+      count: positions.length
+    });
+  }
+});
+
+// src/commands/lending.ts
+import { checksumAddress as checksumAddress3, isAddress as isAddress2 } from "@spectratools/cli-shared";
+import { Cli as Cli3, z as z3 } from "incur";
+import { formatUnits as formatUnits2 } from "viem";
+var MORPHO_DEPLOY_BLOCK = 13947713n;
+var env3 = z3.object({
+  ABSTRACT_RPC_URL: z3.string().optional().describe("Abstract RPC URL override")
+});
+var morphoAbi = [
+  {
+    type: "event",
+    name: "CreateMarket",
+    inputs: [
+      { type: "bytes32", name: "id", indexed: true },
+      {
+        type: "tuple",
+        name: "marketParams",
+        indexed: false,
+        components: [
+          { type: "address", name: "loanToken" },
+          { type: "address", name: "collateralToken" },
+          { type: "address", name: "oracle" },
+          { type: "address", name: "irm" },
+          { type: "uint256", name: "lltv" }
+        ]
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "function",
+    name: "idToMarketParams",
+    stateMutability: "view",
+    inputs: [{ type: "bytes32", name: "id" }],
+    outputs: [
+      { type: "address", name: "loanToken" },
+      { type: "address", name: "collateralToken" },
+      { type: "address", name: "oracle" },
+      { type: "address", name: "irm" },
+      { type: "uint256", name: "lltv" }
+    ]
+  },
+  {
+    type: "function",
+    name: "market",
+    stateMutability: "view",
+    inputs: [{ type: "bytes32", name: "id" }],
+    outputs: [
+      { type: "uint128", name: "totalSupplyAssets" },
+      { type: "uint128", name: "totalSupplyShares" },
+      { type: "uint128", name: "totalBorrowAssets" },
+      { type: "uint128", name: "totalBorrowShares" },
+      { type: "uint128", name: "lastUpdate" },
+      { type: "uint128", name: "fee" }
+    ]
+  },
+  {
+    type: "function",
+    name: "position",
+    stateMutability: "view",
+    inputs: [
+      { type: "bytes32", name: "id" },
+      { type: "address", name: "user" }
+    ],
+    outputs: [
+      { type: "uint256", name: "supplyShares" },
+      { type: "uint128", name: "borrowShares" },
+      { type: "uint128", name: "collateral" }
+    ]
+  }
+];
+var erc20MetadataAbi2 = [
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "string" }]
+  },
+  {
+    type: "function",
+    name: "decimals",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint8" }]
+  }
+];
+var tokenMetaSchema = z3.object({
+  address: z3.string(),
+  symbol: z3.string(),
+  decimals: z3.number()
+});
+var lendingMarketRowSchema = z3.object({
+  marketId: z3.string(),
+  loanToken: tokenMetaSchema,
+  collateralToken: tokenMetaSchema,
+  oracle: z3.string(),
+  irm: z3.string(),
+  lltvBps: z3.number(),
+  lltvPercent: z3.number(),
+  totalSupplyAssets: z3.string(),
+  totalBorrowAssets: z3.string(),
+  totalSupplyShares: z3.string(),
+  totalBorrowShares: z3.string(),
+  availableLiquidityAssets: z3.string(),
+  utilization: z3.number().nullable(),
+  feeWad: z3.string(),
+  lastUpdate: z3.number()
+});
+function isMarketId(value) {
+  return /^0x[0-9a-fA-F]{64}$/.test(value);
+}
+function shortAddress2(address) {
+  return `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
+}
+function finiteOrNull2(value) {
+  return Number.isFinite(value) ? value : null;
+}
+function sharesToAssets(shares, totalShares, totalAssets) {
+  if (shares === 0n || totalShares === 0n) return 0n;
+  return shares * totalAssets / totalShares;
+}
+function normalizeMarketParams(value) {
+  if (Array.isArray(value)) {
+    return {
+      loanToken: checksumAddress3(String(value[0])),
+      collateralToken: checksumAddress3(String(value[1])),
+      oracle: checksumAddress3(String(value[2])),
+      irm: checksumAddress3(String(value[3])),
+      lltv: BigInt(value[4])
+    };
+  }
+  if (typeof value !== "object" || value === null) {
+    throw new Error("invalid market params");
+  }
+  const v = value;
+  return {
+    loanToken: checksumAddress3(String(v.loanToken)),
+    collateralToken: checksumAddress3(String(v.collateralToken)),
+    oracle: checksumAddress3(String(v.oracle)),
+    irm: checksumAddress3(String(v.irm)),
+    lltv: BigInt(v.lltv)
+  };
+}
+function normalizeMarketState(value) {
+  if (Array.isArray(value)) {
+    return {
+      totalSupplyAssets: BigInt(value[0]),
+      totalSupplyShares: BigInt(value[1]),
+      totalBorrowAssets: BigInt(value[2]),
+      totalBorrowShares: BigInt(value[3]),
+      lastUpdate: BigInt(value[4]),
+      fee: BigInt(value[5])
+    };
+  }
+  if (typeof value !== "object" || value === null) {
+    throw new Error("invalid market state");
+  }
+  const v = value;
+  return {
+    totalSupplyAssets: BigInt(v.totalSupplyAssets),
+    totalSupplyShares: BigInt(v.totalSupplyShares),
+    totalBorrowAssets: BigInt(v.totalBorrowAssets),
+    totalBorrowShares: BigInt(v.totalBorrowShares),
+    lastUpdate: BigInt(v.lastUpdate),
+    fee: BigInt(v.fee)
+  };
+}
+function toMarketRow(marketId, params, state, tokenMeta) {
+  const loanMeta = tokenMeta.get(params.loanToken.toLowerCase()) ?? {
+    address: params.loanToken,
+    symbol: shortAddress2(params.loanToken),
+    decimals: 18
+  };
+  const collateralMeta = tokenMeta.get(params.collateralToken.toLowerCase()) ?? {
+    address: params.collateralToken,
+    symbol: shortAddress2(params.collateralToken),
+    decimals: 18
+  };
+  const utilization = state.totalSupplyAssets === 0n ? null : finiteOrNull2(Number(state.totalBorrowAssets) / Number(state.totalSupplyAssets));
+  const lltvPercent = Number(params.lltv) / 1e16;
+  return {
+    marketId,
+    loanToken: {
+      address: toChecksum(loanMeta.address),
+      symbol: loanMeta.symbol,
+      decimals: loanMeta.decimals
+    },
+    collateralToken: {
+      address: toChecksum(collateralMeta.address),
+      symbol: collateralMeta.symbol,
+      decimals: collateralMeta.decimals
+    },
+    oracle: toChecksum(params.oracle),
+    irm: toChecksum(params.irm),
+    lltvBps: Math.round(lltvPercent * 100),
+    lltvPercent,
+    totalSupplyAssets: state.totalSupplyAssets.toString(),
+    totalBorrowAssets: state.totalBorrowAssets.toString(),
+    totalSupplyShares: state.totalSupplyShares.toString(),
+    totalBorrowShares: state.totalBorrowShares.toString(),
+    availableLiquidityAssets: (state.totalSupplyAssets - state.totalBorrowAssets).toString(),
+    utilization,
+    feeWad: state.fee.toString(),
+    lastUpdate: asNum(state.lastUpdate)
+  };
+}
+async function readTokenMetadata2(client, addresses) {
+  const unique = [...new Set(addresses.map((address) => address.toLowerCase()))];
+  if (unique.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const contracts = unique.flatMap((address) => [
+    {
+      abi: erc20MetadataAbi2,
+      address,
+      functionName: "symbol"
+    },
+    {
+      abi: erc20MetadataAbi2,
+      address,
+      functionName: "decimals"
+    }
+  ]);
+  const results = await client.multicall({
+    allowFailure: true,
+    contracts
+  });
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < unique.length; i += 1) {
+    const address = unique[i];
+    const symbolResult = results[i * 2];
+    const decimalsResult = results[i * 2 + 1];
+    const symbol = symbolResult && symbolResult.status === "success" && typeof symbolResult.result === "string" ? symbolResult.result : shortAddress2(address);
+    const decimals = decimalsResult && decimalsResult.status === "success" && typeof decimalsResult.result === "number" ? decimalsResult.result : 18;
+    map.set(address.toLowerCase(), {
+      address: checksumAddress3(address),
+      symbol,
+      decimals
+    });
+  }
+  return map;
+}
+async function discoverMarketIds(client) {
+  const logs = await client.getContractEvents({
+    address: ABOREAN_LENDING_ADDRESSES.morphoBlue,
+    abi: morphoAbi,
+    eventName: "CreateMarket",
+    fromBlock: MORPHO_DEPLOY_BLOCK,
+    toBlock: "latest"
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const ids = [];
+  for (const log of logs) {
+    const id = log.args.id;
+    if (!id) continue;
+    const key = id.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    ids.push(id);
+  }
+  return ids;
+}
+async function readMarkets(client, marketIds) {
+  if (marketIds.length === 0) return [];
+  const contracts = marketIds.flatMap((marketId) => [
+    {
+      abi: morphoAbi,
+      address: ABOREAN_LENDING_ADDRESSES.morphoBlue,
+      functionName: "idToMarketParams",
+      args: [marketId]
+    },
+    {
+      abi: morphoAbi,
+      address: ABOREAN_LENDING_ADDRESSES.morphoBlue,
+      functionName: "market",
+      args: [marketId]
+    }
+  ]);
+  const values = await client.multicall({
+    allowFailure: false,
+    contracts
+  });
+  return marketIds.map((marketId, index) => {
+    const paramsValue = values[index * 2];
+    const stateValue = values[index * 2 + 1];
+    return {
+      marketId,
+      params: normalizeMarketParams(paramsValue),
+      state: normalizeMarketState(stateValue)
+    };
+  });
+}
+function summarizeByLoanToken(markets, tokenMeta) {
+  const byLoanToken = /* @__PURE__ */ new Map();
+  for (const { params, state } of markets) {
+    const key = params.loanToken.toLowerCase();
+    const prev = byLoanToken.get(key);
+    if (prev) {
+      prev.totalSupply += state.totalSupplyAssets;
+      prev.totalBorrow += state.totalBorrowAssets;
+      continue;
+    }
+    byLoanToken.set(key, {
+      token: params.loanToken,
+      totalSupply: state.totalSupplyAssets,
+      totalBorrow: state.totalBorrowAssets
+    });
+  }
+  return [...byLoanToken.values()].map((entry) => {
+    const meta = tokenMeta.get(entry.token.toLowerCase()) ?? {
+      address: entry.token,
+      symbol: shortAddress2(entry.token),
+      decimals: 18
+    };
+    return {
+      token: toChecksum(entry.token),
+      symbol: meta.symbol,
+      decimals: meta.decimals,
+      totalSupplyAssets: entry.totalSupply.toString(),
+      totalBorrowAssets: entry.totalBorrow.toString()
+    };
+  });
+}
+async function readLendingSummary(client) {
+  const marketIds = await discoverMarketIds(client);
+  const markets = await readMarkets(client, marketIds);
+  const tokenMeta = await readTokenMetadata2(
+    client,
+    markets.flatMap((market) => [market.params.loanToken, market.params.collateralToken])
+  );
+  return {
+    available: true,
+    morpho: toChecksum(ABOREAN_LENDING_ADDRESSES.morphoBlue),
+    marketCount: marketIds.length,
+    supplyByLoanToken: summarizeByLoanToken(markets, tokenMeta)
+  };
+}
+var lending = Cli3.create("lending", {
+  description: "Inspect Morpho lending markets on Abstract."
+});
+lending.command("markets", {
+  description: "List Morpho markets discovered from CreateMarket events.",
+  args: z3.object({
+    limit: z3.coerce.number().int().positive().max(200).default(25).describe("Max markets to return")
+  }),
+  env: env3,
+  output: z3.object({
+    morpho: z3.string(),
+    marketCount: z3.number(),
+    markets: z3.array(lendingMarketRowSchema),
+    totalsByLoanToken: z3.array(
+      z3.object({
+        token: z3.string(),
+        symbol: z3.string(),
+        decimals: z3.number(),
+        totalSupplyAssets: z3.string(),
+        totalBorrowAssets: z3.string()
+      })
+    )
+  }),
+  examples: [{ description: "List active Morpho markets on Abstract" }],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const marketIds = await discoverMarketIds(client);
+    const markets = await readMarkets(client, marketIds);
+    const tokenMeta = await readTokenMetadata2(
+      client,
+      markets.flatMap((market) => [market.params.loanToken, market.params.collateralToken])
+    );
+    const rows = markets.map((market) => toMarketRow(market.marketId, market.params, market.state, tokenMeta)).sort(
+      (a, b) => BigInt(a.totalSupplyAssets) > BigInt(b.totalSupplyAssets) ? -1 : BigInt(a.totalSupplyAssets) < BigInt(b.totalSupplyAssets) ? 1 : 0
+    ).slice(0, c.args.limit);
+    return c.ok({
+      morpho: toChecksum(ABOREAN_LENDING_ADDRESSES.morphoBlue),
+      marketCount: marketIds.length,
+      markets: rows,
+      totalsByLoanToken: summarizeByLoanToken(markets, tokenMeta)
+    });
+  }
+});
+lending.command("market", {
+  description: "Get details for one Morpho market id (bytes32).",
+  args: z3.object({
+    marketId: z3.string().describe("Morpho market id (bytes32 hex)")
+  }),
+  env: env3,
+  output: lendingMarketRowSchema,
+  examples: [
+    {
+      args: { marketId: "0xfe1d7da2fbde85b1fee120c88df3e6b55164a2442dab97486d3d4f719a5ff1fb" },
+      description: "Inspect one Morpho market by id"
+    }
+  ],
+  async run(c) {
+    if (!isMarketId(c.args.marketId)) {
+      return c.error({
+        code: "INVALID_ARGUMENT",
+        message: "marketId must be a 32-byte hex string (0x + 64 hex chars)"
+      });
+    }
+    const marketId = c.args.marketId;
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const [paramsRaw, stateRaw] = await Promise.all([
+      client.readContract({
+        abi: morphoAbi,
+        address: ABOREAN_LENDING_ADDRESSES.morphoBlue,
+        functionName: "idToMarketParams",
+        args: [marketId]
+      }),
+      client.readContract({
+        abi: morphoAbi,
+        address: ABOREAN_LENDING_ADDRESSES.morphoBlue,
+        functionName: "market",
+        args: [marketId]
+      })
+    ]);
+    const params = normalizeMarketParams(paramsRaw);
+    const state = normalizeMarketState(stateRaw);
+    const tokenMeta = await readTokenMetadata2(client, [params.loanToken, params.collateralToken]);
+    return c.ok(toMarketRow(marketId, params, state, tokenMeta));
+  }
+});
+lending.command("position", {
+  description: "Inspect one user position in a Morpho market.",
+  args: z3.object({
+    marketId: z3.string().describe("Morpho market id (bytes32 hex)"),
+    user: z3.string().describe("Position owner address")
+  }),
+  env: env3,
+  output: z3.object({
+    marketId: z3.string(),
+    user: z3.string(),
+    loanToken: tokenMetaSchema,
+    collateralToken: tokenMetaSchema,
+    supplyShares: z3.string(),
+    supplyAssetsEstimate: z3.object({
+      raw: z3.string(),
+      decimal: z3.string()
+    }),
+    borrowShares: z3.string(),
+    borrowAssetsEstimate: z3.object({
+      raw: z3.string(),
+      decimal: z3.string()
+    }),
+    collateralAssets: z3.object({
+      raw: z3.string(),
+      decimal: z3.string()
+    })
+  }),
+  examples: [
+    {
+      args: {
+        marketId: "0xfe1d7da2fbde85b1fee120c88df3e6b55164a2442dab97486d3d4f719a5ff1fb",
+        user: "0x0000000000000000000000000000000000000000"
+      },
+      description: "Inspect one user position in a market"
+    }
+  ],
+  async run(c) {
+    if (!isMarketId(c.args.marketId)) {
+      return c.error({
+        code: "INVALID_ARGUMENT",
+        message: "marketId must be a 32-byte hex string (0x + 64 hex chars)"
+      });
+    }
+    if (!isAddress2(c.args.user)) {
+      return c.error({
+        code: "INVALID_ARGUMENT",
+        message: "user must be a valid address"
+      });
+    }
+    const marketId = c.args.marketId;
+    const user = checksumAddress3(c.args.user);
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const [paramsRaw, stateRaw, positionRaw] = await Promise.all([
+      client.readContract({
+        abi: morphoAbi,
+        address: ABOREAN_LENDING_ADDRESSES.morphoBlue,
+        functionName: "idToMarketParams",
+        args: [marketId]
+      }),
+      client.readContract({
+        abi: morphoAbi,
+        address: ABOREAN_LENDING_ADDRESSES.morphoBlue,
+        functionName: "market",
+        args: [marketId]
+      }),
+      client.readContract({
+        abi: morphoAbi,
+        address: ABOREAN_LENDING_ADDRESSES.morphoBlue,
+        functionName: "position",
+        args: [marketId, user]
+      })
+    ]);
+    const params = normalizeMarketParams(paramsRaw);
+    const state = normalizeMarketState(stateRaw);
+    const position = Array.isArray(positionRaw) ? {
+      supplyShares: BigInt(positionRaw[0]),
+      borrowShares: BigInt(positionRaw[1]),
+      collateral: BigInt(positionRaw[2])
+    } : {
+      supplyShares: BigInt(positionRaw.supplyShares),
+      borrowShares: BigInt(positionRaw.borrowShares),
+      collateral: BigInt(positionRaw.collateral)
+    };
+    const tokenMeta = await readTokenMetadata2(client, [params.loanToken, params.collateralToken]);
+    const loanMeta = tokenMeta.get(params.loanToken.toLowerCase()) ?? {
+      address: params.loanToken,
+      symbol: shortAddress2(params.loanToken),
+      decimals: 18
+    };
+    const collateralMeta = tokenMeta.get(params.collateralToken.toLowerCase()) ?? {
+      address: params.collateralToken,
+      symbol: shortAddress2(params.collateralToken),
+      decimals: 18
+    };
+    const supplyAssetsEstimate = sharesToAssets(
+      BigInt(position.supplyShares),
+      state.totalSupplyShares,
+      state.totalSupplyAssets
+    );
+    const borrowAssetsEstimate = sharesToAssets(
+      BigInt(position.borrowShares),
+      state.totalBorrowShares,
+      state.totalBorrowAssets
+    );
+    return c.ok({
+      marketId,
+      user: toChecksum(user),
+      loanToken: {
+        address: toChecksum(loanMeta.address),
+        symbol: loanMeta.symbol,
+        decimals: loanMeta.decimals
+      },
+      collateralToken: {
+        address: toChecksum(collateralMeta.address),
+        symbol: collateralMeta.symbol,
+        decimals: collateralMeta.decimals
+      },
+      supplyShares: position.supplyShares.toString(),
+      supplyAssetsEstimate: {
+        raw: supplyAssetsEstimate.toString(),
+        decimal: formatUnits2(supplyAssetsEstimate, loanMeta.decimals)
+      },
+      borrowShares: position.borrowShares.toString(),
+      borrowAssetsEstimate: {
+        raw: borrowAssetsEstimate.toString(),
+        decimal: formatUnits2(borrowAssetsEstimate, loanMeta.decimals)
+      },
+      collateralAssets: {
+        raw: position.collateral.toString(),
+        decimal: formatUnits2(BigInt(position.collateral), collateralMeta.decimals)
+      }
+    });
+  }
+});
+
+// src/commands/pools.ts
+import { checksumAddress as checksumAddress4, isAddress as isAddress3 } from "@spectratools/cli-shared";
+import { Cli as Cli4, z as z4 } from "incur";
+import { formatUnits as formatUnits3, parseUnits as parseUnits2 } from "viem";
+var MULTICALL_BATCH_SIZE2 = 100;
+var env4 = z4.object({
+  ABSTRACT_RPC_URL: z4.string().optional().describe("Abstract RPC URL override")
+});
+var tokenSchema2 = z4.object({
+  address: z4.string(),
+  symbol: z4.string(),
+  decimals: z4.number()
+});
+var amountSchema = z4.object({
+  raw: z4.string(),
+  decimal: z4.string()
+});
+var feeSchema = z4.object({
+  feeBps: z4.number(),
+  feePercent: z4.number()
+}).nullable();
+var poolSummarySchema = z4.object({
+  pool: z4.string(),
+  pair: z4.string(),
+  stable: z4.boolean(),
+  poolType: z4.enum(["stable", "volatile"]),
+  token0: tokenSchema2,
+  token1: tokenSchema2,
+  reserves: z4.object({
+    token0: amountSchema,
+    token1: amountSchema,
+    blockTimestampLast: z4.number()
+  }),
+  totalSupply: z4.string(),
+  fee: feeSchema
+});
+var erc20MetadataAbi3 = [
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "string" }]
+  },
+  {
+    type: "function",
+    name: "decimals",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint8" }]
+  }
+];
+function shortAddress3(address) {
+  return `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
+}
+function toAddress(address) {
+  return checksumAddress4(address);
+}
+function finiteOrNull3(value) {
+  return Number.isFinite(value) ? value : null;
+}
+function toFeeInfo(value) {
+  if (value === null) return null;
+  const feeBps = Number(value);
+  return {
+    feeBps,
+    feePercent: feeBps / 1e4
+  };
+}
+function chunk2(items, size) {
+  const output = [];
+  for (let i = 0; i < items.length; i += size) {
+    output.push(items.slice(i, i + size));
+  }
+  return output;
+}
+async function multicallStrict2(client, contracts) {
+  if (contracts.length === 0) return [];
+  const batches = chunk2(contracts, MULTICALL_BATCH_SIZE2);
+  const output = [];
+  for (const batch of batches) {
+    const values = await client.multicall({
+      allowFailure: false,
+      contracts: batch
+    });
+    output.push(...values);
+  }
+  return output;
+}
+async function multicallAllowFailure2(client, contracts) {
+  if (contracts.length === 0) return [];
+  const batches = chunk2(contracts, MULTICALL_BATCH_SIZE2);
+  const output = [];
+  for (const batch of batches) {
+    const values = await client.multicall({
+      allowFailure: true,
+      contracts: batch
+    });
+    output.push(...values);
+  }
+  return output;
+}
+function fallbackTokenMeta(address) {
+  const checksummed = checksumAddress4(address);
+  return {
+    address: checksummed,
+    symbol: shortAddress3(checksummed),
+    decimals: 18
+  };
+}
+async function readTokenMetadata3(client, tokenAddresses) {
+  const unique = [
+    ...new Set(tokenAddresses.map((address) => checksumAddress4(address).toLowerCase()))
+  ];
+  if (unique.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const contracts = unique.flatMap((address) => [
+    {
+      abi: erc20MetadataAbi3,
+      address,
+      functionName: "symbol"
+    },
+    {
+      abi: erc20MetadataAbi3,
+      address,
+      functionName: "decimals"
+    }
+  ]);
+  const values = await multicallAllowFailure2(client, contracts);
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < unique.length; i += 1) {
+    const address = unique[i];
+    const symbolResult = values[i * 2];
+    const decimalsResult = values[i * 2 + 1];
+    const fallback = fallbackTokenMeta(address);
+    const symbol = symbolResult && symbolResult.status === "success" && typeof symbolResult.result === "string" ? symbolResult.result : fallback.symbol;
+    const decimals = decimalsResult && decimalsResult.status === "success" && typeof decimalsResult.result === "number" ? decimalsResult.result : fallback.decimals;
+    map.set(address.toLowerCase(), {
+      address: checksumAddress4(address),
+      symbol,
+      decimals
+    });
+  }
+  return map;
+}
+async function readPoolStates2(client, pools2) {
+  if (pools2.length === 0) {
+    return [];
+  }
+  const contracts = pools2.flatMap((pool) => [
+    {
+      abi: v2PoolAbi,
+      address: pool,
+      functionName: "token0"
+    },
+    {
+      abi: v2PoolAbi,
+      address: pool,
+      functionName: "token1"
+    },
+    {
+      abi: v2PoolAbi,
+      address: pool,
+      functionName: "stable"
+    },
+    {
+      abi: v2PoolAbi,
+      address: pool,
+      functionName: "getReserves"
+    },
+    {
+      abi: v2PoolAbi,
+      address: pool,
+      functionName: "totalSupply"
+    }
+  ]);
+  const values = await multicallStrict2(client, contracts);
+  return pools2.map((pool, index) => {
+    const offset = index * 5;
+    const reserves = values[offset + 3];
+    return {
+      pool,
+      token0: values[offset],
+      token1: values[offset + 1],
+      stable: values[offset + 2],
+      reserve0: reserves[0],
+      reserve1: reserves[1],
+      blockTimestampLast: reserves[2],
+      totalSupply: values[offset + 4]
+    };
+  });
+}
+async function readPoolFees(client, pools2) {
+  if (pools2.length === 0) {
+    return [];
+  }
+  const contracts = pools2.map(({ pool, stable }) => ({
+    abi: poolFactoryAbi,
+    address: ABOREAN_V2_ADDRESSES.poolFactory,
+    functionName: "getFee",
+    args: [pool, stable]
+  }));
+  const values = await multicallAllowFailure2(client, contracts);
+  return values.map(
+    (value) => value.status === "success" && typeof value.result === "bigint" ? value.result : null
+  );
+}
+function toAmount(raw, decimals) {
+  return {
+    raw: raw.toString(),
+    decimal: formatUnits3(raw, decimals)
+  };
+}
+function toPoolSummary(state, tokens, fee) {
+  const token0 = tokens.get(state.token0.toLowerCase()) ?? fallbackTokenMeta(state.token0);
+  const token1 = tokens.get(state.token1.toLowerCase()) ?? fallbackTokenMeta(state.token1);
+  return {
+    pool: checksumAddress4(state.pool),
+    pair: `${token0.symbol}/${token1.symbol}`,
+    stable: state.stable,
+    poolType: state.stable ? "stable" : "volatile",
+    token0,
+    token1,
+    reserves: {
+      token0: toAmount(state.reserve0, token0.decimals),
+      token1: toAmount(state.reserve1, token1.decimals),
+      blockTimestampLast: Number(state.blockTimestampLast)
+    },
+    totalSupply: state.totalSupply.toString(),
+    fee: toFeeInfo(fee)
+  };
+}
+var pools = Cli4.create("pools", {
+  description: "Inspect V2 AMM pools, reserves, quotes, and fee configuration."
+});
+pools.command("list", {
+  description: "List V2 pools with token pairs, reserves, and stable/volatile type.",
+  options: z4.object({
+    offset: z4.coerce.number().int().nonnegative().default(0).describe("Pool index offset"),
+    limit: z4.coerce.number().int().positive().max(500).default(50).describe("Maximum pools to return (max 500)")
+  }),
+  env: env4,
+  output: z4.object({
+    total: z4.number(),
+    offset: z4.number(),
+    limit: z4.number(),
+    count: z4.number(),
+    pools: z4.array(poolSummarySchema)
+  }),
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const totalRaw = await client.readContract({
+      abi: poolFactoryAbi,
+      address: ABOREAN_V2_ADDRESSES.poolFactory,
+      functionName: "allPoolsLength"
+    });
+    const total = Number(totalRaw);
+    const offset = Math.min(c.options.offset, total);
+    const end = Math.min(total, offset + c.options.limit);
+    if (offset >= end) {
+      return c.ok({
+        total,
+        offset,
+        limit: c.options.limit,
+        count: 0,
+        pools: []
+      });
+    }
+    const indices = Array.from({ length: end - offset }, (_, i) => BigInt(offset + i));
+    const poolAddresses = await multicallStrict2(
+      client,
+      indices.map((index) => ({
+        abi: poolFactoryAbi,
+        address: ABOREAN_V2_ADDRESSES.poolFactory,
+        functionName: "allPools",
+        args: [index]
+      }))
+    );
+    const poolStates = await readPoolStates2(client, poolAddresses);
+    const tokenMeta = await readTokenMetadata3(
+      client,
+      poolStates.flatMap((pool) => [pool.token0, pool.token1])
+    );
+    const fees = await readPoolFees(
+      client,
+      poolStates.map((pool) => ({ pool: pool.pool, stable: pool.stable }))
+    );
+    return c.ok({
+      total,
+      offset,
+      limit: c.options.limit,
+      count: poolStates.length,
+      pools: poolStates.map((pool, index) => toPoolSummary(pool, tokenMeta, fees[index] ?? null))
+    });
+  }
+});
+pools.command("pool", {
+  description: "Get detailed state for one V2 pool.",
+  args: z4.object({
+    address: z4.string().describe("Pool address")
+  }),
+  env: env4,
+  output: z4.object({
+    pool: poolSummarySchema.extend({
+      poolFees: z4.string(),
+      factory: z4.string()
+    })
+  }),
+  async run(c) {
+    if (!isAddress3(c.args.address)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: `Invalid pool address: "${c.args.address}". Use a valid 0x-prefixed 20-byte hex address.`
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const poolAddress = toAddress(c.args.address);
+    const [token0, token1, stable, reserves, totalSupply, poolFees, factory] = await multicallStrict2(client, [
+      {
+        abi: v2PoolAbi,
+        address: poolAddress,
+        functionName: "token0"
+      },
+      {
+        abi: v2PoolAbi,
+        address: poolAddress,
+        functionName: "token1"
+      },
+      {
+        abi: v2PoolAbi,
+        address: poolAddress,
+        functionName: "stable"
+      },
+      {
+        abi: v2PoolAbi,
+        address: poolAddress,
+        functionName: "getReserves"
+      },
+      {
+        abi: v2PoolAbi,
+        address: poolAddress,
+        functionName: "totalSupply"
+      },
+      {
+        abi: v2PoolAbi,
+        address: poolAddress,
+        functionName: "poolFees"
+      },
+      {
+        abi: v2PoolAbi,
+        address: poolAddress,
+        functionName: "factory"
+      }
+    ]);
+    const tokenMeta = await readTokenMetadata3(client, [token0, token1]);
+    const [fee] = await readPoolFees(client, [{ pool: poolAddress, stable }]);
+    return c.ok({
+      pool: {
+        ...toPoolSummary(
+          {
+            pool: poolAddress,
+            token0,
+            token1,
+            stable,
+            reserve0: reserves[0],
+            reserve1: reserves[1],
+            blockTimestampLast: reserves[2],
+            totalSupply
+          },
+          tokenMeta,
+          fee ?? null
+        ),
+        poolFees: checksumAddress4(poolFees),
+        factory: checksumAddress4(factory)
+      }
+    });
+  }
+});
+pools.command("quote", {
+  description: "Quote a single-hop V2 swap between tokenIn and tokenOut.",
+  args: z4.object({
+    tokenIn: z4.string().describe("Input token address"),
+    tokenOut: z4.string().describe("Output token address"),
+    amountIn: z4.string().describe("Input amount in human-readable decimal units")
+  }),
+  options: z4.object({
+    stable: z4.boolean().default(false).describe("Use stable pool route (default: volatile)")
+  }),
+  env: env4,
+  output: z4.object({
+    pool: z4.string(),
+    stable: z4.boolean(),
+    tokenIn: tokenSchema2,
+    tokenOut: tokenSchema2,
+    amountIn: amountSchema,
+    amountOut: amountSchema,
+    priceOutPerIn: z4.number().nullable()
+  }),
+  async run(c) {
+    if (!isAddress3(c.args.tokenIn) || !isAddress3(c.args.tokenOut)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: "tokenIn and tokenOut must both be valid 0x-prefixed 20-byte addresses."
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const tokenIn = toAddress(c.args.tokenIn);
+    const tokenOut = toAddress(c.args.tokenOut);
+    const tokenMeta = await readTokenMetadata3(client, [tokenIn, tokenOut]);
+    const inMeta = tokenMeta.get(tokenIn.toLowerCase()) ?? fallbackTokenMeta(tokenIn);
+    const outMeta = tokenMeta.get(tokenOut.toLowerCase()) ?? fallbackTokenMeta(tokenOut);
+    let amountInRaw;
+    try {
+      amountInRaw = parseUnits2(c.args.amountIn, inMeta.decimals);
+    } catch {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: `Invalid amountIn: "${c.args.amountIn}" for token ${inMeta.symbol} (${inMeta.decimals} decimals).`
+      });
+    }
+    const poolAddress = await client.readContract({
+      abi: poolFactoryAbi,
+      address: ABOREAN_V2_ADDRESSES.poolFactory,
+      functionName: "getPool",
+      args: [tokenIn, tokenOut, c.options.stable]
+    });
+    if (poolAddress.toLowerCase() === ZERO_ADDRESS.toLowerCase()) {
+      return c.error({
+        code: "POOL_NOT_FOUND",
+        message: `No ${c.options.stable ? "stable" : "volatile"} V2 pool found for pair ${checksumAddress4(
+          tokenIn
+        )}/${checksumAddress4(tokenOut)}.`
+      });
+    }
+    const amounts = await client.readContract({
+      abi: v2RouterAbi,
+      address: ABOREAN_V2_ADDRESSES.router,
+      functionName: "getAmountsOut",
+      args: [
+        amountInRaw,
+        [
+          {
+            from: tokenIn,
+            to: tokenOut,
+            stable: c.options.stable,
+            factory: ABOREAN_V2_ADDRESSES.poolFactory
+          }
+        ]
+      ]
+    });
+    const amountOutRaw = amounts[amounts.length - 1] ?? 0n;
+    const amountInDecimal = formatUnits3(amountInRaw, inMeta.decimals);
+    const amountOutDecimal = formatUnits3(amountOutRaw, outMeta.decimals);
+    const ratio = Number(amountOutDecimal) / Number(amountInDecimal);
+    return c.ok({
+      pool: checksumAddress4(poolAddress),
+      stable: c.options.stable,
+      tokenIn: inMeta,
+      tokenOut: outMeta,
+      amountIn: {
+        raw: amountInRaw.toString(),
+        decimal: amountInDecimal
+      },
+      amountOut: {
+        raw: amountOutRaw.toString(),
+        decimal: amountOutDecimal
+      },
+      priceOutPerIn: Number(amountInDecimal) === 0 ? null : finiteOrNull3(ratio)
+    });
+  }
+});
+pools.command("fees", {
+  description: "Read V2 fee configuration for a pool address.",
+  args: z4.object({
+    pool: z4.string().describe("Pool address")
+  }),
+  env: env4,
+  output: z4.object({
+    pool: z4.string(),
+    pair: z4.string(),
+    stable: z4.boolean(),
+    activeFee: feeSchema,
+    stableFee: feeSchema,
+    volatileFee: feeSchema
+  }),
+  async run(c) {
+    if (!isAddress3(c.args.pool)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: `Invalid pool address: "${c.args.pool}". Use a valid 0x-prefixed 20-byte hex address.`
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const pool = toAddress(c.args.pool);
+    const [token0, token1, stable] = await multicallStrict2(client, [
+      {
+        abi: v2PoolAbi,
+        address: pool,
+        functionName: "token0"
+      },
+      {
+        abi: v2PoolAbi,
+        address: pool,
+        functionName: "token1"
+      },
+      {
+        abi: v2PoolAbi,
+        address: pool,
+        functionName: "stable"
+      }
+    ]);
+    const tokenMeta = await readTokenMetadata3(client, [token0, token1]);
+    const token0Meta = tokenMeta.get(token0.toLowerCase()) ?? fallbackTokenMeta(token0);
+    const token1Meta = tokenMeta.get(token1.toLowerCase()) ?? fallbackTokenMeta(token1);
+    const [stableFeeRaw, volatileFeeRaw] = await readPoolFees(client, [
+      { pool, stable: true },
+      { pool, stable: false }
+    ]);
+    const stableFee = toFeeInfo(stableFeeRaw ?? null);
+    const volatileFee = toFeeInfo(volatileFeeRaw ?? null);
+    return c.ok({
+      pool: checksumAddress4(pool),
+      pair: `${token0Meta.symbol}/${token1Meta.symbol}`,
+      stable,
+      activeFee: stable ? stableFee : volatileFee,
+      stableFee,
+      volatileFee
+    });
+  }
+});
+
+// src/commands/vaults.ts
+import { checksumAddress as checksumAddress5, isAddress as isAddress4 } from "@spectratools/cli-shared";
+import { Cli as Cli5, z as z5 } from "incur";
+var env5 = z5.object({
+  ABSTRACT_RPC_URL: z5.string().optional().describe("Abstract RPC URL override")
+});
+var relayAbi = [
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "string" }]
+  },
+  {
+    type: "function",
+    name: "mTokenId",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "token",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "address" }]
+  },
+  {
+    type: "function",
+    name: "keeperLastRun",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  }
+];
+var erc20Abi = [
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "string" }]
+  },
+  {
+    type: "function",
+    name: "decimals",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint8" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ type: "address", name: "owner" }],
+    outputs: [{ type: "uint256" }]
+  }
+];
+var votingEscrowLiteAbi = [
+  {
+    type: "function",
+    name: "balanceOfNFT",
+    stateMutability: "view",
+    inputs: [{ type: "uint256", name: "tokenId" }],
+    outputs: [{ type: "uint256" }]
+  }
+];
+var relayRowSchema = z5.object({
+  label: z5.string(),
+  relay: z5.string(),
+  name: z5.string(),
+  factoryType: z5.enum(["autoCompounder", "autoConverter"]),
+  managedTokenId: z5.string(),
+  managedVotingPower: z5.string(),
+  relayToken: z5.object({
+    address: z5.string(),
+    symbol: z5.string(),
+    decimals: z5.number()
+  }),
+  relayTokenBalance: z5.string(),
+  keeperLastRun: z5.number(),
+  keeperLastRunRelative: z5.string(),
+  secondsSinceKeeperRun: z5.number()
+});
+var KNOWN_RELAYS = [
+  {
+    label: "veABX Maxi Relay",
+    relay: checksumAddress5(ABOREAN_VAULT_ADDRESSES.veAbxMaxiRelay),
+    factoryType: "autoCompounder"
+  },
+  {
+    label: "ABX Rewards Relay",
+    relay: checksumAddress5(ABOREAN_VAULT_ADDRESSES.abxRewardsRelay),
+    factoryType: "autoConverter"
+  }
+];
+function shortAddress4(address) {
+  return `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
+}
+async function readRelaySnapshot(client, relay) {
+  const [name, managedTokenId, relayTokenAddress, keeperLastRun] = await Promise.all([
+    client.readContract({
+      abi: relayAbi,
+      address: relay.relay,
+      functionName: "name"
+    }),
+    client.readContract({
+      abi: relayAbi,
+      address: relay.relay,
+      functionName: "mTokenId"
+    }),
+    client.readContract({
+      abi: relayAbi,
+      address: relay.relay,
+      functionName: "token"
+    }),
+    client.readContract({
+      abi: relayAbi,
+      address: relay.relay,
+      functionName: "keeperLastRun"
+    })
+  ]);
+  const tokenAddress = checksumAddress5(relayTokenAddress);
+  const [symbol, decimals, relayTokenBalance, managedVotingPower] = await Promise.all([
+    client.readContract({
+      abi: erc20Abi,
+      address: tokenAddress,
+      functionName: "symbol"
+    }),
+    client.readContract({
+      abi: erc20Abi,
+      address: tokenAddress,
+      functionName: "decimals"
+    }),
+    client.readContract({
+      abi: erc20Abi,
+      address: tokenAddress,
+      functionName: "balanceOf",
+      args: [relay.relay]
+    }),
+    client.readContract({
+      abi: votingEscrowLiteAbi,
+      address: ABOREAN_V2_ADDRESSES.votingEscrow,
+      functionName: "balanceOfNFT",
+      args: [managedTokenId]
+    })
+  ]);
+  const keeperTs = asNum(keeperLastRun);
+  const now = Math.floor(Date.now() / 1e3);
+  return {
+    label: relay.label,
+    relay: toChecksum(relay.relay),
+    name,
+    factoryType: relay.factoryType,
+    managedTokenId: managedTokenId.toString(),
+    managedVotingPower: managedVotingPower.toString(),
+    relayToken: {
+      address: toChecksum(tokenAddress),
+      symbol,
+      decimals
+    },
+    relayTokenBalance: relayTokenBalance.toString(),
+    keeperLastRun: keeperTs,
+    keeperLastRunRelative: relTime(keeperLastRun),
+    secondsSinceKeeperRun: Math.max(0, now - keeperTs)
+  };
+}
+async function readVaultSummary(client) {
+  const relays = await Promise.all(KNOWN_RELAYS.map((relay) => readRelaySnapshot(client, relay)));
+  const tokenTotals = /* @__PURE__ */ new Map();
+  let managedVotingPowerTotal = 0n;
+  for (const relay of relays) {
+    managedVotingPowerTotal += BigInt(relay.managedVotingPower);
+    const key = relay.relayToken.address.toLowerCase();
+    const prev = tokenTotals.get(key);
+    const balance = BigInt(relay.relayTokenBalance);
+    if (prev) {
+      prev.balance += balance;
+      continue;
+    }
+    tokenTotals.set(key, {
+      token: relay.relayToken.address,
+      symbol: relay.relayToken.symbol,
+      decimals: relay.relayToken.decimals,
+      balance
+    });
+  }
+  const relayTokenBalances = [...tokenTotals.values()].map((row) => ({
+    token: row.token,
+    symbol: row.symbol,
+    decimals: row.decimals,
+    balance: row.balance.toString()
+  }));
+  return {
+    relayCount: relays.length,
+    relays,
+    totals: {
+      managedVotingPower: managedVotingPowerTotal.toString(),
+      relayTokenBalances
+    }
+  };
+}
+var vaults = Cli5.create("vaults", {
+  description: "Inspect Aborean relay vaults (auto-compounder / auto-converter)."
+});
+vaults.command("list", {
+  description: "List known Aborean relay vaults with keeper and veNFT state.",
+  env: env5,
+  output: z5.object({
+    relayCount: z5.number(),
+    relays: z5.array(relayRowSchema),
+    totals: z5.object({
+      managedVotingPower: z5.string(),
+      relayTokenBalances: z5.array(
+        z5.object({
+          token: z5.string(),
+          symbol: z5.string(),
+          decimals: z5.number(),
+          balance: z5.string()
+        })
+      )
+    })
   }),
-  env,
-  output: z.object({
-    address: z.string(),
-    positions: z.array(
-      z.object({
-        pool: z.string(),
-        gauge: z.string(),
-        rewardToken: z.string(),
-        staked: z.string(),
-        earned: z.string()
-      })
-    ),
-    count: z.number()
+  examples: [{ description: "List all known vault relays on Abstract" }],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const snapshot = await readVaultSummary(client);
+    return c.ok(snapshot);
+  }
+});
+vaults.command("relay", {
+  description: "Inspect one relay vault by address.",
+  args: z5.object({
+    relay: z5.string().describe("Relay vault contract address")
   }),
+  env: env5,
+  output: relayRowSchema,
   examples: [
     {
-      args: { address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" },
-      description: "List gauge positions for a wallet"
+      args: { relay: ABOREAN_VAULT_ADDRESSES.veAbxMaxiRelay },
+      description: "Inspect the veABX maxi relay"
     }
   ],
   async run(c) {
-    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
-    const gaugePools = await discoverGaugePools(client);
-    if (!gaugePools.length) {
-      return c.ok({
-        address: toChecksum(c.args.address),
-        positions: [],
-        count: 0
+    if (!isAddress4(c.args.relay)) {
+      return c.error({
+        code: "INVALID_ARGUMENT",
+        message: "relay must be a valid address"
       });
     }
-    const positionData = await client.multicall({
-      allowFailure: false,
-      contracts: gaugePools.flatMap(({ gauge }) => [
-        {
-          abi: gaugeAbi,
-          address: gauge,
-          functionName: "balanceOf",
-          args: [c.args.address]
-        },
-        {
-          abi: gaugeAbi,
-          address: gauge,
-          functionName: "earned",
-          args: [c.args.address]
-        },
-        {
-          abi: gaugeAbi,
-          address: gauge,
-          functionName: "rewardToken"
-        }
-      ])
-    });
-    const positions = gaugePools.map(({ pool, gauge }, index) => {
-      const offset = index * 3;
-      const staked = positionData[offset];
-      const earned = positionData[offset + 1];
-      const rewardToken = positionData[offset + 2];
-      return {
-        pool: toChecksum(pool),
-        gauge: toChecksum(gauge),
-        rewardToken: toChecksum(rewardToken),
-        staked,
-        earned
-      };
-    }).filter((position) => position.staked > 0n || position.earned > 0n).map((position) => ({
-      pool: position.pool,
-      gauge: position.gauge,
-      rewardToken: position.rewardToken,
-      staked: position.staked.toString(),
-      earned: position.earned.toString()
-    }));
-    return c.ok({
-      address: toChecksum(c.args.address),
-      positions,
-      count: positions.length
-    });
+    const relayAddress = checksumAddress5(c.args.relay);
+    const known = KNOWN_RELAYS.find(
+      (relay) => relay.relay.toLowerCase() === relayAddress.toLowerCase()
+    );
+    if (!known) {
+      return c.error({
+        code: "NOT_FOUND",
+        message: `relay ${shortAddress4(relayAddress)} is not in the known Aborean vault set`
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const snapshot = await readRelaySnapshot(client, known);
+    return c.ok(snapshot);
   }
 });
 
 // src/commands/ve.ts
-import { Cli as Cli2, z as z2 } from "incur";
-var env2 = z2.object({
-  ABSTRACT_RPC_URL: z2.string().optional().describe("Abstract RPC URL override")
+import { Cli as Cli6, z as z6 } from "incur";
+var env6 = z6.object({
+  ABSTRACT_RPC_URL: z6.string().optional().describe("Abstract RPC URL override")
 });
-var ve = Cli2.create("ve", {
+var ve = Cli6.create("ve", {
   description: "Inspect Aborean VotingEscrow (veABX) global and per-NFT lock state."
 });
 ve.command("stats", {
   description: "Get global VotingEscrow supply, locks, and decay checkpoint data.",
-  env: env2,
-  output: z2.object({
-    token: z2.string(),
-    totalVotingPower: z2.string(),
-    totalLocked: z2.string(),
-    permanentLocked: z2.string(),
-    epoch: z2.number(),
-    decayBias: z2.string(),
-    decaySlope: z2.string(),
-    lastCheckpointTimestamp: z2.number(),
-    lastCheckpointBlock: z2.number()
+  env: env6,
+  output: z6.object({
+    token: z6.string(),
+    totalVotingPower: z6.string(),
+    totalLocked: z6.string(),
+    permanentLocked: z6.string(),
+    epoch: z6.number(),
+    decayBias: z6.string(),
+    decaySlope: z6.string(),
+    lastCheckpointTimestamp: z6.number(),
+    lastCheckpointBlock: z6.number()
   }),
   examples: [{ description: "Show global veABX state and decay metrics" }],
   async run(c) {
@@ -1224,17 +3411,17 @@ ve.command("stats", {
 });
 ve.command("lock", {
   description: "Get lock details and voting power for one veNFT token id.",
-  args: z2.object({
-    tokenId: z2.coerce.number().int().nonnegative().describe("veNFT token id")
+  args: z6.object({
+    tokenId: z6.coerce.number().int().nonnegative().describe("veNFT token id")
   }),
-  env: env2,
-  output: z2.object({
-    tokenId: z2.number(),
-    owner: z2.string(),
-    amount: z2.string(),
-    unlockTime: z2.number(),
-    isPermanent: z2.boolean(),
-    votingPower: z2.string()
+  env: env6,
+  output: z6.object({
+    tokenId: z6.number(),
+    owner: z6.string(),
+    amount: z6.string(),
+    unlockTime: z6.number(),
+    isPermanent: z6.boolean(),
+    votingPower: z6.string()
   }),
   examples: [{ args: { tokenId: 1 }, description: "Inspect lock details for veNFT #1" }],
   async run(c) {
@@ -1272,22 +3459,22 @@ ve.command("lock", {
 });
 ve.command("locks", {
   description: "List all veNFT locks owned by an address.",
-  args: z2.object({
-    address: z2.string().describe("Owner address")
+  args: z6.object({
+    address: z6.string().describe("Owner address")
   }),
-  env: env2,
-  output: z2.object({
-    address: z2.string(),
-    locks: z2.array(
-      z2.object({
-        tokenId: z2.string(),
-        amount: z2.string(),
-        unlockTime: z2.number(),
-        isPermanent: z2.boolean(),
-        votingPower: z2.string()
+  env: env6,
+  output: z6.object({
+    address: z6.string(),
+    locks: z6.array(
+      z6.object({
+        tokenId: z6.string(),
+        amount: z6.string(),
+        unlockTime: z6.number(),
+        isPermanent: z6.boolean(),
+        votingPower: z6.string()
       })
     ),
-    count: z2.number()
+    count: z6.number()
   }),
   examples: [
     {
@@ -1359,13 +3546,13 @@ ve.command("locks", {
 });
 ve.command("voting-power", {
   description: "Get current voting power for one veNFT token id.",
-  args: z2.object({
-    tokenId: z2.coerce.number().int().nonnegative().describe("veNFT token id")
+  args: z6.object({
+    tokenId: z6.coerce.number().int().nonnegative().describe("veNFT token id")
   }),
-  env: env2,
-  output: z2.object({
-    tokenId: z2.number(),
-    votingPower: z2.string()
+  env: env6,
+  output: z6.object({
+    tokenId: z6.number(),
+    votingPower: z6.string()
   }),
   examples: [{ args: { tokenId: 1 }, description: "Get current voting power for veNFT #1" }],
   async run(c) {
@@ -1384,9 +3571,9 @@ ve.command("voting-power", {
 });
 
 // src/commands/voter.ts
-import { Cli as Cli3, z as z3 } from "incur";
-var env3 = z3.object({
-  ABSTRACT_RPC_URL: z3.string().optional().describe("Abstract RPC URL override")
+import { Cli as Cli7, z as z7 } from "incur";
+var env7 = z7.object({
+  ABSTRACT_RPC_URL: z7.string().optional().describe("Abstract RPC URL override")
 });
 async function discoverPools(client) {
   const [v2PoolCount, clPoolCount] = await Promise.all([
@@ -1425,20 +3612,20 @@ async function discoverPools(client) {
   ]);
   return [...v2Pools, ...clPools];
 }
-var voter = Cli3.create("voter", {
+var voter = Cli7.create("voter", {
   description: "Inspect Aborean voter epoch, pool weights, and claimable rewards context."
 });
 voter.command("epoch", {
   description: "Show current emissions epoch timing from Minter.",
-  env: env3,
-  output: z3.object({
-    activePeriod: z3.number(),
-    epochEnd: z3.number(),
-    secondsRemaining: z3.number(),
-    timeRemaining: z3.string(),
-    weekSeconds: z3.number(),
-    epochCount: z3.number(),
-    weeklyEmission: z3.string()
+  env: env7,
+  output: z7.object({
+    activePeriod: z7.number(),
+    epochEnd: z7.number(),
+    secondsRemaining: z7.number(),
+    timeRemaining: z7.string(),
+    weekSeconds: z7.number(),
+    epochCount: z7.number(),
+    weeklyEmission: z7.string()
   }),
   examples: [{ description: "Inspect current voter epoch boundaries" }],
   async run(c) {
@@ -1480,23 +3667,23 @@ voter.command("epoch", {
 });
 voter.command("weights", {
   description: "Show current pool voting weight distribution.",
-  env: env3,
-  output: z3.object({
-    totalWeight: z3.string(),
-    pools: z3.array(
-      z3.object({
-        pool: z3.string(),
-        gauge: z3.string(),
-        weight: z3.string()
+  env: env7,
+  output: z7.object({
+    totalWeight: z7.string(),
+    pools: z7.array(
+      z7.object({
+        pool: z7.string(),
+        gauge: z7.string(),
+        weight: z7.string()
       })
     ),
-    count: z3.number()
+    count: z7.number()
   }),
   examples: [{ description: "List all pools with non-zero voting weight" }],
   async run(c) {
     const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
-    const pools = await discoverPools(client);
-    if (!pools.length) {
+    const pools2 = await discoverPools(client);
+    if (!pools2.length) {
       return c.ok({ totalWeight: "0", pools: [], count: 0 });
     }
     const [totalWeight, poolData] = await Promise.all([
@@ -1507,7 +3694,7 @@ voter.command("weights", {
       }),
       client.multicall({
         allowFailure: false,
-        contracts: pools.flatMap((pool) => [
+        contracts: pools2.flatMap((pool) => [
           {
             abi: voterAbi,
             address: ABOREAN_V2_ADDRESSES.voter,
@@ -1523,7 +3710,7 @@ voter.command("weights", {
         ])
       })
     ]);
-    const entries = pools.map((pool, index) => {
+    const entries = pools2.map((pool, index) => {
       const offset = index * 2;
       const gauge = poolData[offset] ?? ZERO_ADDRESS;
       const weight = poolData[offset + 1] ?? 0n;
@@ -1548,19 +3735,19 @@ voter.command("weights", {
 });
 voter.command("rewards", {
   description: "Show claimable rebase rewards and voting context for a veNFT.",
-  args: z3.object({
-    tokenId: z3.coerce.number().int().nonnegative().describe("veNFT token id")
+  args: z7.object({
+    tokenId: z7.coerce.number().int().nonnegative().describe("veNFT token id")
   }),
-  env: env3,
-  output: z3.object({
-    tokenId: z3.number(),
-    rewardToken: z3.string(),
-    claimableRebase: z3.string(),
-    timeCursor: z3.number(),
-    lastTokenTime: z3.number(),
-    distributorStartTime: z3.number(),
-    usedWeight: z3.string(),
-    lastVoted: z3.number()
+  env: env7,
+  output: z7.object({
+    tokenId: z7.number(),
+    rewardToken: z7.string(),
+    claimableRebase: z7.string(),
+    timeCursor: z7.number(),
+    lastTokenTime: z7.number(),
+    distributorStartTime: z7.number(),
+    usedWeight: z7.string(),
+    lastVoted: z7.number()
   }),
   examples: [{ args: { tokenId: 1 }, description: "Check claimable voter/distributor rewards" }],
   async run(c) {
@@ -1629,22 +3816,22 @@ voter.command("rewards", {
 });
 voter.command("bribes", {
   description: "Show active bribe reward tokens and current-epoch amounts for a pool.",
-  args: z3.object({
-    pool: z3.string().describe("Pool address")
+  args: z7.object({
+    pool: z7.string().describe("Pool address")
   }),
-  env: env3,
-  output: z3.object({
-    pool: z3.string(),
-    gauge: z3.string(),
-    bribeContract: z3.string(),
-    epochStart: z3.number(),
-    rewardTokens: z3.array(
-      z3.object({
-        token: z3.string(),
-        epochAmount: z3.string()
+  env: env7,
+  output: z7.object({
+    pool: z7.string(),
+    gauge: z7.string(),
+    bribeContract: z7.string(),
+    epochStart: z7.number(),
+    rewardTokens: z7.array(
+      z7.object({
+        token: z7.string(),
+        epochAmount: z7.string()
       })
     ),
-    count: z3.number()
+    count: z7.number()
   }),
   examples: [
     {
@@ -1870,26 +4057,283 @@ function applyFriendlyErrorHandling(cli2) {
 // src/cli.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf8"));
-var cli = Cli4.create("aborean", {
+var cli = Cli8.create("aborean", {
   version: pkg.version,
   description: "Aborean Finance DEX CLI for Abstract chain."
 });
 cli.command(gauges);
+cli.command(pools);
 cli.command(ve);
 cli.command(voter);
-var rootEnv = z4.object({
-  ABSTRACT_RPC_URL: z4.string().optional().describe("Abstract RPC URL override")
+cli.command(cl);
+cli.command(vaults);
+cli.command(lending);
+var rootEnv = z8.object({
+  ABSTRACT_RPC_URL: z8.string().optional().describe("Abstract RPC URL override")
 });
+var erc20MetadataAbi4 = [
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "string" }]
+  },
+  {
+    type: "function",
+    name: "decimals",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint8" }]
+  }
+];
+var v2PoolLiteAbi = [
+  {
+    type: "function",
+    name: "token0",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "address" }]
+  },
+  {
+    type: "function",
+    name: "token1",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "address" }]
+  },
+  {
+    type: "function",
+    name: "stable",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "getReserves",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      { type: "uint256", name: "reserve0" },
+      { type: "uint256", name: "reserve1" },
+      { type: "uint256", name: "blockTimestampLast" }
+    ]
+  }
+];
+function finiteOrZero(value) {
+  return Number.isFinite(value) ? value : 0;
+}
+function shortAddress5(address) {
+  return `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
+}
+function normalizeReserveTuple(value) {
+  if (Array.isArray(value)) {
+    return {
+      reserve0: BigInt(value[0]),
+      reserve1: BigInt(value[1])
+    };
+  }
+  const row = value;
+  return {
+    reserve0: BigInt(row.reserve0),
+    reserve1: BigInt(row.reserve1)
+  };
+}
+async function readTokenMetadata4(client, tokenAddresses) {
+  const unique = [...new Set(tokenAddresses.map((address) => address.toLowerCase()))];
+  if (!unique.length) {
+    return /* @__PURE__ */ new Map();
+  }
+  const contracts = unique.flatMap((address) => [
+    {
+      abi: erc20MetadataAbi4,
+      address,
+      functionName: "symbol"
+    },
+    {
+      abi: erc20MetadataAbi4,
+      address,
+      functionName: "decimals"
+    }
+  ]);
+  const results = await client.multicall({
+    allowFailure: true,
+    contracts
+  });
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < unique.length; i += 1) {
+    const address = checksumAddress6(unique[i]);
+    const symbolResult = results[i * 2];
+    const decimalsResult = results[i * 2 + 1];
+    const symbol = symbolResult && symbolResult.status === "success" && typeof symbolResult.result === "string" ? symbolResult.result : shortAddress5(address);
+    const decimals = decimalsResult && decimalsResult.status === "success" && typeof decimalsResult.result === "number" ? decimalsResult.result : 18;
+    map.set(address.toLowerCase(), {
+      address,
+      symbol,
+      decimals
+    });
+  }
+  return map;
+}
+async function readTopV2PoolsSnapshot(client, limit) {
+  const v2PoolCount = await client.readContract({
+    abi: poolFactoryAbi,
+    address: ABOREAN_V2_ADDRESSES.poolFactory,
+    functionName: "allPoolsLength"
+  });
+  if (v2PoolCount === 0n) {
+    return { topPools: [], reserveUnitTvl: 0 };
+  }
+  const indices = Array.from({ length: Number(v2PoolCount) }, (_, i) => BigInt(i));
+  const pools2 = await client.multicall({
+    allowFailure: false,
+    contracts: indices.map((index) => ({
+      abi: poolFactoryAbi,
+      address: ABOREAN_V2_ADDRESSES.poolFactory,
+      functionName: "allPools",
+      args: [index]
+    }))
+  });
+  const poolData = await client.multicall({
+    allowFailure: false,
+    contracts: pools2.flatMap((pool) => [
+      {
+        abi: v2PoolLiteAbi,
+        address: pool,
+        functionName: "token0"
+      },
+      {
+        abi: v2PoolLiteAbi,
+        address: pool,
+        functionName: "token1"
+      },
+      {
+        abi: v2PoolLiteAbi,
+        address: pool,
+        functionName: "stable"
+      },
+      {
+        abi: v2PoolLiteAbi,
+        address: pool,
+        functionName: "getReserves"
+      }
+    ])
+  });
+  const tokenAddresses = [];
+  for (let i = 0; i < pools2.length; i += 1) {
+    tokenAddresses.push(checksumAddress6(poolData[i * 4]));
+    tokenAddresses.push(checksumAddress6(poolData[i * 4 + 1]));
+  }
+  const tokenMeta = await readTokenMetadata4(client, tokenAddresses);
+  const rows = pools2.map((pool, index) => {
+    const token0Address = checksumAddress6(poolData[index * 4]);
+    const token1Address = checksumAddress6(poolData[index * 4 + 1]);
+    const stable = Boolean(poolData[index * 4 + 2]);
+    const reserves = normalizeReserveTuple(poolData[index * 4 + 3]);
+    const token0 = tokenMeta.get(token0Address.toLowerCase()) ?? {
+      address: token0Address,
+      symbol: shortAddress5(token0Address),
+      decimals: 18
+    };
+    const token1 = tokenMeta.get(token1Address.toLowerCase()) ?? {
+      address: token1Address,
+      symbol: shortAddress5(token1Address),
+      decimals: 18
+    };
+    const reserve0Decimal = finiteOrZero(Number(formatUnits4(reserves.reserve0, token0.decimals)));
+    const reserve1Decimal = finiteOrZero(Number(formatUnits4(reserves.reserve1, token1.decimals)));
+    const tvlUnits = reserve0Decimal + reserve1Decimal;
+    return {
+      pool: checksumAddress6(pool),
+      pair: `${token0.symbol}/${token1.symbol}`,
+      poolType: stable ? "stable" : "volatile",
+      token0: {
+        address: checksumAddress6(token0.address),
+        symbol: token0.symbol,
+        decimals: token0.decimals
+      },
+      token1: {
+        address: checksumAddress6(token1.address),
+        symbol: token1.symbol,
+        decimals: token1.decimals
+      },
+      reserves: {
+        token0: formatUnits4(reserves.reserve0, token0.decimals),
+        token1: formatUnits4(reserves.reserve1, token1.decimals)
+      },
+      tvlEstimateUnits: tvlUnits
+    };
+  });
+  const reserveUnitTvl = rows.reduce((sum, row) => sum + Number(row.tvlEstimateUnits), 0);
+  return {
+    topPools: rows.sort((a, b) => Number(b.tvlEstimateUnits) - Number(a.tvlEstimateUnits)).slice(0, limit),
+    reserveUnitTvl
+  };
+}
 cli.command("status", {
-  description: "Get a cross-contract Aborean protocol snapshot (pool counts, gauge count, veABX supply).",
+  description: "Cross-protocol Aborean snapshot (TVL estimates, epoch, top pools, ve lock, vaults, Morpho lending).",
   env: rootEnv,
-  output: z4.object({
-    v2PoolCount: z4.number().describe("Number of V2 AMM pools"),
-    clPoolCount: z4.number().describe("Number of Slipstream (CL) pools"),
-    gaugeCount: z4.number().describe("Number of pools with gauges"),
-    totalVotingWeight: z4.string().describe("Total voting weight (wei)"),
-    veABXTotalSupply: z4.string().describe("Total veABX supply (wei)"),
-    veABXLockedSupply: z4.string().describe("Total ABX locked in VotingEscrow (wei)")
+  output: z8.object({
+    v2PoolCount: z8.number().describe("Number of V2 AMM pools"),
+    clPoolCount: z8.number().describe("Number of Slipstream (CL) pools"),
+    gaugeCount: z8.number().describe("Number of pools with gauges"),
+    totalVotingWeight: z8.string().describe("Total voting weight (wei)"),
+    veABXTotalSupply: z8.string().describe("Total veABX supply (wei)"),
+    veABXLockedSupply: z8.string().describe("Total ABX locked in VotingEscrow (wei)"),
+    epoch: z8.object({
+      activePeriod: z8.number(),
+      epochEnd: z8.number(),
+      secondsRemaining: z8.number(),
+      epochCount: z8.number(),
+      weeklyEmission: z8.string()
+    }),
+    topPools: z8.array(
+      z8.object({
+        pool: z8.string(),
+        pair: z8.string(),
+        poolType: z8.enum(["stable", "volatile"]),
+        token0: z8.object({
+          address: z8.string(),
+          symbol: z8.string(),
+          decimals: z8.number()
+        }),
+        token1: z8.object({
+          address: z8.string(),
+          symbol: z8.string(),
+          decimals: z8.number()
+        }),
+        reserves: z8.object({
+          token0: z8.string(),
+          token1: z8.string()
+        }),
+        tvlEstimateUnits: z8.number()
+      })
+    ),
+    tvl: z8.object({
+      v2ReserveUnitEstimate: z8.number(),
+      vaultManagedVotingPower: z8.string()
+    }),
+    vaults: z8.object({
+      relayCount: z8.number(),
+      managedVotingPower: z8.string(),
+      note: z8.string().nullable()
+    }),
+    lending: z8.object({
+      available: z8.boolean(),
+      morpho: z8.string(),
+      marketCount: z8.number(),
+      supplyByLoanToken: z8.array(
+        z8.object({
+          token: z8.string(),
+          symbol: z8.string(),
+          decimals: z8.number(),
+          totalSupplyAssets: z8.string(),
+          totalBorrowAssets: z8.string()
+        })
+      ),
+      note: z8.string().nullable()
+    })
   }),
   examples: [{ description: "Fetch the current Aborean protocol status" }],
   async run(c) {
@@ -1900,7 +4344,12 @@ cli.command("status", {
       gaugeCount,
       totalVotingWeight,
       veABXTotalSupply,
-      veABXLockedSupply
+      veABXLockedSupply,
+      activePeriod,
+      weekSeconds,
+      epochCount,
+      weeklyEmission,
+      v2PoolSnapshot
     ] = await Promise.all([
       client.readContract({
         abi: poolFactoryAbi,
@@ -1931,15 +4380,87 @@ cli.command("status", {
         abi: votingEscrowAbi,
         address: ABOREAN_V2_ADDRESSES.votingEscrow,
         functionName: "supply"
-      })
+      }),
+      client.readContract({
+        abi: minterAbi,
+        address: ABOREAN_V2_ADDRESSES.minter,
+        functionName: "activePeriod"
+      }),
+      client.readContract({
+        abi: minterAbi,
+        address: ABOREAN_V2_ADDRESSES.minter,
+        functionName: "WEEK"
+      }),
+      client.readContract({
+        abi: minterAbi,
+        address: ABOREAN_V2_ADDRESSES.minter,
+        functionName: "epochCount"
+      }),
+      client.readContract({
+        abi: minterAbi,
+        address: ABOREAN_V2_ADDRESSES.minter,
+        functionName: "weekly"
+      }),
+      readTopV2PoolsSnapshot(client, 5)
     ]);
+    let vaultRelayCount = 0;
+    let vaultManagedVotingPower = "0";
+    let vaultNote = null;
+    try {
+      const vaultSnapshot = await readVaultSummary(client);
+      vaultRelayCount = vaultSnapshot.relayCount;
+      vaultManagedVotingPower = vaultSnapshot.totals.managedVotingPower;
+    } catch (error) {
+      vaultNote = error instanceof Error ? error.message : "vault snapshot unavailable";
+    }
+    let lendingAvailable = false;
+    let lendingMarketCount = 0;
+    let lendingMorpho = "";
+    let lendingSupplyByLoanToken = [];
+    let lendingNote = null;
+    try {
+      const lendingSnapshot = await readLendingSummary(client);
+      lendingAvailable = lendingSnapshot.available;
+      lendingMarketCount = lendingSnapshot.marketCount;
+      lendingMorpho = lendingSnapshot.morpho;
+      lendingSupplyByLoanToken = lendingSnapshot.supplyByLoanToken;
+    } catch (error) {
+      lendingMorpho = "";
+      lendingNote = error instanceof Error ? error.message : "lending snapshot unavailable";
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const epochEnd = Number(activePeriod) + Number(weekSeconds);
     return c.ok({
       v2PoolCount: Number(v2PoolCount),
       clPoolCount: Number(clPoolCount),
       gaugeCount: Number(gaugeCount),
       totalVotingWeight: String(totalVotingWeight),
       veABXTotalSupply: String(veABXTotalSupply),
-      veABXLockedSupply: String(veABXLockedSupply)
+      veABXLockedSupply: String(veABXLockedSupply),
+      epoch: {
+        activePeriod: Number(activePeriod),
+        epochEnd,
+        secondsRemaining: Math.max(0, epochEnd - now),
+        epochCount: Number(epochCount),
+        weeklyEmission: String(weeklyEmission)
+      },
+      topPools: v2PoolSnapshot.topPools,
+      tvl: {
+        v2ReserveUnitEstimate: v2PoolSnapshot.reserveUnitTvl,
+        vaultManagedVotingPower
+      },
+      vaults: {
+        relayCount: vaultRelayCount,
+        managedVotingPower: vaultManagedVotingPower,
+        note: vaultNote
+      },
+      lending: {
+        available: lendingAvailable,
+        morpho: lendingMorpho,
+        marketCount: lendingMarketCount,
+        supplyByLoanToken: lendingSupplyByLoanToken,
+        note: lendingNote
+      }
     });
   }
 });