@spectratools/aborean-cli 0.7.0 → 0.10.0

package/dist/cli.js

@@ -5,12 +5,12 @@ import { readFileSync } from "fs";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { checksumAddress as checksumAddress6 } from "@spectratools/cli-shared";
-import { Cli as Cli8, z as z8 } from "incur";
+import { Cli as Cli8, z as z9 } from "incur";
 import { formatUnits as formatUnits4 } from "viem";
 
 // src/commands/cl.ts
-import { checksumAddress, isAddress } from "@spectratools/cli-shared";
-import { Cli, z } from "incur";
+import { checksumAddress as checksumAddress2, isAddress } from "@spectratools/cli-shared";
+import { Cli, z as z2 } from "incur";
 import { formatUnits, parseUnits } from "viem";
 
 // src/contracts/abis/CLFactory.abi.json
@@ -560,6 +560,47 @@ var RewardsDistributor_abi_default = [
   }
 ];
 
+// src/contracts/abis/SwapRouter.abi.json
+var SwapRouter_abi_default = [
+  {
+    type: "function",
+    name: "exactInputSingle",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        internalType: "struct ISwapRouter.ExactInputSingleParams",
+        components: [
+          { name: "tokenIn", type: "address", internalType: "address" },
+          { name: "tokenOut", type: "address", internalType: "address" },
+          { name: "tickSpacing", type: "int24", internalType: "int24" },
+          { name: "recipient", type: "address", internalType: "address" },
+          { name: "deadline", type: "uint256", internalType: "uint256" },
+          { name: "amountIn", type: "uint256", internalType: "uint256" },
+          { name: "amountOutMinimum", type: "uint256", internalType: "uint256" },
+          { name: "sqrtPriceLimitX96", type: "uint160", internalType: "uint160" }
+        ]
+      }
+    ],
+    outputs: [{ name: "amountOut", type: "uint256", internalType: "uint256" }],
+    stateMutability: "payable"
+  },
+  {
+    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/V2Pool.abi.json
 var V2Pool_abi_default = [
   {
@@ -947,6 +988,7 @@ var nonfungiblePositionManagerAbi = NonfungiblePositionManager_abi_default;
 var poolFactoryAbi = PoolFactory_abi_default;
 var quoterV2Abi = QuoterV2_abi_default;
 var rewardsDistributorAbi = RewardsDistributor_abi_default;
+var swapRouterAbi = SwapRouter_abi_default;
 var v2PoolAbi = V2Pool_abi_default;
 var v2RouterAbi = V2Router_abi_default;
 var voterAbi = Voter_abi_default;
@@ -1032,7 +1074,12 @@ var ABOREAN_ADDRESSES = {
 };
 
 // src/contracts/client.ts
-import { http, createPublicClient, defineChain } from "viem";
+import {
+  http,
+  createPublicClient,
+  createWalletClient,
+  defineChain
+} from "viem";
 var abstractMainnet = defineChain({
   id: 2741,
   name: "Abstract Mainnet",
@@ -1053,63 +1100,174 @@ function createAboreanPublicClient(rpcUrl) {
     transport: http(rpcUrl ?? process.env.ABSTRACT_RPC_URL ?? "https://api.mainnet.abs.xyz")
   });
 }
+function createAboreanWalletClient(account, rpcUrl) {
+  return createWalletClient({
+    account,
+    chain: abstractMainnet,
+    transport: http(rpcUrl ?? process.env.ABSTRACT_RPC_URL ?? "https://api.mainnet.abs.xyz")
+  });
+}
+
+// src/commands/_write-utils.ts
+import {
+  createPrivateKeySigner,
+  executeTx
+} from "@spectratools/tx-shared";
+import { z } from "incur";
+
+// 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;
+  }
+}
+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;
+}
+function jsonSafe(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map((item) => jsonSafe(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        jsonSafe(entry)
+      ])
+    );
+  }
+  return value;
+}
+
+// src/commands/_write-utils.ts
+var PRIVATE_KEY_MISSING_MESSAGE = "Missing PRIVATE_KEY env var. Set PRIVATE_KEY to a 0x-prefixed 32-byte hex private key.";
+var writeEnv = z.object({
+  ABSTRACT_RPC_URL: z.string().optional().describe("Abstract RPC URL override"),
+  PRIVATE_KEY: z.string().min(1, PRIVATE_KEY_MISSING_MESSAGE).describe("Private key (0x-prefixed 32-byte hex) for signing transactions")
+});
+var writeOptions = z.object({
+  "dry-run": z.boolean().default(false).describe("Simulate the transaction without broadcasting"),
+  "gas-limit": z.string().optional().describe("Gas limit override (in gas units)"),
+  "max-fee": z.string().optional().describe("Max fee per gas override in wei (EIP-1559)"),
+  nonce: z.number().optional().describe("Nonce override")
+});
+function resolveAccount(env8) {
+  const privateKey = env8.PRIVATE_KEY?.trim();
+  if (!privateKey) {
+    throw new Error(PRIVATE_KEY_MISSING_MESSAGE);
+  }
+  const signer = createPrivateKeySigner(privateKey);
+  return signer.account;
+}
+function formatTxResult(result) {
+  if (result.status === "dry-run") {
+    return {
+      dryRun: true,
+      estimatedGas: result.estimatedGas.toString(),
+      simulationResult: jsonSafe(result.simulationResult),
+      ...result.privyPolicy !== void 0 ? { privyPolicy: jsonSafe(result.privyPolicy) } : {}
+    };
+  }
+  return {
+    txHash: result.hash,
+    blockNumber: Number(result.blockNumber),
+    gasUsed: result.gasUsed.toString()
+  };
+}
+async function aboreanWriteTx(opts) {
+  const { env: env8, options, address, abi, functionName, args, value } = opts;
+  const account = resolveAccount(env8);
+  const publicClient = createAboreanPublicClient(env8.ABSTRACT_RPC_URL);
+  const walletClient = createAboreanWalletClient(account, env8.ABSTRACT_RPC_URL);
+  const result = await executeTx({
+    publicClient,
+    walletClient,
+    account,
+    address,
+    abi,
+    functionName,
+    ...args !== void 0 ? { args } : {},
+    ...value !== void 0 ? { value } : {},
+    dryRun: options["dry-run"],
+    ...options["gas-limit"] ? { gasLimit: BigInt(options["gas-limit"]) } : {},
+    ...options["max-fee"] ? { maxFeePerGas: BigInt(options["max-fee"]) } : {},
+    ...options.nonce !== void 0 ? { nonce: options.nonce } : {}
+  });
+  return formatTxResult(result);
+}
 
 // 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 env = z2.object({
+  ABSTRACT_RPC_URL: z2.string().optional().describe("Abstract RPC URL override")
 });
-var tokenSchema = z.object({
-  address: z.string(),
-  symbol: z.string(),
-  decimals: z.number()
+var tokenSchema = z2.object({
+  address: z2.string(),
+  symbol: z2.string(),
+  decimals: z2.number()
 });
-var poolRowSchema = z.object({
-  pool: z.string(),
-  pair: z.string(),
+var poolRowSchema = z2.object({
+  pool: z2.string(),
+  pair: z2.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()
+  fee: z2.number(),
+  feePercent: z2.number(),
+  tickSpacing: z2.number(),
+  liquidity: z2.string(),
+  currentTick: z2.number(),
+  sqrtPriceX96: z2.string(),
+  activeLiquidityEstimate: z2.object({
+    token0: z2.string(),
+    token1: z2.string(),
+    totalInToken0: z2.number().nullable(),
+    totalInToken1: z2.number().nullable()
   }),
-  price: z.object({
-    token1PerToken0: z.number().nullable(),
-    token0PerToken1: z.number().nullable()
+  price: z2.object({
+    token1PerToken0: z2.number().nullable(),
+    token0PerToken1: z2.number().nullable()
   })
 });
-var quoteOutputSchema = z.object({
-  pool: z.string(),
-  selectedFee: z.number(),
-  selectedTickSpacing: z.number(),
+var quoteOutputSchema = z2.object({
+  pool: z2.string(),
+  selectedFee: z2.number(),
+  selectedTickSpacing: z2.number(),
   tokenIn: tokenSchema,
   tokenOut: tokenSchema,
-  amountIn: z.object({
-    raw: z.string(),
-    decimal: z.string()
+  amountIn: z2.object({
+    raw: z2.string(),
+    decimal: z2.string()
   }),
-  amountOut: z.object({
-    raw: z.string(),
-    decimal: z.string()
+  amountOut: z2.object({
+    raw: z2.string(),
+    decimal: z2.string()
   }),
-  execution: z.object({
-    sqrtPriceX96After: z.string(),
-    initializedTicksCrossed: z.number(),
-    gasEstimate: z.string()
+  execution: z2.object({
+    sqrtPriceX96After: z2.string(),
+    initializedTicksCrossed: z2.number(),
+    gasEstimate: z2.string()
   }),
-  prices: z.object({
-    poolMidPriceOutPerIn: z.number().nullable(),
-    quotePriceOutPerIn: z.number().nullable(),
-    priceImpactPct: z.number().nullable()
+  prices: z2.object({
+    poolMidPriceOutPerIn: z2.number().nullable(),
+    quotePriceOutPerIn: z2.number().nullable(),
+    priceImpactPct: z2.number().nullable()
   })
 });
 var erc20MetadataAbi = [
@@ -1137,7 +1295,7 @@ function finiteOrNull(value) {
 function toTokenMetaFallback(address) {
   return {
     address,
-    symbol: shortAddress(checksumAddress(address)),
+    symbol: shortAddress(checksumAddress2(address)),
     decimals: 18
   };
 }
@@ -1232,7 +1390,7 @@ async function readTokenMetadata(client, tokenAddresses) {
     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),
+      address: checksumAddress2(address),
       symbol,
       decimals
     });
@@ -1316,7 +1474,7 @@ function toPoolRow(pool, tokenMeta) {
     prices
   );
   return {
-    pool: checksumAddress(pool.pool),
+    pool: checksumAddress2(pool.pool),
     pair: `${token0.symbol}/${token1.symbol}`,
     token0,
     token1,
@@ -1339,9 +1497,9 @@ var cl = Cli.create("cl", {
 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)
+  output: z2.object({
+    count: z2.number(),
+    pools: z2.array(poolRowSchema)
   }),
   async run(c) {
     const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
@@ -1382,11 +1540,11 @@ cl.command("pools", {
 });
 cl.command("pool", {
   description: "Get detailed state for a Slipstream pool address.",
-  args: z.object({
-    pool: z.string().describe("Pool address")
+  args: z2.object({
+    pool: z2.string().describe("Pool address")
   }),
   env,
-  output: z.object({
+  output: z2.object({
     pool: poolRowSchema
   }),
   async run(c) {
@@ -1397,7 +1555,7 @@ cl.command("pool", {
       });
     }
     const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
-    const checksummedPool = checksumAddress(c.args.pool);
+    const checksummedPool = checksumAddress2(c.args.pool);
     const [poolState] = await readPoolStates(client, [checksummedPool]);
     const tokenMeta = await readTokenMetadata(client, [poolState.token0, poolState.token1]);
     const row = toPoolRow(poolState, tokenMeta);
@@ -1431,25 +1589,25 @@ cl.command("pool", {
 });
 cl.command("positions", {
   description: "List concentrated liquidity NFT positions for an owner.",
-  args: z.object({
-    owner: z.string().describe("Owner wallet address")
+  args: z2.object({
+    owner: z2.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(),
+  output: z2.object({
+    owner: z2.string(),
+    count: z2.number(),
+    positions: z2.array(
+      z2.object({
+        tokenId: z2.string(),
+        pair: z2.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() })
+        tickSpacing: z2.number(),
+        tickLower: z2.number(),
+        tickUpper: z2.number(),
+        liquidity: z2.string(),
+        tokensOwed0: z2.object({ raw: z2.string(), decimal: z2.string() }),
+        tokensOwed1: z2.object({ raw: z2.string(), decimal: z2.string() })
       })
     )
   }),
@@ -1461,7 +1619,7 @@ cl.command("positions", {
       });
     }
     const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
-    const owner = checksumAddress(c.args.owner);
+    const owner = checksumAddress2(c.args.owner);
     const balance = await client.readContract({
       abi: nonfungiblePositionManagerAbi,
       address: ABOREAN_CL_ADDRESSES.nonfungiblePositionManager,
@@ -1545,13 +1703,13 @@ cl.command("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")
+  args: z2.object({
+    tokenIn: z2.string().describe("Input token address"),
+    tokenOut: z2.string().describe("Output token address"),
+    amountIn: z2.string().describe("Input amount in human-readable decimal units")
   }),
-  options: z.object({
-    fee: z.coerce.number().int().positive().optional().describe("Optional fee tier filter")
+  options: z2.object({
+    fee: z2.coerce.number().int().positive().optional().describe("Optional fee tier filter")
   }),
   env,
   output: quoteOutputSchema,
@@ -1564,8 +1722,8 @@ cl.command("quote", {
       });
     }
     const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
-    const inAddress = checksumAddress(tokenIn);
-    const outAddress = checksumAddress(tokenOut);
+    const inAddress = checksumAddress2(tokenIn);
+    const outAddress = checksumAddress2(tokenOut);
     const allPools = await listPoolAddresses(client);
     const poolStates = await readPoolStates(client, allPools);
     const pairPools = poolStates.filter((pool) => {
@@ -1632,7 +1790,7 @@ cl.command("quote", {
     const priceImpactPct = quotePriceOutPerIn === null || poolMidPriceOutPerIn === null || poolMidPriceOutPerIn === 0 ? null : finiteOrNull((poolMidPriceOutPerIn - quotePriceOutPerIn) / poolMidPriceOutPerIn * 100);
     return c.ok(
       {
-        pool: checksumAddress(selectedPool.pool),
+        pool: checksumAddress2(selectedPool.pool),
         selectedFee: selectedPool.fee,
         selectedTickSpacing: selectedPool.tickSpacing,
         tokenIn: inMeta,
@@ -1662,7 +1820,7 @@ cl.command("quote", {
           commands: [
             {
               command: "cl pool",
-              args: { pool: checksumAddress(selectedPool.pool) },
+              args: { pool: checksumAddress2(selectedPool.pool) },
               description: "Inspect the pool used for this quote"
             },
             {
@@ -1680,147 +1838,755 @@ cl.command("quote", {
     );
   }
 });
-
-// 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"
+var DEFAULT_SLIPPAGE_PERCENT = 0.5;
+var DEFAULT_DEADLINE_SECONDS = 300;
+var swapOutputSchema = z2.object({
+  pool: z2.string(),
+  tokenIn: tokenSchema,
+  tokenOut: tokenSchema,
+  amountIn: z2.object({ raw: z2.string(), decimal: z2.string() }),
+  quotedAmountOut: z2.object({ raw: z2.string(), decimal: z2.string() }),
+  amountOutMinimum: z2.object({ raw: z2.string(), decimal: z2.string() }),
+  slippagePercent: z2.number(),
+  deadlineSeconds: z2.number(),
+  tx: z2.union([
+    z2.object({
+      txHash: z2.string(),
+      blockNumber: z2.number(),
+      gasUsed: z2.string()
     }),
-    client.readContract({
-      abi: clFactoryAbi,
-      address: ABOREAN_CL_ADDRESSES.clFactory,
-      functionName: "allPoolsLength"
+    z2.object({
+      dryRun: z2.literal(true),
+      estimatedGas: z2.string(),
+      simulationResult: z2.unknown()
     })
-  ]);
-  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]
-      }))
-    }) : Promise.resolve([]),
-    clIndices.length ? client.multicall({
-      allowFailure: false,
-      contracts: clIndices.map((index) => ({
-        abi: clFactoryAbi,
-        address: ABOREAN_CL_ADDRESSES.clFactory,
-        functionName: "allPools",
-        args: [index]
-      }))
-    }) : Promise.resolve([])
-  ]);
-  const pools2 = [...v2Pools, ...clPools];
-  if (!pools2.length) return [];
-  const gauges2 = await client.multicall({
-    allowFailure: false,
-    contracts: pools2.map((pool) => ({
-      abi: voterAbi,
-      address: ABOREAN_V2_ADDRESSES.voter,
-      functionName: "gauges",
-      args: [pool]
-    }))
-  });
-  return pools2.map((pool, index) => ({ pool, gauge: gauges2[index] })).filter(({ gauge }) => gauge.toLowerCase() !== ZERO_ADDRESS.toLowerCase());
-}
-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: 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: z2.number()
+cl.command("swap", {
+  description: "Execute a single-hop Slipstream swap via the CL SwapRouter.",
+  options: z2.object({
+    "token-in": z2.string().describe("Input token address"),
+    "token-out": z2.string().describe("Output token address"),
+    "amount-in": z2.string().describe("Input amount in wei"),
+    slippage: z2.coerce.number().default(DEFAULT_SLIPPAGE_PERCENT).describe("Slippage tolerance in percent (default: 0.5)"),
+    deadline: z2.coerce.number().int().default(DEFAULT_DEADLINE_SECONDS).describe("Transaction deadline in seconds from now (default: 300)"),
+    ...writeOptions.shape
   }),
-  examples: [{ description: "List all active gauges and current emissions state" }],
+  env: writeEnv,
+  output: swapOutputSchema,
   async run(c) {
+    const tokenIn = c.options["token-in"];
+    const tokenOut = c.options["token-out"];
+    const amountInWei = c.options["amount-in"];
+    const slippage = c.options.slippage;
+    const deadlineSeconds = c.options.deadline;
+    if (!isAddress(tokenIn) || !isAddress(tokenOut)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: "token-in and token-out must both be valid 0x-prefixed 20-byte addresses."
+      });
+    }
+    const inAddress = checksumAddress2(tokenIn);
+    const outAddress = checksumAddress2(tokenOut);
+    let amountInRaw;
+    try {
+      amountInRaw = BigInt(amountInWei);
+    } catch {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: `Invalid amount-in: "${amountInWei}". Provide a valid integer in wei.`
+      });
+    }
+    if (amountInRaw <= 0n) {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: "amount-in must be a positive integer."
+      });
+    }
+    if (slippage < 0 || slippage > 100) {
+      return c.error({
+        code: "INVALID_SLIPPAGE",
+        message: `Slippage must be between 0 and 100. Got: ${slippage}`
+      });
+    }
     const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
-    const gaugePools = await discoverGaugePools(client);
-    if (!gaugePools.length) {
-      return c.ok({ gauges: [], count: 0 });
+    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;
+    });
+    if (pairPools.length === 0) {
+      return c.error({
+        code: "POOL_NOT_FOUND",
+        message: `No Slipstream pool found for pair ${inAddress}/${outAddress}.`
+      });
     }
-    const details = await client.multicall({
-      allowFailure: false,
-      contracts: gaugePools.flatMap(({ gauge }) => [
-        {
-          abi: gaugeAbi,
-          address: gauge,
-          functionName: "rewardToken"
-        },
-        {
-          abi: gaugeAbi,
-          address: gauge,
-          functionName: "rewardRate"
-        },
-        {
-          abi: gaugeAbi,
-          address: gauge,
-          functionName: "totalSupply"
-        },
-        {
-          abi: gaugeAbi,
-          address: gauge,
-          functionName: "periodFinish"
-        },
+    const selectedPool = [...pairPools].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);
+    const quote = await client.readContract({
+      abi: quoterV2Abi,
+      address: ABOREAN_CL_ADDRESSES.quoterV2,
+      functionName: "quoteExactInputSingle",
+      args: [
         {
-          abi: voterAbi,
-          address: ABOREAN_V2_ADDRESSES.voter,
-          functionName: "claimable",
-          args: [gauge]
+          tokenIn: inAddress,
+          tokenOut: outAddress,
+          amountIn: amountInRaw,
+          tickSpacing: selectedPool.tickSpacing,
+          sqrtPriceLimitX96: 0n
         }
-      ])
+      ]
+    });
+    const quotedAmountOut = quote[0];
+    const slippageBps = BigInt(Math.round(slippage * 100));
+    const amountOutMinimum = quotedAmountOut - quotedAmountOut * slippageBps / 10000n;
+    const account = resolveAccount(c.env);
+    const deadlineTimestamp = BigInt(Math.floor(Date.now() / 1e3) + deadlineSeconds);
+    const txResult = await aboreanWriteTx({
+      env: c.env,
+      options: {
+        "dry-run": c.options["dry-run"],
+        "gas-limit": c.options["gas-limit"],
+        "max-fee": c.options["max-fee"],
+        nonce: c.options.nonce
+      },
+      address: ABOREAN_CL_ADDRESSES.swapRouter,
+      abi: swapRouterAbi,
+      functionName: "exactInputSingle",
+      args: [
+        {
+          tokenIn: inAddress,
+          tokenOut: outAddress,
+          tickSpacing: selectedPool.tickSpacing,
+          recipient: account.address,
+          deadline: deadlineTimestamp,
+          amountIn: amountInRaw,
+          amountOutMinimum,
+          sqrtPriceLimitX96: 0n
+        }
+      ]
+    });
+    const amountInDecimal = formatUnits(amountInRaw, inMeta.decimals);
+    const quotedOutDecimal = formatUnits(quotedAmountOut, outMeta.decimals);
+    const minOutDecimal = formatUnits(amountOutMinimum, outMeta.decimals);
+    return c.ok({
+      pool: checksumAddress2(selectedPool.pool),
+      tokenIn: inMeta,
+      tokenOut: outMeta,
+      amountIn: { raw: amountInRaw.toString(), decimal: amountInDecimal },
+      quotedAmountOut: { raw: quotedAmountOut.toString(), decimal: quotedOutDecimal },
+      amountOutMinimum: { raw: amountOutMinimum.toString(), decimal: minOutDecimal },
+      slippagePercent: slippage,
+      deadlineSeconds,
+      tx: txResult
+    });
+  }
+});
+var nfpmMintAbi = [
+  {
+    type: "function",
+    name: "mint",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "token0", type: "address" },
+          { name: "token1", type: "address" },
+          { name: "tickSpacing", type: "int24" },
+          { name: "tickLower", type: "int24" },
+          { name: "tickUpper", type: "int24" },
+          { name: "amount0Desired", type: "uint256" },
+          { name: "amount1Desired", type: "uint256" },
+          { name: "amount0Min", type: "uint256" },
+          { name: "amount1Min", type: "uint256" },
+          { name: "recipient", type: "address" },
+          { name: "deadline", type: "uint256" },
+          { name: "sqrtPriceX96", type: "uint160" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "tokenId", type: "uint256" },
+      { name: "liquidity", type: "uint128" },
+      { name: "amount0", type: "uint256" },
+      { name: "amount1", type: "uint256" }
+    ]
+  }
+];
+var nfpmDecreaseLiquidityAbi = [
+  {
+    type: "function",
+    name: "decreaseLiquidity",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenId", type: "uint256" },
+          { name: "liquidity", type: "uint128" },
+          { name: "amount0Min", type: "uint256" },
+          { name: "amount1Min", type: "uint256" },
+          { name: "deadline", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "amount0", type: "uint256" },
+      { name: "amount1", type: "uint256" }
+    ]
+  }
+];
+var nfpmCollectAbi = [
+  {
+    type: "function",
+    name: "collect",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenId", type: "uint256" },
+          { name: "recipient", type: "address" },
+          { name: "amount0Max", type: "uint128" },
+          { name: "amount1Max", type: "uint128" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "amount0", type: "uint256" },
+      { name: "amount1", type: "uint256" }
+    ]
+  }
+];
+var nfpmBurnAbi = [
+  {
+    type: "function",
+    name: "burn",
+    stateMutability: "payable",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: []
+  }
+];
+var erc20ApproveAbi = [
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "account", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+var amountSchema = z2.object({
+  raw: z2.string(),
+  decimal: z2.string()
+});
+cl.command("add-position", {
+  description: "Mint a new concentrated liquidity position via the NonfungiblePositionManager. Approves both tokens if needed. Supports --dry-run.",
+  options: z2.object({
+    "token-a": z2.string().describe("First token address"),
+    "token-b": z2.string().describe("Second token address"),
+    "tick-spacing": z2.coerce.number().int().describe("Pool tick spacing"),
+    "tick-lower": z2.coerce.number().int().describe("Lower tick boundary"),
+    "tick-upper": z2.coerce.number().int().describe("Upper tick boundary"),
+    "amount-0": z2.string().describe("Desired amount of token0 in wei"),
+    "amount-1": z2.string().describe("Desired amount of token1 in wei"),
+    slippage: z2.coerce.number().default(0.5).describe("Slippage tolerance in percent (default: 0.5)"),
+    deadline: z2.coerce.number().int().default(300).describe("Transaction deadline in seconds from now (default: 300)"),
+    ...writeOptions.shape
+  }),
+  env: writeEnv,
+  output: z2.object({
+    pool: z2.string(),
+    token0: tokenSchema,
+    token1: tokenSchema,
+    tickSpacing: z2.number(),
+    tickLower: z2.number(),
+    tickUpper: z2.number(),
+    amount0Desired: amountSchema,
+    amount1Desired: amountSchema,
+    amount0Min: amountSchema,
+    amount1Min: amountSchema,
+    slippagePercent: z2.number(),
+    tx: z2.union([
+      z2.object({
+        txHash: z2.string(),
+        blockNumber: z2.number(),
+        gasUsed: z2.string()
+      }),
+      z2.object({
+        dryRun: z2.literal(true),
+        estimatedGas: z2.string(),
+        simulationResult: z2.unknown()
+      })
+    ])
+  }),
+  async run(c) {
+    const tokenARaw = c.options["token-a"];
+    const tokenBRaw = c.options["token-b"];
+    if (!isAddress(tokenARaw) || !isAddress(tokenBRaw)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: "token-a and token-b must both be valid 0x-prefixed 20-byte addresses."
+      });
+    }
+    const addrA = checksumAddress2(tokenARaw);
+    const addrB = checksumAddress2(tokenBRaw);
+    const [token0, token1] = addrA.toLowerCase() < addrB.toLowerCase() ? [addrA, addrB] : [addrB, addrA];
+    let amount0Desired;
+    let amount1Desired;
+    try {
+      const amountForA = BigInt(c.options["amount-0"]);
+      const amountForB = BigInt(c.options["amount-1"]);
+      if (addrA.toLowerCase() < addrB.toLowerCase()) {
+        amount0Desired = amountForA;
+        amount1Desired = amountForB;
+      } else {
+        amount0Desired = amountForB;
+        amount1Desired = amountForA;
+      }
+    } catch {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: "amount-0 and amount-1 must be valid integers in wei."
+      });
+    }
+    if (amount0Desired <= 0n && amount1Desired <= 0n) {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: "At least one of amount-0 or amount-1 must be positive."
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const allPools = await listPoolAddresses(client);
+    const poolStates = await readPoolStates(client, allPools);
+    const matchingPool = poolStates.find(
+      (pool) => normalizeAddress(pool.token0) === normalizeAddress(token0) && normalizeAddress(pool.token1) === normalizeAddress(token1) && pool.tickSpacing === c.options["tick-spacing"]
+    );
+    if (!matchingPool) {
+      return c.error({
+        code: "POOL_NOT_FOUND",
+        message: `No Slipstream pool found for ${checksumAddress2(token0)}/${checksumAddress2(token1)} with tick spacing ${c.options["tick-spacing"]}.`
+      });
+    }
+    const tokenMeta = await readTokenMetadata(client, [token0, token1]);
+    const meta0 = tokenMeta.get(token0) ?? toTokenMetaFallback(token0);
+    const meta1 = tokenMeta.get(token1) ?? toTokenMetaFallback(token1);
+    const slippageBps = BigInt(Math.round(c.options.slippage * 100));
+    const amount0Min = amount0Desired - amount0Desired * slippageBps / 10000n;
+    const amount1Min = amount1Desired - amount1Desired * slippageBps / 10000n;
+    const deadlineTimestamp = BigInt(Math.floor(Date.now() / 1e3) + c.options.deadline);
+    const account = resolveAccount(c.env);
+    const nfpmAddress = ABOREAN_CL_ADDRESSES.nonfungiblePositionManager;
+    if (!c.options["dry-run"]) {
+      for (const [token, amount] of [
+        [token0, amount0Desired],
+        [token1, amount1Desired]
+      ]) {
+        if (amount <= 0n) continue;
+        const currentAllowance = await client.readContract({
+          abi: erc20ApproveAbi,
+          address: token,
+          functionName: "allowance",
+          args: [account.address, nfpmAddress]
+        });
+        if (currentAllowance < amount) {
+          await aboreanWriteTx({
+            env: c.env,
+            options: { ...c.options, "dry-run": false },
+            address: token,
+            abi: erc20ApproveAbi,
+            functionName: "approve",
+            args: [nfpmAddress, amount]
+          });
+        }
+      }
+    }
+    const txResult = await aboreanWriteTx({
+      env: c.env,
+      options: {
+        "dry-run": c.options["dry-run"],
+        "gas-limit": c.options["gas-limit"],
+        "max-fee": c.options["max-fee"],
+        nonce: c.options.nonce
+      },
+      address: nfpmAddress,
+      abi: nfpmMintAbi,
+      functionName: "mint",
+      args: [
+        {
+          token0,
+          token1,
+          tickSpacing: c.options["tick-spacing"],
+          tickLower: c.options["tick-lower"],
+          tickUpper: c.options["tick-upper"],
+          amount0Desired,
+          amount1Desired,
+          amount0Min,
+          amount1Min,
+          recipient: account.address,
+          deadline: deadlineTimestamp,
+          sqrtPriceX96: 0n
+        }
+      ]
+    });
+    return c.ok({
+      pool: checksumAddress2(matchingPool.pool),
+      token0: meta0,
+      token1: meta1,
+      tickSpacing: c.options["tick-spacing"],
+      tickLower: c.options["tick-lower"],
+      tickUpper: c.options["tick-upper"],
+      amount0Desired: {
+        raw: amount0Desired.toString(),
+        decimal: formatUnits(amount0Desired, meta0.decimals)
+      },
+      amount1Desired: {
+        raw: amount1Desired.toString(),
+        decimal: formatUnits(amount1Desired, meta1.decimals)
+      },
+      amount0Min: {
+        raw: amount0Min.toString(),
+        decimal: formatUnits(amount0Min, meta0.decimals)
+      },
+      amount1Min: {
+        raw: amount1Min.toString(),
+        decimal: formatUnits(amount1Min, meta1.decimals)
+      },
+      slippagePercent: c.options.slippage,
+      tx: txResult
+    });
+  }
+});
+cl.command("remove-position", {
+  description: "Remove (close) a concentrated liquidity position. Decreases liquidity to zero, collects all tokens, and burns the NFT. Supports --dry-run.",
+  options: z2.object({
+    "token-id": z2.string().describe("Position NFT token ID"),
+    slippage: z2.coerce.number().default(0.5).describe("Slippage tolerance in percent (default: 0.5)"),
+    deadline: z2.coerce.number().int().default(300).describe("Transaction deadline in seconds from now (default: 300)"),
+    ...writeOptions.shape
+  }),
+  env: writeEnv,
+  output: z2.object({
+    tokenId: z2.string(),
+    pair: z2.string(),
+    token0: tokenSchema,
+    token1: tokenSchema,
+    tickLower: z2.number(),
+    tickUpper: z2.number(),
+    liquidity: z2.string(),
+    slippagePercent: z2.number(),
+    tx: z2.union([
+      z2.object({
+        txHash: z2.string(),
+        blockNumber: z2.number(),
+        gasUsed: z2.string()
+      }),
+      z2.object({
+        dryRun: z2.literal(true),
+        estimatedGas: z2.string(),
+        simulationResult: z2.unknown()
+      })
+    ])
+  }),
+  async run(c) {
+    let tokenId;
+    try {
+      tokenId = BigInt(c.options["token-id"]);
+    } catch {
+      return c.error({
+        code: "INVALID_TOKEN_ID",
+        message: `Invalid token-id: "${c.options["token-id"]}". Provide a valid integer.`
+      });
+    }
+    if (tokenId <= 0n) {
+      return c.error({
+        code: "INVALID_TOKEN_ID",
+        message: "token-id must be a positive integer."
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const nfpmAddress = ABOREAN_CL_ADDRESSES.nonfungiblePositionManager;
+    let positionData;
+    try {
+      positionData = await client.readContract({
+        abi: nonfungiblePositionManagerAbi,
+        address: nfpmAddress,
+        functionName: "positions",
+        args: [tokenId]
+      });
+    } catch {
+      return c.error({
+        code: "POSITION_NOT_FOUND",
+        message: `Position with tokenId ${tokenId.toString()} not found.`
+      });
+    }
+    const token0 = positionData[2];
+    const token1 = positionData[3];
+    const tickLower = positionData[5];
+    const tickUpper = positionData[6];
+    const liquidity = positionData[7];
+    if (liquidity === 0n) {
+      return c.error({
+        code: "ZERO_LIQUIDITY",
+        message: `Position ${tokenId.toString()} has zero liquidity. Nothing to remove.`
+      });
+    }
+    const tokenMeta = await readTokenMetadata(client, [token0, token1]);
+    const meta0 = tokenMeta.get(token0) ?? toTokenMetaFallback(token0);
+    const meta1 = tokenMeta.get(token1) ?? toTokenMetaFallback(token1);
+    const account = resolveAccount(c.env);
+    const deadlineTimestamp = BigInt(Math.floor(Date.now() / 1e3) + c.options.deadline);
+    const txResult = await aboreanWriteTx({
+      env: c.env,
+      options: {
+        "dry-run": c.options["dry-run"],
+        "gas-limit": c.options["gas-limit"],
+        "max-fee": c.options["max-fee"],
+        nonce: c.options.nonce
+      },
+      address: nfpmAddress,
+      abi: nfpmDecreaseLiquidityAbi,
+      functionName: "decreaseLiquidity",
+      args: [
+        {
+          tokenId,
+          liquidity,
+          amount0Min: 0n,
+          amount1Min: 0n,
+          deadline: deadlineTimestamp
+        }
+      ]
+    });
+    if (!c.options["dry-run"]) {
+      const maxUint128 = (1n << 128n) - 1n;
+      await aboreanWriteTx({
+        env: c.env,
+        options: { ...c.options, "dry-run": false },
+        address: nfpmAddress,
+        abi: nfpmCollectAbi,
+        functionName: "collect",
+        args: [
+          {
+            tokenId,
+            recipient: account.address,
+            amount0Max: maxUint128,
+            amount1Max: maxUint128
+          }
+        ]
+      });
+      await aboreanWriteTx({
+        env: c.env,
+        options: { ...c.options, "dry-run": false },
+        address: nfpmAddress,
+        abi: nfpmBurnAbi,
+        functionName: "burn",
+        args: [tokenId]
+      });
+    }
+    return c.ok({
+      tokenId: tokenId.toString(),
+      pair: `${meta0.symbol}/${meta1.symbol}`,
+      token0: meta0,
+      token1: meta1,
+      tickLower,
+      tickUpper,
+      liquidity: liquidity.toString(),
+      slippagePercent: c.options.slippage,
+      tx: txResult
+    });
+  }
+});
+
+// src/commands/gauges.ts
+import { isAddress as isAddress2 } from "@spectratools/cli-shared";
+import { Cli as Cli2, z as z3 } from "incur";
+var env2 = z3.object({
+  ABSTRACT_RPC_URL: z3.string().optional().describe("Abstract RPC URL override")
+});
+var erc20ApproveAbi2 = [
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "account", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+var gaugeDepositAbi = [
+  {
+    type: "function",
+    name: "deposit",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "amount", type: "uint256" }],
+    outputs: []
+  }
+];
+var gaugeDepositWithTokenIdAbi = [
+  {
+    type: "function",
+    name: "deposit",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+var gaugeWithdrawAbi = [
+  {
+    type: "function",
+    name: "withdraw",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "amount", type: "uint256" }],
+    outputs: []
+  }
+];
+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]
+      }))
+    }) : Promise.resolve([]),
+    clIndices.length ? client.multicall({
+      allowFailure: false,
+      contracts: clIndices.map((index) => ({
+        abi: clFactoryAbi,
+        address: ABOREAN_CL_ADDRESSES.clFactory,
+        functionName: "allPools",
+        args: [index]
+      }))
+    }) : Promise.resolve([])
+  ]);
+  const pools2 = [...v2Pools, ...clPools];
+  if (!pools2.length) return [];
+  const gauges2 = await client.multicall({
+    allowFailure: false,
+    contracts: pools2.map((pool) => ({
+      abi: voterAbi,
+      address: ABOREAN_V2_ADDRESSES.voter,
+      functionName: "gauges",
+      args: [pool]
+    }))
+  });
+  return pools2.map((pool, index) => ({ pool, gauge: gauges2[index] })).filter(({ gauge }) => gauge.toLowerCase() !== ZERO_ADDRESS.toLowerCase());
+}
+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: env2,
+  output: z3.object({
+    gauges: z3.array(
+      z3.object({
+        pool: z3.string(),
+        gauge: z3.string(),
+        rewardToken: z3.string(),
+        rewardRate: z3.string(),
+        totalStaked: z3.string(),
+        claimableEmissions: z3.string(),
+        periodFinish: z3.number(),
+        periodFinishRelative: z3.string()
+      })
+    ),
+    count: z3.number()
+  }),
+  examples: [{ description: "List all active gauges and current emissions state" }],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const gaugePools = await discoverGaugePools(client);
+    if (!gaugePools.length) {
+      return c.ok({ gauges: [], count: 0 });
+    }
+    const details = await client.multicall({
+      allowFailure: false,
+      contracts: gaugePools.flatMap(({ gauge }) => [
+        {
+          abi: gaugeAbi,
+          address: gauge,
+          functionName: "rewardToken"
+        },
+        {
+          abi: gaugeAbi,
+          address: gauge,
+          functionName: "rewardRate"
+        },
+        {
+          abi: gaugeAbi,
+          address: gauge,
+          functionName: "totalSupply"
+        },
+        {
+          abi: gaugeAbi,
+          address: gauge,
+          functionName: "periodFinish"
+        },
+        {
+          abi: voterAbi,
+          address: ABOREAN_V2_ADDRESSES.voter,
+          functionName: "claimable",
+          args: [gauge]
+        }
+      ])
     });
     const items = gaugePools.map(({ pool, gauge }, index) => {
       const offset = index * 5;
@@ -1863,27 +2629,27 @@ gauges.command("list", {
 });
 gauges.command("info", {
   description: "Get detailed state for one gauge address.",
-  args: z2.object({
-    gauge: z2.string().describe("Gauge contract address")
+  args: z3.object({
+    gauge: z3.string().describe("Gauge contract address")
   }),
   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()
+  output: z3.object({
+    gauge: z3.string(),
+    pool: z3.string(),
+    isAlive: z3.boolean(),
+    stakingToken: z3.string(),
+    rewardToken: z3.string(),
+    totalStaked: z3.string(),
+    rewardRate: z3.string(),
+    rewardPerTokenStored: z3.string(),
+    fees0: z3.string(),
+    fees1: z3.string(),
+    left: z3.string(),
+    periodFinish: z3.number(),
+    periodFinishRelative: z3.string(),
+    lastUpdateTime: z3.number(),
+    bribeContract: z3.string(),
+    feeContract: z3.string()
   }),
   examples: [
     {
@@ -2029,22 +2795,22 @@ gauges.command("info", {
 });
 gauges.command("staked", {
   description: "Show one address staking positions across all gauges.",
-  args: z2.object({
-    address: z2.string().describe("Wallet address to inspect")
+  args: z3.object({
+    address: z3.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()
+  output: z3.object({
+    address: z3.string(),
+    positions: z3.array(
+      z3.object({
+        pool: z3.string(),
+        gauge: z3.string(),
+        rewardToken: z3.string(),
+        staked: z3.string(),
+        earned: z3.string()
       })
     ),
-    count: z2.number()
+    count: z3.number()
   }),
   examples: [
     {
@@ -2132,14 +2898,194 @@ gauges.command("staked", {
     );
   }
 });
+gauges.command("deposit", {
+  description: "Deposit LP tokens into a gauge for staking rewards. Optionally attach a veNFT tokenId for boosted emissions. Approves the gauge to spend LP tokens if needed.",
+  options: z3.object({
+    gauge: z3.string().describe("Gauge contract address"),
+    amount: z3.string().describe("Amount of LP tokens to deposit (in wei)"),
+    "token-id": z3.coerce.number().int().nonnegative().optional().describe("veNFT token id for boosted emissions")
+  }).merge(writeOptions),
+  env: writeEnv,
+  output: z3.object({
+    gauge: z3.string(),
+    stakingToken: z3.string(),
+    amount: z3.string(),
+    tokenId: z3.number().nullable(),
+    tx: z3.union([
+      z3.object({
+        txHash: z3.string(),
+        blockNumber: z3.number(),
+        gasUsed: z3.string()
+      }),
+      z3.object({
+        dryRun: z3.literal(true),
+        estimatedGas: z3.string(),
+        simulationResult: z3.unknown()
+      })
+    ])
+  }),
+  examples: [
+    {
+      options: {
+        gauge: "0x0000000000000000000000000000000000000001",
+        amount: "1000000000000000000",
+        "dry-run": true
+      },
+      description: "Dry-run deposit 1e18 LP tokens into a gauge"
+    },
+    {
+      options: {
+        gauge: "0x0000000000000000000000000000000000000001",
+        amount: "1000000000000000000",
+        "token-id": 42
+      },
+      description: "Deposit with veNFT boost"
+    }
+  ],
+  async run(c) {
+    const gaugeAddress = c.options.gauge;
+    if (!isAddress2(gaugeAddress)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: `Invalid gauge address: "${gaugeAddress}". Use a valid 0x-prefixed 20-byte hex address.`
+      });
+    }
+    const amount = BigInt(c.options.amount);
+    if (amount <= 0n) {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: "amount must be a positive integer in wei."
+      });
+    }
+    const gauge = gaugeAddress;
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const isAlive = await client.readContract({
+      abi: voterAbi,
+      address: ABOREAN_V2_ADDRESSES.voter,
+      functionName: "isAlive",
+      args: [gauge]
+    });
+    if (!isAlive) {
+      return c.error({
+        code: "GAUGE_NOT_ALIVE",
+        message: `Gauge ${toChecksum(gauge)} is not alive.`,
+        retryable: false
+      });
+    }
+    const stakingToken = await client.readContract({
+      abi: gaugeAbi,
+      address: gauge,
+      functionName: "stakingToken"
+    });
+    const account = resolveAccount(c.env);
+    if (!c.options["dry-run"]) {
+      const currentAllowance = await client.readContract({
+        abi: erc20ApproveAbi2,
+        address: stakingToken,
+        functionName: "allowance",
+        args: [account.address, gauge]
+      });
+      if (currentAllowance < amount) {
+        await aboreanWriteTx({
+          env: c.env,
+          options: { ...c.options, "dry-run": false },
+          address: stakingToken,
+          abi: erc20ApproveAbi2,
+          functionName: "approve",
+          args: [gauge, amount]
+        });
+      }
+    }
+    const tokenId = c.options["token-id"];
+    const tx = await aboreanWriteTx({
+      env: c.env,
+      options: c.options,
+      address: gauge,
+      abi: tokenId !== void 0 ? gaugeDepositWithTokenIdAbi : gaugeDepositAbi,
+      functionName: "deposit",
+      args: tokenId !== void 0 ? [amount, BigInt(tokenId)] : [amount]
+    });
+    return c.ok({
+      gauge: toChecksum(gauge),
+      stakingToken: toChecksum(stakingToken),
+      amount: amount.toString(),
+      tokenId: tokenId !== void 0 ? tokenId : null,
+      tx
+    });
+  }
+});
+gauges.command("withdraw", {
+  description: "Withdraw LP tokens from a gauge.",
+  options: z3.object({
+    gauge: z3.string().describe("Gauge contract address"),
+    amount: z3.string().describe("Amount of LP tokens to withdraw (in wei)")
+  }).merge(writeOptions),
+  env: writeEnv,
+  output: z3.object({
+    gauge: z3.string(),
+    amount: z3.string(),
+    tx: z3.union([
+      z3.object({
+        txHash: z3.string(),
+        blockNumber: z3.number(),
+        gasUsed: z3.string()
+      }),
+      z3.object({
+        dryRun: z3.literal(true),
+        estimatedGas: z3.string(),
+        simulationResult: z3.unknown()
+      })
+    ])
+  }),
+  examples: [
+    {
+      options: {
+        gauge: "0x0000000000000000000000000000000000000001",
+        amount: "1000000000000000000",
+        "dry-run": true
+      },
+      description: "Dry-run withdraw 1e18 LP tokens from a gauge"
+    }
+  ],
+  async run(c) {
+    const gaugeAddress = c.options.gauge;
+    if (!isAddress2(gaugeAddress)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: `Invalid gauge address: "${gaugeAddress}". Use a valid 0x-prefixed 20-byte hex address.`
+      });
+    }
+    const amount = BigInt(c.options.amount);
+    if (amount <= 0n) {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: "amount must be a positive integer in wei."
+      });
+    }
+    const gauge = gaugeAddress;
+    const tx = await aboreanWriteTx({
+      env: c.env,
+      options: c.options,
+      address: gauge,
+      abi: gaugeWithdrawAbi,
+      functionName: "withdraw",
+      args: [amount]
+    });
+    return c.ok({
+      gauge: toChecksum(gauge),
+      amount: amount.toString(),
+      tx
+    });
+  }
+});
 
 // 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 { checksumAddress as checksumAddress3, isAddress as isAddress3 } from "@spectratools/cli-shared";
+import { Cli as Cli3, z as z4 } 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 env3 = z4.object({
+  ABSTRACT_RPC_URL: z4.string().optional().describe("Abstract RPC URL override")
 });
 var morphoAbi = [
   {
@@ -2220,27 +3166,27 @@ var erc20MetadataAbi2 = [
     outputs: [{ type: "uint8" }]
   }
 ];
-var tokenMetaSchema = z3.object({
-  address: z3.string(),
-  symbol: z3.string(),
-  decimals: z3.number()
+var tokenMetaSchema = z4.object({
+  address: z4.string(),
+  symbol: z4.string(),
+  decimals: z4.number()
 });
-var lendingMarketRowSchema = z3.object({
-  marketId: z3.string(),
+var lendingMarketRowSchema = z4.object({
+  marketId: z4.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()
+  oracle: z4.string(),
+  irm: z4.string(),
+  lltvBps: z4.number(),
+  lltvPercent: z4.number(),
+  totalSupplyAssets: z4.string(),
+  totalBorrowAssets: z4.string(),
+  totalSupplyShares: z4.string(),
+  totalBorrowShares: z4.string(),
+  availableLiquidityAssets: z4.string(),
+  utilization: z4.number().nullable(),
+  feeWad: z4.string(),
+  lastUpdate: z4.number()
 });
 function isMarketId(value) {
   return /^0x[0-9a-fA-F]{64}$/.test(value);
@@ -2476,21 +3422,21 @@ var lending = Cli3.create("lending", {
 });
 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")
+  args: z4.object({
+    limit: z4.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()
+  output: z4.object({
+    morpho: z4.string(),
+    marketCount: z4.number(),
+    markets: z4.array(lendingMarketRowSchema),
+    totalsByLoanToken: z4.array(
+      z4.object({
+        token: z4.string(),
+        symbol: z4.string(),
+        decimals: z4.number(),
+        totalSupplyAssets: z4.string(),
+        totalBorrowAssets: z4.string()
       })
     )
   }),
@@ -2537,8 +3483,8 @@ lending.command("markets", {
 });
 lending.command("market", {
   description: "Get details for one Morpho market id (bytes32).",
-  args: z3.object({
-    marketId: z3.string().describe("Morpho market id (bytes32 hex)")
+  args: z4.object({
+    marketId: z4.string().describe("Morpho market id (bytes32 hex)")
   }),
   env: env3,
   output: lendingMarketRowSchema,
@@ -2598,29 +3544,29 @@ lending.command("market", {
 });
 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")
+  args: z4.object({
+    marketId: z4.string().describe("Morpho market id (bytes32 hex)"),
+    user: z4.string().describe("Position owner address")
   }),
   env: env3,
-  output: z3.object({
-    marketId: z3.string(),
-    user: z3.string(),
+  output: z4.object({
+    marketId: z4.string(),
+    user: z4.string(),
     loanToken: tokenMetaSchema,
     collateralToken: tokenMetaSchema,
-    supplyShares: z3.string(),
-    supplyAssetsEstimate: z3.object({
-      raw: z3.string(),
-      decimal: z3.string()
+    supplyShares: z4.string(),
+    supplyAssetsEstimate: z4.object({
+      raw: z4.string(),
+      decimal: z4.string()
     }),
-    borrowShares: z3.string(),
-    borrowAssetsEstimate: z3.object({
-      raw: z3.string(),
-      decimal: z3.string()
+    borrowShares: z4.string(),
+    borrowAssetsEstimate: z4.object({
+      raw: z4.string(),
+      decimal: z4.string()
     }),
-    collateralAssets: z3.object({
-      raw: z3.string(),
-      decimal: z3.string()
+    collateralAssets: z4.object({
+      raw: z4.string(),
+      decimal: z4.string()
     })
   }),
   examples: [
@@ -2639,7 +3585,7 @@ lending.command("position", {
         message: "marketId must be a 32-byte hex string (0x + 64 hex chars)"
       });
     }
-    if (!isAddress2(c.args.user)) {
+    if (!isAddress3(c.args.user)) {
       return c.error({
         code: "INVALID_ARGUMENT",
         message: "user must be a valid address"
@@ -2750,39 +3696,87 @@ lending.command("position", {
 });
 
 // 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 { checksumAddress as checksumAddress4, isAddress as isAddress4 } from "@spectratools/cli-shared";
+import { Cli as Cli4, z as z5 } 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 DEFAULT_SLIPPAGE_PERCENT2 = 0.5;
+var DEFAULT_DEADLINE_SECONDS2 = 300;
+var erc20ApproveAbi3 = [
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "account", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+var v2RouterSwapAbi = [
+  {
+    type: "function",
+    name: "swapExactTokensForTokens",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amountIn", type: "uint256" },
+      { name: "amountOutMin", type: "uint256" },
+      {
+        name: "routes",
+        type: "tuple[]",
+        components: [
+          { name: "from", type: "address" },
+          { name: "to", type: "address" },
+          { name: "stable", type: "bool" },
+          { name: "factory", type: "address" }
+        ]
+      },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ name: "amounts", type: "uint256[]" }]
+  }
+];
+var env4 = z5.object({
+  ABSTRACT_RPC_URL: z5.string().optional().describe("Abstract RPC URL override")
 });
-var tokenSchema2 = z4.object({
-  address: z4.string(),
-  symbol: z4.string(),
-  decimals: z4.number()
+var tokenSchema2 = z5.object({
+  address: z5.string(),
+  symbol: z5.string(),
+  decimals: z5.number()
 });
-var amountSchema = z4.object({
-  raw: z4.string(),
-  decimal: z4.string()
+var amountSchema2 = z5.object({
+  raw: z5.string(),
+  decimal: z5.string()
 });
-var feeSchema = z4.object({
-  feeBps: z4.number(),
-  feePercent: z4.number()
+var feeSchema = z5.object({
+  feeBps: z5.number(),
+  feePercent: z5.number()
 }).nullable();
-var poolSummarySchema = z4.object({
-  pool: z4.string(),
-  pair: z4.string(),
-  stable: z4.boolean(),
-  poolType: z4.enum(["stable", "volatile"]),
+var poolSummarySchema = z5.object({
+  pool: z5.string(),
+  pair: z5.string(),
+  stable: z5.boolean(),
+  poolType: z5.enum(["stable", "volatile"]),
   token0: tokenSchema2,
   token1: tokenSchema2,
-  reserves: z4.object({
-    token0: amountSchema,
-    token1: amountSchema,
-    blockTimestampLast: z4.number()
+  reserves: z5.object({
+    token0: amountSchema2,
+    token1: amountSchema2,
+    blockTimestampLast: z5.number()
   }),
-  totalSupply: z4.string(),
+  totalSupply: z5.string(),
   fee: feeSchema
 });
 var erc20MetadataAbi3 = [
@@ -2987,17 +3981,17 @@ var pools = Cli4.create("pools", {
 });
 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)")
+  options: z5.object({
+    offset: z5.coerce.number().int().nonnegative().default(0).describe("Pool index offset"),
+    limit: z5.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)
+  output: z5.object({
+    total: z5.number(),
+    offset: z5.number(),
+    limit: z5.number(),
+    count: z5.number(),
+    pools: z5.array(poolSummarySchema)
   }),
   async run(c) {
     const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
@@ -3073,105 +4067,303 @@ pools.command("list", {
     );
   }
 });
-pools.command("pool", {
-  description: "Get detailed state for one V2 pool.",
-  args: z4.object({
-    address: z4.string().describe("Pool address")
+pools.command("pool", {
+  description: "Get detailed state for one V2 pool.",
+  args: z5.object({
+    address: z5.string().describe("Pool address")
+  }),
+  env: env4,
+  output: z5.object({
+    pool: poolSummarySchema.extend({
+      poolFees: z5.string(),
+      factory: z5.string()
+    })
+  }),
+  async run(c) {
+    if (!isAddress4(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 }]);
+    const summary = toPoolSummary(
+      {
+        pool: poolAddress,
+        token0,
+        token1,
+        stable,
+        reserve0: reserves[0],
+        reserve1: reserves[1],
+        blockTimestampLast: reserves[2],
+        totalSupply
+      },
+      tokenMeta,
+      fee ?? null
+    );
+    return c.ok(
+      {
+        pool: {
+          ...summary,
+          poolFees: checksumAddress4(poolFees),
+          factory: checksumAddress4(factory)
+        }
+      },
+      c.format === "json" || c.format === "jsonl" ? void 0 : {
+        cta: {
+          description: "Next steps:",
+          commands: [
+            {
+              command: "pools quote",
+              args: {
+                tokenIn: summary.token0.address,
+                tokenOut: summary.token1.address,
+                amountIn: "1"
+              },
+              description: `Quote a ${summary.token0.symbol} \u2192 ${summary.token1.symbol} swap`
+            },
+            {
+              command: "pools fees",
+              args: { pool: checksumAddress4(poolAddress) },
+              description: "Check fee configuration"
+            }
+          ]
+        }
+      }
+    );
+  }
+});
+pools.command("quote", {
+  description: "Quote a single-hop V2 swap between tokenIn and tokenOut.",
+  args: z5.object({
+    tokenIn: z5.string().describe("Input token address"),
+    tokenOut: z5.string().describe("Output token address"),
+    amountIn: z5.string().describe("Input amount in human-readable decimal units")
+  }),
+  options: z5.object({
+    stable: z5.boolean().default(false).describe("Use stable pool route (default: volatile)")
+  }),
+  env: env4,
+  output: z5.object({
+    pool: z5.string(),
+    stable: z5.boolean(),
+    tokenIn: tokenSchema2,
+    tokenOut: tokenSchema2,
+    amountIn: amountSchema2,
+    amountOut: amountSchema2,
+    priceOutPerIn: z5.number().nullable()
+  }),
+  async run(c) {
+    if (!isAddress4(c.args.tokenIn) || !isAddress4(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)
+      },
+      c.format === "json" || c.format === "jsonl" ? void 0 : {
+        cta: {
+          description: "Related commands:",
+          commands: [
+            {
+              command: "pools pool",
+              args: { address: checksumAddress4(poolAddress) },
+              description: "Inspect the pool used for this quote"
+            },
+            {
+              command: "pools quote",
+              args: {
+                tokenIn: outMeta.address,
+                tokenOut: inMeta.address,
+                amountIn: amountOutDecimal
+              },
+              description: `Reverse quote ${outMeta.symbol} \u2192 ${inMeta.symbol}`
+            }
+          ]
+        }
+      }
+    );
+  }
+});
+pools.command("fees", {
+  description: "Read V2 fee configuration for a pool address.",
+  args: z5.object({
+    pool: z5.string().describe("Pool address")
   }),
   env: env4,
-  output: z4.object({
-    pool: poolSummarySchema.extend({
-      poolFees: z4.string(),
-      factory: z4.string()
-    })
+  output: z5.object({
+    pool: z5.string(),
+    pair: z5.string(),
+    stable: z5.boolean(),
+    activeFee: feeSchema,
+    stableFee: feeSchema,
+    volatileFee: feeSchema
   }),
   async run(c) {
-    if (!isAddress3(c.args.address)) {
+    if (!isAddress4(c.args.pool)) {
       return c.error({
         code: "INVALID_ADDRESS",
-        message: `Invalid pool address: "${c.args.address}". Use a valid 0x-prefixed 20-byte hex 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 poolAddress = toAddress(c.args.address);
-    const [token0, token1, stable, reserves, totalSupply, poolFees, factory] = await multicallStrict2(client, [
+    const pool = toAddress(c.args.pool);
+    const [token0, token1, stable] = await multicallStrict2(client, [
       {
         abi: v2PoolAbi,
-        address: poolAddress,
+        address: pool,
         functionName: "token0"
       },
       {
         abi: v2PoolAbi,
-        address: poolAddress,
+        address: pool,
         functionName: "token1"
       },
       {
         abi: v2PoolAbi,
-        address: poolAddress,
+        address: pool,
         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 }]);
-    const summary = toPoolSummary(
-      {
-        pool: poolAddress,
-        token0,
-        token1,
-        stable,
-        reserve0: reserves[0],
-        reserve1: reserves[1],
-        blockTimestampLast: reserves[2],
-        totalSupply
-      },
-      tokenMeta,
-      fee ?? null
-    );
+    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: {
-          ...summary,
-          poolFees: checksumAddress4(poolFees),
-          factory: checksumAddress4(factory)
-        }
+        pool: checksumAddress4(pool),
+        pair: `${token0Meta.symbol}/${token1Meta.symbol}`,
+        stable,
+        activeFee: stable ? stableFee : volatileFee,
+        stableFee,
+        volatileFee
       },
       c.format === "json" || c.format === "jsonl" ? void 0 : {
         cta: {
-          description: "Next steps:",
+          description: "Related commands:",
           commands: [
+            {
+              command: "pools pool",
+              args: { address: checksumAddress4(pool) },
+              description: "View full pool state"
+            },
             {
               command: "pools quote",
               args: {
-                tokenIn: summary.token0.address,
-                tokenOut: summary.token1.address,
+                tokenIn: token0Meta.address,
+                tokenOut: token1Meta.address,
                 amountIn: "1"
               },
-              description: `Quote a ${summary.token0.symbol} \u2192 ${summary.token1.symbol} swap`
-            },
-            {
-              command: "pools fees",
-              args: { pool: checksumAddress4(poolAddress) },
-              description: "Check fee configuration"
+              description: `Quote a ${token0Meta.symbol} \u2192 ${token1Meta.symbol} swap`
             }
           ]
         }
@@ -3179,210 +4371,512 @@ pools.command("pool", {
     );
   }
 });
-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(),
+pools.command("swap", {
+  description: "Execute a single-hop V2 AMM swap. Quotes the expected output, applies slippage tolerance, approves the router if needed, and broadcasts the swap transaction.",
+  options: z5.object({
+    "token-in": z5.string().describe("Input token address"),
+    "token-out": z5.string().describe("Output token address"),
+    "amount-in": z5.string().describe("Input amount in wei"),
+    slippage: z5.coerce.number().min(0).max(100).default(DEFAULT_SLIPPAGE_PERCENT2).describe("Slippage tolerance in percent (default: 0.5)"),
+    deadline: z5.coerce.number().int().positive().default(DEFAULT_DEADLINE_SECONDS2).describe("Transaction deadline in seconds from now (default: 300)"),
+    stable: z5.boolean().default(false).describe("Use stable pool route (default: volatile)")
+  }).merge(writeOptions),
+  env: writeEnv,
+  output: z5.object({
+    pool: z5.string(),
+    stable: z5.boolean(),
     tokenIn: tokenSchema2,
     tokenOut: tokenSchema2,
-    amountIn: amountSchema,
-    amountOut: amountSchema,
-    priceOutPerIn: z4.number().nullable()
+    amountIn: amountSchema2,
+    expectedAmountOut: amountSchema2,
+    minAmountOut: amountSchema2,
+    slippagePercent: z5.number(),
+    effectivePrice: z5.number().nullable(),
+    tx: z5.union([
+      z5.object({
+        txHash: z5.string(),
+        blockNumber: z5.number(),
+        gasUsed: z5.string()
+      }),
+      z5.object({
+        dryRun: z5.literal(true),
+        estimatedGas: z5.string(),
+        simulationResult: z5.unknown()
+      })
+    ])
   }),
   async run(c) {
-    if (!isAddress3(c.args.tokenIn) || !isAddress3(c.args.tokenOut)) {
+    const tokenInRaw = c.options["token-in"];
+    const tokenOutRaw = c.options["token-out"];
+    if (!isAddress4(tokenInRaw) || !isAddress4(tokenOutRaw)) {
       return c.error({
         code: "INVALID_ADDRESS",
-        message: "tokenIn and tokenOut must both be valid 0x-prefixed 20-byte addresses."
+        message: "token-in and token-out must both be valid 0x-prefixed 20-byte addresses."
+      });
+    }
+    const tokenIn = toAddress(tokenInRaw);
+    const tokenOut = toAddress(tokenOutRaw);
+    const amountInRaw = BigInt(c.options["amount-in"]);
+    if (amountInRaw <= 0n) {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: "amount-in must be a positive integer in wei."
       });
     }
     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;
+    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 expectedAmountOut = amounts[amounts.length - 1] ?? 0n;
+    if (expectedAmountOut === 0n) {
+      return c.error({
+        code: "ZERO_QUOTE",
+        message: "Router returned zero output amount. The pool may have insufficient liquidity."
+      });
+    }
+    const slippageBps = Math.round(c.options.slippage * 100);
+    const minAmountOut = expectedAmountOut * BigInt(1e4 - slippageBps) / 10000n;
+    const deadlineTimestamp = BigInt(Math.floor(Date.now() / 1e3) + c.options.deadline);
+    const account = resolveAccount(c.env);
+    if (!c.options["dry-run"]) {
+      const currentAllowance = await client.readContract({
+        abi: erc20ApproveAbi3,
+        address: tokenIn,
+        functionName: "allowance",
+        args: [account.address, ABOREAN_V2_ADDRESSES.router]
+      });
+      if (currentAllowance < amountInRaw) {
+        await aboreanWriteTx({
+          env: c.env,
+          options: { ...c.options, "dry-run": false },
+          address: tokenIn,
+          abi: erc20ApproveAbi3,
+          functionName: "approve",
+          args: [ABOREAN_V2_ADDRESSES.router, amountInRaw]
+        });
+      }
+    }
+    const tx = await aboreanWriteTx({
+      env: c.env,
+      options: c.options,
+      address: ABOREAN_V2_ADDRESSES.router,
+      abi: v2RouterSwapAbi,
+      functionName: "swapExactTokensForTokens",
+      args: [
+        amountInRaw,
+        minAmountOut,
+        [
+          {
+            from: tokenIn,
+            to: tokenOut,
+            stable: c.options.stable,
+            factory: ABOREAN_V2_ADDRESSES.poolFactory
+          }
+        ],
+        account.address,
+        deadlineTimestamp
+      ]
+    });
+    const amountInDecimal = formatUnits3(amountInRaw, inMeta.decimals);
+    const expectedOutDecimal = formatUnits3(expectedAmountOut, outMeta.decimals);
+    const minOutDecimal = formatUnits3(minAmountOut, outMeta.decimals);
+    const ratio = Number(expectedOutDecimal) / Number(amountInDecimal);
+    return c.ok({
+      pool: checksumAddress4(poolAddress),
+      stable: c.options.stable,
+      tokenIn: inMeta,
+      tokenOut: outMeta,
+      amountIn: {
+        raw: amountInRaw.toString(),
+        decimal: amountInDecimal
+      },
+      expectedAmountOut: {
+        raw: expectedAmountOut.toString(),
+        decimal: expectedOutDecimal
+      },
+      minAmountOut: {
+        raw: minAmountOut.toString(),
+        decimal: minOutDecimal
+      },
+      slippagePercent: c.options.slippage,
+      effectivePrice: Number(amountInDecimal) === 0 ? null : finiteOrNull3(ratio),
+      tx
+    });
+  }
+});
+var v2RouterAddLiquidityAbi = [
+  {
+    type: "function",
+    name: "addLiquidity",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "tokenA", type: "address" },
+      { name: "tokenB", type: "address" },
+      { name: "stable", type: "bool" },
+      { name: "amountADesired", type: "uint256" },
+      { name: "amountBDesired", type: "uint256" },
+      { name: "amountAMin", type: "uint256" },
+      { name: "amountBMin", type: "uint256" },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [
+      { name: "amountA", type: "uint256" },
+      { name: "amountB", type: "uint256" },
+      { name: "liquidity", type: "uint256" }
+    ]
+  }
+];
+var v2RouterRemoveLiquidityAbi = [
+  {
+    type: "function",
+    name: "removeLiquidity",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "tokenA", type: "address" },
+      { name: "tokenB", type: "address" },
+      { name: "stable", type: "bool" },
+      { name: "liquidity", type: "uint256" },
+      { name: "amountAMin", type: "uint256" },
+      { name: "amountBMin", type: "uint256" },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [
+      { name: "amountA", type: "uint256" },
+      { name: "amountB", type: "uint256" }
+    ]
+  }
+];
+pools.command("add-liquidity", {
+  description: "Add liquidity to a V2 pool. Approves both tokens to the router if needed, then calls addLiquidity. Supports --dry-run.",
+  options: z5.object({
+    "token-a": z5.string().describe("First token address"),
+    "token-b": z5.string().describe("Second token address"),
+    "amount-a": z5.string().describe("Desired amount of token A in wei"),
+    "amount-b": z5.string().describe("Desired amount of token B in wei"),
+    slippage: z5.coerce.number().min(0).max(100).default(DEFAULT_SLIPPAGE_PERCENT2).describe("Slippage tolerance in percent (default: 0.5)"),
+    deadline: z5.coerce.number().int().positive().default(DEFAULT_DEADLINE_SECONDS2).describe("Transaction deadline in seconds from now (default: 300)"),
+    stable: z5.boolean().default(false).describe("Target stable pool (default: volatile)")
+  }).merge(writeOptions),
+  env: writeEnv,
+  output: z5.object({
+    pool: z5.string(),
+    stable: z5.boolean(),
+    tokenA: tokenSchema2,
+    tokenB: tokenSchema2,
+    amountADesired: amountSchema2,
+    amountBDesired: amountSchema2,
+    amountAMin: amountSchema2,
+    amountBMin: amountSchema2,
+    slippagePercent: z5.number(),
+    tx: z5.union([
+      z5.object({
+        txHash: z5.string(),
+        blockNumber: z5.number(),
+        gasUsed: z5.string()
+      }),
+      z5.object({
+        dryRun: z5.literal(true),
+        estimatedGas: z5.string(),
+        simulationResult: z5.unknown()
+      })
+    ])
+  }),
+  async run(c) {
+    const tokenARaw = c.options["token-a"];
+    const tokenBRaw = c.options["token-b"];
+    if (!isAddress4(tokenARaw) || !isAddress4(tokenBRaw)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: "token-a and token-b must both be valid 0x-prefixed 20-byte addresses."
+      });
+    }
+    const tokenA = toAddress(tokenARaw);
+    const tokenB = toAddress(tokenBRaw);
+    let amountADesired;
+    let amountBDesired;
+    try {
+      amountADesired = BigInt(c.options["amount-a"]);
+      amountBDesired = BigInt(c.options["amount-b"]);
+    } catch {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: "amount-a and amount-b must be valid integers in wei."
+      });
+    }
+    if (amountADesired <= 0n || amountBDesired <= 0n) {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: "amount-a and amount-b must be positive integers."
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const poolAddress = await client.readContract({
+      abi: poolFactoryAbi,
+      address: ABOREAN_V2_ADDRESSES.poolFactory,
+      functionName: "getPool",
+      args: [tokenA, tokenB, 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(tokenA)}/${checksumAddress4(tokenB)}.`
+      });
+    }
+    const tokenMeta = await readTokenMetadata3(client, [tokenA, tokenB]);
+    const aMeta = tokenMeta.get(tokenA.toLowerCase()) ?? fallbackTokenMeta(tokenA);
+    const bMeta = tokenMeta.get(tokenB.toLowerCase()) ?? fallbackTokenMeta(tokenB);
+    const slippageBps = Math.round(c.options.slippage * 100);
+    const amountAMin = amountADesired * BigInt(1e4 - slippageBps) / 10000n;
+    const amountBMin = amountBDesired * BigInt(1e4 - slippageBps) / 10000n;
+    const deadlineTimestamp = BigInt(Math.floor(Date.now() / 1e3) + c.options.deadline);
+    const account = resolveAccount(c.env);
+    if (!c.options["dry-run"]) {
+      for (const [token, amount] of [
+        [tokenA, amountADesired],
+        [tokenB, amountBDesired]
+      ]) {
+        const currentAllowance = await client.readContract({
+          abi: erc20ApproveAbi3,
+          address: token,
+          functionName: "allowance",
+          args: [account.address, ABOREAN_V2_ADDRESSES.router]
+        });
+        if (currentAllowance < amount) {
+          await aboreanWriteTx({
+            env: c.env,
+            options: { ...c.options, "dry-run": false },
+            address: token,
+            abi: erc20ApproveAbi3,
+            functionName: "approve",
+            args: [ABOREAN_V2_ADDRESSES.router, amount]
+          });
+        }
+      }
+    }
+    const tx = await aboreanWriteTx({
+      env: c.env,
+      options: c.options,
+      address: ABOREAN_V2_ADDRESSES.router,
+      abi: v2RouterAddLiquidityAbi,
+      functionName: "addLiquidity",
+      args: [
+        tokenA,
+        tokenB,
+        c.options.stable,
+        amountADesired,
+        amountBDesired,
+        amountAMin,
+        amountBMin,
+        account.address,
+        deadlineTimestamp
+      ]
+    });
+    return c.ok({
+      pool: checksumAddress4(poolAddress),
+      stable: c.options.stable,
+      tokenA: aMeta,
+      tokenB: bMeta,
+      amountADesired: {
+        raw: amountADesired.toString(),
+        decimal: formatUnits3(amountADesired, aMeta.decimals)
+      },
+      amountBDesired: {
+        raw: amountBDesired.toString(),
+        decimal: formatUnits3(amountBDesired, bMeta.decimals)
+      },
+      amountAMin: {
+        raw: amountAMin.toString(),
+        decimal: formatUnits3(amountAMin, aMeta.decimals)
+      },
+      amountBMin: {
+        raw: amountBMin.toString(),
+        decimal: formatUnits3(amountBMin, bMeta.decimals)
+      },
+      slippagePercent: c.options.slippage,
+      tx
+    });
+  }
+});
+pools.command("remove-liquidity", {
+  description: "Remove liquidity from a V2 pool. Approves the LP token to the router if needed, then calls removeLiquidity. Supports --dry-run.",
+  options: z5.object({
+    "token-a": z5.string().describe("First token address of the pair"),
+    "token-b": z5.string().describe("Second token address of the pair"),
+    liquidity: z5.string().describe("Amount of LP tokens to burn (in wei)"),
+    slippage: z5.coerce.number().min(0).max(100).default(DEFAULT_SLIPPAGE_PERCENT2).describe("Slippage tolerance in percent (default: 0.5)"),
+    deadline: z5.coerce.number().int().positive().default(DEFAULT_DEADLINE_SECONDS2).describe("Transaction deadline in seconds from now (default: 300)"),
+    stable: z5.boolean().default(false).describe("Target stable pool (default: volatile)")
+  }).merge(writeOptions),
+  env: writeEnv,
+  output: z5.object({
+    pool: z5.string(),
+    stable: z5.boolean(),
+    tokenA: tokenSchema2,
+    tokenB: tokenSchema2,
+    liquidity: amountSchema2,
+    amountAMin: amountSchema2,
+    amountBMin: amountSchema2,
+    slippagePercent: z5.number(),
+    tx: z5.union([
+      z5.object({
+        txHash: z5.string(),
+        blockNumber: z5.number(),
+        gasUsed: z5.string()
+      }),
+      z5.object({
+        dryRun: z5.literal(true),
+        estimatedGas: z5.string(),
+        simulationResult: z5.unknown()
+      })
+    ])
+  }),
+  async run(c) {
+    const tokenARaw = c.options["token-a"];
+    const tokenBRaw = c.options["token-b"];
+    if (!isAddress4(tokenARaw) || !isAddress4(tokenBRaw)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: "token-a and token-b must both be valid 0x-prefixed 20-byte addresses."
+      });
+    }
+    const tokenA = toAddress(tokenARaw);
+    const tokenB = toAddress(tokenBRaw);
+    let liquidityAmount;
     try {
-      amountInRaw = parseUnits2(c.args.amountIn, inMeta.decimals);
+      liquidityAmount = BigInt(c.options.liquidity);
     } catch {
       return c.error({
         code: "INVALID_AMOUNT",
-        message: `Invalid amountIn: "${c.args.amountIn}" for token ${inMeta.symbol} (${inMeta.decimals} decimals).`
+        message: "liquidity must be a valid integer in wei."
+      });
+    }
+    if (liquidityAmount <= 0n) {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: "liquidity must be a positive integer."
       });
     }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
     const poolAddress = await client.readContract({
       abi: poolFactoryAbi,
       address: ABOREAN_V2_ADDRESSES.poolFactory,
       functionName: "getPool",
-      args: [tokenIn, tokenOut, c.options.stable]
+      args: [tokenA, tokenB, 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)}.`
+        message: `No ${c.options.stable ? "stable" : "volatile"} V2 pool found for pair ${checksumAddress4(tokenA)}/${checksumAddress4(tokenB)}.`
       });
     }
-    const amounts = await client.readContract({
-      abi: v2RouterAbi,
+    const [poolStates] = await readPoolStates2(client, [poolAddress]);
+    const tokenMeta = await readTokenMetadata3(client, [tokenA, tokenB]);
+    const aMeta = tokenMeta.get(tokenA.toLowerCase()) ?? fallbackTokenMeta(tokenA);
+    const bMeta = tokenMeta.get(tokenB.toLowerCase()) ?? fallbackTokenMeta(tokenB);
+    const totalSupply = poolStates.totalSupply;
+    const isTokenAToken0 = tokenA.toLowerCase() === poolStates.token0.toLowerCase();
+    const reserveA = isTokenAToken0 ? poolStates.reserve0 : poolStates.reserve1;
+    const reserveB = isTokenAToken0 ? poolStates.reserve1 : poolStates.reserve0;
+    const expectedAmountA = totalSupply > 0n ? liquidityAmount * reserveA / totalSupply : 0n;
+    const expectedAmountB = totalSupply > 0n ? liquidityAmount * reserveB / totalSupply : 0n;
+    const slippageBps = Math.round(c.options.slippage * 100);
+    const amountAMin = expectedAmountA * BigInt(1e4 - slippageBps) / 10000n;
+    const amountBMin = expectedAmountB * BigInt(1e4 - slippageBps) / 10000n;
+    const deadlineTimestamp = BigInt(Math.floor(Date.now() / 1e3) + c.options.deadline);
+    const account = resolveAccount(c.env);
+    if (!c.options["dry-run"]) {
+      const currentAllowance = await client.readContract({
+        abi: erc20ApproveAbi3,
+        address: poolAddress,
+        functionName: "allowance",
+        args: [account.address, ABOREAN_V2_ADDRESSES.router]
+      });
+      if (currentAllowance < liquidityAmount) {
+        await aboreanWriteTx({
+          env: c.env,
+          options: { ...c.options, "dry-run": false },
+          address: poolAddress,
+          abi: erc20ApproveAbi3,
+          functionName: "approve",
+          args: [ABOREAN_V2_ADDRESSES.router, liquidityAmount]
+        });
+      }
+    }
+    const tx = await aboreanWriteTx({
+      env: c.env,
+      options: c.options,
       address: ABOREAN_V2_ADDRESSES.router,
-      functionName: "getAmountsOut",
+      abi: v2RouterRemoveLiquidityAbi,
+      functionName: "removeLiquidity",
       args: [
-        amountInRaw,
-        [
-          {
-            from: tokenIn,
-            to: tokenOut,
-            stable: c.options.stable,
-            factory: ABOREAN_V2_ADDRESSES.poolFactory
-          }
-        ]
+        tokenA,
+        tokenB,
+        c.options.stable,
+        liquidityAmount,
+        amountAMin,
+        amountBMin,
+        account.address,
+        deadlineTimestamp
       ]
     });
-    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)
-      },
-      c.format === "json" || c.format === "jsonl" ? void 0 : {
-        cta: {
-          description: "Related commands:",
-          commands: [
-            {
-              command: "pools pool",
-              args: { address: checksumAddress4(poolAddress) },
-              description: "Inspect the pool used for this quote"
-            },
-            {
-              command: "pools quote",
-              args: {
-                tokenIn: outMeta.address,
-                tokenOut: inMeta.address,
-                amountIn: amountOutDecimal
-              },
-              description: `Reverse quote ${outMeta.symbol} \u2192 ${inMeta.symbol}`
-            }
-          ]
-        }
-      }
-    );
-  }
-});
-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"
+    return c.ok({
+      pool: checksumAddress4(poolAddress),
+      stable: c.options.stable,
+      tokenA: aMeta,
+      tokenB: bMeta,
+      liquidity: {
+        raw: liquidityAmount.toString(),
+        decimal: formatUnits3(liquidityAmount, 18)
       },
-      {
-        abi: v2PoolAbi,
-        address: pool,
-        functionName: "token1"
+      amountAMin: {
+        raw: amountAMin.toString(),
+        decimal: formatUnits3(amountAMin, aMeta.decimals)
       },
-      {
-        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
+      amountBMin: {
+        raw: amountBMin.toString(),
+        decimal: formatUnits3(amountBMin, bMeta.decimals)
       },
-      c.format === "json" || c.format === "jsonl" ? void 0 : {
-        cta: {
-          description: "Related commands:",
-          commands: [
-            {
-              command: "pools pool",
-              args: { address: checksumAddress4(pool) },
-              description: "View full pool state"
-            },
-            {
-              command: "pools quote",
-              args: {
-                tokenIn: token0Meta.address,
-                tokenOut: token1Meta.address,
-                amountIn: "1"
-              },
-              description: `Quote a ${token0Meta.symbol} \u2192 ${token1Meta.symbol} swap`
-            }
-          ]
-        }
-      }
-    );
+      slippagePercent: c.options.slippage,
+      tx
+    });
   }
 });
 
 // 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")
+import { checksumAddress as checksumAddress5, isAddress as isAddress5 } from "@spectratools/cli-shared";
+import { Cli as Cli5, z as z6 } from "incur";
+var env5 = z6.object({
+  ABSTRACT_RPC_URL: z6.string().optional().describe("Abstract RPC URL override")
 });
 var relayAbi = [
   {
@@ -3446,22 +4940,22 @@ var votingEscrowLiteAbi = [
     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()
+var relayRowSchema = z6.object({
+  label: z6.string(),
+  relay: z6.string(),
+  name: z6.string(),
+  factoryType: z6.enum(["autoCompounder", "autoConverter"]),
+  managedTokenId: z6.string(),
+  managedVotingPower: z6.string(),
+  relayToken: z6.object({
+    address: z6.string(),
+    symbol: z6.string(),
+    decimals: z6.number()
   }),
-  relayTokenBalance: z5.string(),
-  keeperLastRun: z5.number(),
-  keeperLastRunRelative: z5.string(),
-  secondsSinceKeeperRun: z5.number()
+  relayTokenBalance: z6.string(),
+  keeperLastRun: z6.number(),
+  keeperLastRunRelative: z6.string(),
+  secondsSinceKeeperRun: z6.number()
 });
 var KNOWN_RELAYS = [
   {
@@ -3587,17 +5081,17 @@ var vaults = Cli5.create("vaults", {
 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()
+  output: z6.object({
+    relayCount: z6.number(),
+    relays: z6.array(relayRowSchema),
+    totals: z6.object({
+      managedVotingPower: z6.string(),
+      relayTokenBalances: z6.array(
+        z6.object({
+          token: z6.string(),
+          symbol: z6.string(),
+          decimals: z6.number(),
+          balance: z6.string()
         })
       )
     })
@@ -3636,8 +5130,8 @@ vaults.command("list", {
 });
 vaults.command("relay", {
   description: "Inspect one relay vault by address.",
-  args: z5.object({
-    relay: z5.string().describe("Relay vault contract address")
+  args: z6.object({
+    relay: z6.string().describe("Relay vault contract address")
   }),
   env: env5,
   output: relayRowSchema,
@@ -3648,7 +5142,7 @@ vaults.command("relay", {
     }
   ],
   async run(c) {
-    if (!isAddress4(c.args.relay)) {
+    if (!isAddress5(c.args.relay)) {
       return c.error({
         code: "INVALID_ARGUMENT",
         message: "relay must be a valid address"
@@ -3689,9 +5183,9 @@ vaults.command("relay", {
 });
 
 // src/commands/ve.ts
-import { Cli as Cli6, z as z6 } from "incur";
-var env6 = z6.object({
-  ABSTRACT_RPC_URL: z6.string().optional().describe("Abstract RPC URL override")
+import { Cli as Cli6, z as z7 } from "incur";
+var env6 = z7.object({
+  ABSTRACT_RPC_URL: z7.string().optional().describe("Abstract RPC URL override")
 });
 var ve = Cli6.create("ve", {
   description: "Inspect Aborean VotingEscrow (veABX) global and per-NFT lock state."
@@ -3699,16 +5193,16 @@ var ve = Cli6.create("ve", {
 ve.command("stats", {
   description: "Get global VotingEscrow supply, locks, and decay checkpoint data.",
   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()
+  output: z7.object({
+    token: z7.string(),
+    totalVotingPower: z7.string(),
+    totalLocked: z7.string(),
+    permanentLocked: z7.string(),
+    epoch: z7.number(),
+    decayBias: z7.string(),
+    decaySlope: z7.string(),
+    lastCheckpointTimestamp: z7.number(),
+    lastCheckpointBlock: z7.number()
   }),
   examples: [{ description: "Show global veABX state and decay metrics" }],
   async run(c) {
@@ -3779,17 +5273,17 @@ ve.command("stats", {
 });
 ve.command("lock", {
   description: "Get lock details and voting power for one veNFT token id.",
-  args: z6.object({
-    tokenId: z6.coerce.number().int().nonnegative().describe("veNFT token id")
+  args: z7.object({
+    tokenId: z7.coerce.number().int().nonnegative().describe("veNFT token id")
   }),
   env: env6,
-  output: z6.object({
-    tokenId: z6.number(),
-    owner: z6.string(),
-    amount: z6.string(),
-    unlockTime: z6.number(),
-    isPermanent: z6.boolean(),
-    votingPower: z6.string()
+  output: z7.object({
+    tokenId: z7.number(),
+    owner: z7.string(),
+    amount: z7.string(),
+    unlockTime: z7.number(),
+    isPermanent: z7.boolean(),
+    votingPower: z7.string()
   }),
   examples: [{ args: { tokenId: 1 }, description: "Inspect lock details for veNFT #1" }],
   async run(c) {
@@ -3846,22 +5340,22 @@ ve.command("lock", {
 });
 ve.command("locks", {
   description: "List all veNFT locks owned by an address.",
-  args: z6.object({
-    address: z6.string().describe("Owner address")
+  args: z7.object({
+    address: z7.string().describe("Owner address")
   }),
   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()
+  output: z7.object({
+    address: z7.string(),
+    locks: z7.array(
+      z7.object({
+        tokenId: z7.string(),
+        amount: z7.string(),
+        unlockTime: z7.number(),
+        isPermanent: z7.boolean(),
+        votingPower: z7.string()
       })
     ),
-    count: z6.number()
+    count: z7.number()
   }),
   examples: [
     {
@@ -3953,13 +5447,13 @@ ve.command("locks", {
 });
 ve.command("voting-power", {
   description: "Get current voting power for one veNFT token id.",
-  args: z6.object({
-    tokenId: z6.coerce.number().int().nonnegative().describe("veNFT token id")
+  args: z7.object({
+    tokenId: z7.coerce.number().int().nonnegative().describe("veNFT token id")
   }),
   env: env6,
-  output: z6.object({
-    tokenId: z6.number(),
-    votingPower: z6.string()
+  output: z7.object({
+    tokenId: z7.number(),
+    votingPower: z7.string()
   }),
   examples: [{ args: { tokenId: 1 }, description: "Get current voting power for veNFT #1" }],
   async run(c) {
@@ -3997,9 +5491,23 @@ ve.command("voting-power", {
 });
 
 // src/commands/voter.ts
-import { Cli as Cli7, z as z7 } from "incur";
-var env7 = z7.object({
-  ABSTRACT_RPC_URL: z7.string().optional().describe("Abstract RPC URL override")
+import { isAddress as isAddress6 } from "@spectratools/cli-shared";
+import { Cli as Cli7, z as z8 } from "incur";
+var voterVoteAbi = [
+  {
+    type: "function",
+    name: "vote",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "tokenId", type: "uint256" },
+      { name: "_poolVote", type: "address[]" },
+      { name: "_weights", type: "uint256[]" }
+    ],
+    outputs: []
+  }
+];
+var env7 = z8.object({
+  ABSTRACT_RPC_URL: z8.string().optional().describe("Abstract RPC URL override")
 });
 async function discoverPools(client) {
   const [v2PoolCount, clPoolCount] = await Promise.all([
@@ -4044,14 +5552,14 @@ var voter = Cli7.create("voter", {
 voter.command("epoch", {
   description: "Show current emissions epoch timing from Minter.",
   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()
+  output: z8.object({
+    activePeriod: z8.number(),
+    epochEnd: z8.number(),
+    secondsRemaining: z8.number(),
+    timeRemaining: z8.string(),
+    weekSeconds: z8.number(),
+    epochCount: z8.number(),
+    weeklyEmission: z8.string()
   }),
   examples: [{ description: "Inspect current voter epoch boundaries" }],
   async run(c) {
@@ -4111,16 +5619,16 @@ voter.command("epoch", {
 voter.command("weights", {
   description: "Show current pool voting weight distribution.",
   env: env7,
-  output: z7.object({
-    totalWeight: z7.string(),
-    pools: z7.array(
-      z7.object({
-        pool: z7.string(),
-        gauge: z7.string(),
-        weight: z7.string()
+  output: z8.object({
+    totalWeight: z8.string(),
+    pools: z8.array(
+      z8.object({
+        pool: z8.string(),
+        gauge: z8.string(),
+        weight: z8.string()
       })
     ),
-    count: z7.number()
+    count: z8.number()
   }),
   examples: [{ description: "List all pools with non-zero voting weight" }],
   async run(c) {
@@ -4199,19 +5707,19 @@ voter.command("weights", {
 });
 voter.command("rewards", {
   description: "Show claimable rebase rewards and voting context for a veNFT.",
-  args: z7.object({
-    tokenId: z7.coerce.number().int().nonnegative().describe("veNFT token id")
+  args: z8.object({
+    tokenId: z8.coerce.number().int().nonnegative().describe("veNFT token id")
   }),
   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()
+  output: z8.object({
+    tokenId: z8.number(),
+    rewardToken: z8.string(),
+    claimableRebase: z8.string(),
+    timeCursor: z8.number(),
+    lastTokenTime: z8.number(),
+    distributorStartTime: z8.number(),
+    usedWeight: z8.string(),
+    lastVoted: z8.number()
   }),
   examples: [{ args: { tokenId: 1 }, description: "Check claimable voter/distributor rewards" }],
   async run(c) {
@@ -4298,22 +5806,22 @@ voter.command("rewards", {
 });
 voter.command("bribes", {
   description: "Show active bribe reward tokens and current-epoch amounts for a pool.",
-  args: z7.object({
-    pool: z7.string().describe("Pool address")
+  args: z8.object({
+    pool: z8.string().describe("Pool address")
   }),
   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()
+  output: z8.object({
+    pool: z8.string(),
+    gauge: z8.string(),
+    bribeContract: z8.string(),
+    epochStart: z8.number(),
+    rewardTokens: z8.array(
+      z8.object({
+        token: z8.string(),
+        epochAmount: z8.string()
       })
     ),
-    count: z7.number()
+    count: z8.number()
   }),
   examples: [
     {
@@ -4426,6 +5934,139 @@ voter.command("bribes", {
     );
   }
 });
+voter.command("vote", {
+  description: "Cast votes for gauge(s) using a veNFT. Weights are relative and will be normalized by the Voter contract. Each pool address must have an active gauge.",
+  options: z8.object({
+    "token-id": z8.coerce.number().int().nonnegative().describe("veNFT token id to vote with"),
+    pools: z8.string().describe("Comma-separated pool addresses to vote for"),
+    weights: z8.string().describe("Comma-separated relative weights (matching pool order)")
+  }).merge(writeOptions),
+  env: writeEnv,
+  output: z8.object({
+    tokenId: z8.number(),
+    pools: z8.array(z8.string()),
+    weights: z8.array(z8.string()),
+    tx: z8.union([
+      z8.object({
+        txHash: z8.string(),
+        blockNumber: z8.number(),
+        gasUsed: z8.string()
+      }),
+      z8.object({
+        dryRun: z8.literal(true),
+        estimatedGas: z8.string(),
+        simulationResult: z8.unknown()
+      })
+    ])
+  }),
+  examples: [
+    {
+      options: {
+        "token-id": 1,
+        pools: "0x0000000000000000000000000000000000000001",
+        weights: "100",
+        "dry-run": true
+      },
+      description: "Dry-run vote for a single pool with weight 100"
+    },
+    {
+      options: {
+        "token-id": 1,
+        pools: "0x0000000000000000000000000000000000000001,0x0000000000000000000000000000000000000002",
+        weights: "60,40",
+        "dry-run": true
+      },
+      description: "Dry-run vote for two pools with relative weights"
+    }
+  ],
+  async run(c) {
+    const poolAddresses = c.options.pools.split(",").map((s) => s.trim());
+    const weightValues = c.options.weights.split(",").map((s) => s.trim());
+    if (poolAddresses.length === 0 || poolAddresses[0] === "") {
+      return c.error({
+        code: "INVALID_INPUT",
+        message: "At least one pool address is required."
+      });
+    }
+    if (poolAddresses.length !== weightValues.length) {
+      return c.error({
+        code: "INVALID_INPUT",
+        message: `Pool count (${poolAddresses.length}) and weight count (${weightValues.length}) must match.`
+      });
+    }
+    for (const addr of poolAddresses) {
+      if (!isAddress6(addr)) {
+        return c.error({
+          code: "INVALID_ADDRESS",
+          message: `Invalid pool address: "${addr}". Use valid 0x-prefixed 20-byte hex addresses.`
+        });
+      }
+    }
+    const parsedWeights = [];
+    for (const w of weightValues) {
+      const parsed = BigInt(w);
+      if (parsed <= 0n) {
+        return c.error({
+          code: "INVALID_INPUT",
+          message: `Weight must be a positive integer, got: "${w}".`
+        });
+      }
+      parsedWeights.push(parsed);
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const gaugeResults = await client.multicall({
+      allowFailure: false,
+      contracts: poolAddresses.map((pool) => ({
+        abi: voterAbi,
+        address: ABOREAN_V2_ADDRESSES.voter,
+        functionName: "gauges",
+        args: [pool]
+      }))
+    });
+    for (let i = 0; i < gaugeResults.length; i++) {
+      if (gaugeResults[i].toLowerCase() === ZERO_ADDRESS.toLowerCase()) {
+        return c.error({
+          code: "GAUGE_NOT_FOUND",
+          message: `No gauge exists for pool ${poolAddresses[i]}.`,
+          retryable: false
+        });
+      }
+    }
+    const aliveResults = await client.multicall({
+      allowFailure: false,
+      contracts: gaugeResults.map((gauge) => ({
+        abi: voterAbi,
+        address: ABOREAN_V2_ADDRESSES.voter,
+        functionName: "isAlive",
+        args: [gauge]
+      }))
+    });
+    for (let i = 0; i < aliveResults.length; i++) {
+      if (!aliveResults[i]) {
+        return c.error({
+          code: "GAUGE_NOT_ALIVE",
+          message: `Gauge for pool ${poolAddresses[i]} is not alive.`,
+          retryable: false
+        });
+      }
+    }
+    const tokenId = BigInt(c.options["token-id"]);
+    const tx = await aboreanWriteTx({
+      env: c.env,
+      options: c.options,
+      address: ABOREAN_V2_ADDRESSES.voter,
+      abi: voterVoteAbi,
+      functionName: "vote",
+      args: [tokenId, poolAddresses, parsedWeights]
+    });
+    return c.ok({
+      tokenId: c.options["token-id"],
+      pools: poolAddresses.map((p) => toChecksum(p)),
+      weights: parsedWeights.map((w) => w.toString()),
+      tx
+    });
+  }
+});
 
 // src/error-handling.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -4568,8 +6209,8 @@ cli.command(voter);
 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 rootEnv = z9.object({
+  ABSTRACT_RPC_URL: z9.string().optional().describe("Abstract RPC URL override")
 });
 var erc20MetadataAbi4 = [
   {
@@ -4774,65 +6415,65 @@ async function readTopV2PoolsSnapshot(client, limit) {
 cli.command("status", {
   description: "Cross-protocol Aborean snapshot (TVL estimates, epoch, top pools, ve lock, vaults, Morpho lending).",
   env: rootEnv,
-  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()
+  output: z9.object({
+    v2PoolCount: z9.number().describe("Number of V2 AMM pools"),
+    clPoolCount: z9.number().describe("Number of Slipstream (CL) pools"),
+    gaugeCount: z9.number().describe("Number of pools with gauges"),
+    totalVotingWeight: z9.string().describe("Total voting weight (wei)"),
+    veABXTotalSupply: z9.string().describe("Total veABX supply (wei)"),
+    veABXLockedSupply: z9.string().describe("Total ABX locked in VotingEscrow (wei)"),
+    epoch: z9.object({
+      activePeriod: z9.number(),
+      epochEnd: z9.number(),
+      secondsRemaining: z9.number(),
+      epochCount: z9.number(),
+      weeklyEmission: z9.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()
+    topPools: z9.array(
+      z9.object({
+        pool: z9.string(),
+        pair: z9.string(),
+        poolType: z9.enum(["stable", "volatile"]),
+        token0: z9.object({
+          address: z9.string(),
+          symbol: z9.string(),
+          decimals: z9.number()
         }),
-        token1: z8.object({
-          address: z8.string(),
-          symbol: z8.string(),
-          decimals: z8.number()
+        token1: z9.object({
+          address: z9.string(),
+          symbol: z9.string(),
+          decimals: z9.number()
         }),
-        reserves: z8.object({
-          token0: z8.string(),
-          token1: z8.string()
+        reserves: z9.object({
+          token0: z9.string(),
+          token1: z9.string()
         }),
-        tvlEstimateUnits: z8.number()
+        tvlEstimateUnits: z9.number()
       })
     ),
-    tvl: z8.object({
-      v2ReserveUnitEstimate: z8.number(),
-      vaultManagedVotingPower: z8.string()
+    tvl: z9.object({
+      v2ReserveUnitEstimate: z9.number(),
+      vaultManagedVotingPower: z9.string()
     }),
-    vaults: z8.object({
-      relayCount: z8.number(),
-      managedVotingPower: z8.string(),
-      note: z8.string().nullable()
+    vaults: z9.object({
+      relayCount: z9.number(),
+      managedVotingPower: z9.string(),
+      note: z9.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()
+    lending: z9.object({
+      available: z9.boolean(),
+      morpho: z9.string(),
+      marketCount: z9.number(),
+      supplyByLoanToken: z9.array(
+        z9.object({
+          token: z9.string(),
+          symbol: z9.string(),
+          decimals: z9.number(),
+          totalSupplyAssets: z9.string(),
+          totalBorrowAssets: z9.string()
         })
       ),
-      note: z8.string().nullable()
+      note: z9.string().nullable()
     })
   }),
   examples: [{ description: "Fetch the current Aborean protocol status" }],