@spectratools/aborean-cli 0.9.0 → 0.10.0

package/dist/cli.js

@@ -1991,12 +1991,496 @@ cl.command("swap", {
     });
   }
 });
+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({
@@ -2414,9 +2898,189 @@ 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 { 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;
@@ -2921,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"
@@ -3032,13 +3696,13 @@ lending.command("position", {
 });
 
 // src/commands/pools.ts
-import { checksumAddress as checksumAddress4, isAddress as isAddress3 } from "@spectratools/cli-shared";
+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 DEFAULT_SLIPPAGE_PERCENT2 = 0.5;
 var DEFAULT_DEADLINE_SECONDS2 = 300;
-var erc20ApproveAbi = [
+var erc20ApproveAbi3 = [
   {
     type: "function",
     name: "approve",
@@ -3092,7 +3756,7 @@ var tokenSchema2 = z5.object({
   symbol: z5.string(),
   decimals: z5.number()
 });
-var amountSchema = z5.object({
+var amountSchema2 = z5.object({
   raw: z5.string(),
   decimal: z5.string()
 });
@@ -3108,8 +3772,8 @@ var poolSummarySchema = z5.object({
   token0: tokenSchema2,
   token1: tokenSchema2,
   reserves: z5.object({
-    token0: amountSchema,
-    token1: amountSchema,
+    token0: amountSchema2,
+    token1: amountSchema2,
     blockTimestampLast: z5.number()
   }),
   totalSupply: z5.string(),
@@ -3416,7 +4080,7 @@ pools.command("pool", {
     })
   }),
   async run(c) {
-    if (!isAddress3(c.args.address)) {
+    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.`
@@ -3525,12 +4189,12 @@ pools.command("quote", {
     stable: z5.boolean(),
     tokenIn: tokenSchema2,
     tokenOut: tokenSchema2,
-    amountIn: amountSchema,
-    amountOut: amountSchema,
+    amountIn: amountSchema2,
+    amountOut: amountSchema2,
     priceOutPerIn: z5.number().nullable()
   }),
   async run(c) {
-    if (!isAddress3(c.args.tokenIn) || !isAddress3(c.args.tokenOut)) {
+    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."
@@ -3640,7 +4304,7 @@ pools.command("fees", {
     volatileFee: feeSchema
   }),
   async run(c) {
-    if (!isAddress3(c.args.pool)) {
+    if (!isAddress4(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.`
@@ -3723,9 +4387,9 @@ pools.command("swap", {
     stable: z5.boolean(),
     tokenIn: tokenSchema2,
     tokenOut: tokenSchema2,
-    amountIn: amountSchema,
-    expectedAmountOut: amountSchema,
-    minAmountOut: amountSchema,
+    amountIn: amountSchema2,
+    expectedAmountOut: amountSchema2,
+    minAmountOut: amountSchema2,
     slippagePercent: z5.number(),
     effectivePrice: z5.number().nullable(),
     tx: z5.union([
@@ -3744,7 +4408,7 @@ pools.command("swap", {
   async run(c) {
     const tokenInRaw = c.options["token-in"];
     const tokenOutRaw = c.options["token-out"];
-    if (!isAddress3(tokenInRaw) || !isAddress3(tokenOutRaw)) {
+    if (!isAddress4(tokenInRaw) || !isAddress4(tokenOutRaw)) {
       return c.error({
         code: "INVALID_ADDRESS",
         message: "token-in and token-out must both be valid 0x-prefixed 20-byte addresses."
@@ -3804,7 +4468,7 @@ pools.command("swap", {
     const account = resolveAccount(c.env);
     if (!c.options["dry-run"]) {
       const currentAllowance = await client.readContract({
-        abi: erc20ApproveAbi,
+        abi: erc20ApproveAbi3,
         address: tokenIn,
         functionName: "allowance",
         args: [account.address, ABOREAN_V2_ADDRESSES.router]
@@ -3814,7 +4478,7 @@ pools.command("swap", {
           env: c.env,
           options: { ...c.options, "dry-run": false },
           address: tokenIn,
-          abi: erc20ApproveAbi,
+          abi: erc20ApproveAbi3,
           functionName: "approve",
           args: [ABOREAN_V2_ADDRESSES.router, amountInRaw]
         });
@@ -3868,9 +4532,348 @@ pools.command("swap", {
     });
   }
 });
+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 {
+      liquidityAmount = BigInt(c.options.liquidity);
+    } catch {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        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: [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 [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,
+      abi: v2RouterRemoveLiquidityAbi,
+      functionName: "removeLiquidity",
+      args: [
+        tokenA,
+        tokenB,
+        c.options.stable,
+        liquidityAmount,
+        amountAMin,
+        amountBMin,
+        account.address,
+        deadlineTimestamp
+      ]
+    });
+    return c.ok({
+      pool: checksumAddress4(poolAddress),
+      stable: c.options.stable,
+      tokenA: aMeta,
+      tokenB: bMeta,
+      liquidity: {
+        raw: liquidityAmount.toString(),
+        decimal: formatUnits3(liquidityAmount, 18)
+      },
+      amountAMin: {
+        raw: amountAMin.toString(),
+        decimal: formatUnits3(amountAMin, aMeta.decimals)
+      },
+      amountBMin: {
+        raw: amountBMin.toString(),
+        decimal: formatUnits3(amountBMin, bMeta.decimals)
+      },
+      slippagePercent: c.options.slippage,
+      tx
+    });
+  }
+});
 
 // src/commands/vaults.ts
-import { checksumAddress as checksumAddress5, isAddress as isAddress4 } from "@spectratools/cli-shared";
+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")
@@ -4139,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"
@@ -4488,7 +5491,21 @@ ve.command("voting-power", {
 });
 
 // src/commands/voter.ts
+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")
 });
@@ -4917,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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spectratools/aborean-cli",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "CLI for Aborean Finance DEX on Abstract (pools, swaps, gauges, voting escrow).",
   "type": "module",
   "license": "MIT",