@spectratools/aborean-cli 0.2.0 → 0.4.0

package/dist/cli.js

@@ -4,7 +4,12 @@
 import { readFileSync } from "fs";
 import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
+import { Cli as Cli5, z as z5 } from "incur";
+
+// src/commands/cl.ts
+import { checksumAddress, isAddress } from "@spectratools/cli-shared";
 import { Cli, z } from "incur";
+import { formatUnits, parseUnits } from "viem";
 
 // src/contracts/abis/CLFactory.abi.json
 var CLFactory_abi_default = [
@@ -119,177 +124,246 @@ var CLFactory_abi_default = [
   }
 ];
 
-// src/contracts/abis/PoolFactory.abi.json
-var PoolFactory_abi_default = [
+// src/contracts/abis/CLPool.abi.json
+var CLPool_abi_default = [
   {
     type: "function",
-    name: "allPoolsLength",
+    name: "slot0",
     inputs: [],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    outputs: [
+      { name: "sqrtPriceX96", type: "uint160", internalType: "uint160" },
+      { name: "tick", type: "int24", internalType: "int24" },
+      { name: "observationIndex", type: "uint16", internalType: "uint16" },
+      { name: "observationCardinality", type: "uint16", internalType: "uint16" },
+      { name: "observationCardinalityNext", type: "uint16", internalType: "uint16" },
+      { name: "unlocked", type: "bool", internalType: "bool" }
+    ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "allPools",
-    inputs: [{ name: "index", type: "uint256", internalType: "uint256" }],
-    outputs: [{ name: "", type: "address", internalType: "address" }],
+    name: "liquidity",
+    inputs: [],
+    outputs: [{ name: "", type: "uint128", internalType: "uint128" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "getPool",
-    inputs: [
-      { name: "tokenA", type: "address", internalType: "address" },
-      { name: "tokenB", type: "address", internalType: "address" },
-      { name: "stable", type: "bool", internalType: "bool" }
-    ],
+    name: "token0",
+    inputs: [],
     outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "isPair",
-    inputs: [{ name: "pool", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    name: "token1",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "getFee",
-    inputs: [
-      { name: "pool", type: "address", internalType: "address" },
-      { name: "stable", type: "bool", internalType: "bool" }
-    ],
-    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    name: "tickSpacing",
+    inputs: [],
+    outputs: [{ name: "", type: "int24", internalType: "int24" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "implementation",
+    name: "factory",
     inputs: [],
     outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "voter",
+    name: "gauge",
     inputs: [],
     outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "fee",
+    inputs: [],
+    outputs: [{ name: "", type: "uint24", internalType: "uint24" }],
+    stateMutability: "view"
   }
 ];
 
-// src/contracts/abis/Voter.abi.json
-var Voter_abi_default = [
+// src/contracts/abis/Gauge.abi.json
+var Gauge_abi_default = [
   {
     type: "function",
-    name: "length",
+    name: "stakingToken",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "rewardToken",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "periodFinish",
     inputs: [],
     outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "totalWeight",
+    name: "rewardRate",
     inputs: [],
     outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "gauges",
-    inputs: [{ name: "pool", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "address", internalType: "address" }],
+    name: "lastUpdateTime",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "poolForGauge",
-    inputs: [{ name: "gauge", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "address", internalType: "address" }],
+    name: "rewardPerTokenStored",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "weights",
-    inputs: [{ name: "pool", type: "address", internalType: "address" }],
+    name: "totalSupply",
+    inputs: [],
     outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "isAlive",
-    inputs: [{ name: "gauge", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "isGauge",
-    inputs: [{ name: "", type: "address", internalType: "address" }],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    name: "earned",
+    inputs: [{ name: "account", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "ve",
+    name: "fees0",
     inputs: [],
-    outputs: [{ name: "", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "minter",
+    name: "fees1",
     inputs: [],
-    outputs: [{ name: "", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "factoryRegistry",
+    name: "left",
     inputs: [],
-    outputs: [{ name: "", type: "address", internalType: "address" }],
+    outputs: [{ name: "_left", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  }
+];
+
+// src/contracts/abis/Minter.abi.json
+var Minter_abi_default = [
+  {
+    type: "function",
+    name: "WEEK",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "forwarder",
+    name: "weekly",
     inputs: [],
-    outputs: [{ name: "", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "governor",
+    name: "activePeriod",
     inputs: [],
-    outputs: [{ name: "", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "emergencyCouncil",
+    name: "epochCount",
     inputs: [],
-    outputs: [{ name: "", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "maxVotingNum",
+    name: "teamRate",
     inputs: [],
     outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "claimable",
-    inputs: [{ name: "gauge", type: "address", internalType: "address" }],
+    name: "tailEmissionRate",
+    inputs: [],
     outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   }
 ];
 
-// src/contracts/abis/VotingEscrow.abi.json
-var VotingEscrow_abi_default = [
+// src/contracts/abis/NonfungiblePositionManager.abi.json
+var NonfungiblePositionManager_abi_default = [
+  {
+    type: "function",
+    name: "positions",
+    inputs: [{ name: "tokenId", type: "uint256", internalType: "uint256" }],
+    outputs: [
+      { name: "nonce", type: "uint96", internalType: "uint96" },
+      { name: "operator", type: "address", internalType: "address" },
+      { name: "token0", type: "address", internalType: "address" },
+      { name: "token1", type: "address", internalType: "address" },
+      { name: "tickSpacing", type: "int24", internalType: "int24" },
+      { name: "tickLower", type: "int24", internalType: "int24" },
+      { name: "tickUpper", type: "int24", internalType: "int24" },
+      { name: "liquidity", type: "uint128", internalType: "uint128" },
+      { name: "feeGrowthInside0LastX128", type: "uint256", internalType: "uint256" },
+      { name: "feeGrowthInside1LastX128", type: "uint256", internalType: "uint256" },
+      { name: "tokensOwed0", type: "uint128", internalType: "uint128" },
+      { name: "tokensOwed1", type: "uint128", internalType: "uint128" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "owner", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tokenOfOwnerByIndex",
+    inputs: [
+      { name: "owner", type: "address", internalType: "address" },
+      { name: "index", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "totalSupply",
@@ -299,46 +373,168 @@ var VotingEscrow_abi_default = [
   },
   {
     type: "function",
-    name: "balanceOf",
-    inputs: [{ name: "owner", type: "address", internalType: "address" }],
+    name: "factory",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "WETH9",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  }
+];
+
+// src/contracts/abis/PoolFactory.abi.json
+var PoolFactory_abi_default = [
+  {
+    type: "function",
+    name: "allPoolsLength",
+    inputs: [],
     outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "locked",
-    inputs: [{ name: "tokenId", type: "uint256", internalType: "uint256" }],
-    outputs: [
-      { name: "amount", type: "int128", internalType: "int128" },
-      { name: "end", type: "uint256", internalType: "uint256" },
-      { name: "isPermanent", type: "bool", internalType: "bool" }
+    name: "allPools",
+    inputs: [{ name: "index", type: "uint256", internalType: "uint256" }],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getPool",
+    inputs: [
+      { name: "tokenA", type: "address", internalType: "address" },
+      { name: "tokenB", type: "address", internalType: "address" },
+      { name: "stable", type: "bool", internalType: "bool" }
     ],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "ownerOf",
-    inputs: [{ name: "tokenId", type: "uint256", internalType: "uint256" }],
+    name: "isPair",
+    inputs: [{ name: "pool", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getFee",
+    inputs: [
+      { name: "pool", type: "address", internalType: "address" },
+      { name: "stable", type: "bool", internalType: "bool" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "implementation",
+    inputs: [],
     outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "tokenOfOwnerByIndex",
+    name: "voter",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  }
+];
+
+// src/contracts/abis/QuoterV2.abi.json
+var QuoterV2_abi_default = [
+  {
+    type: "function",
+    name: "factory",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "WETH9",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "quoteExactInputSingle",
     inputs: [
-      { name: "owner", type: "address", internalType: "address" },
-      { name: "index", type: "uint256", internalType: "uint256" }
+      {
+        name: "params",
+        type: "tuple",
+        internalType: "struct IQuoterV2.QuoteExactInputSingleParams",
+        components: [
+          { name: "tokenIn", type: "address", internalType: "address" },
+          { name: "tokenOut", type: "address", internalType: "address" },
+          { name: "amountIn", type: "uint256", internalType: "uint256" },
+          { name: "tickSpacing", type: "int24", internalType: "int24" },
+          { name: "sqrtPriceLimitX96", type: "uint160", internalType: "uint160" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "amountOut", type: "uint256", internalType: "uint256" },
+      { name: "sqrtPriceX96After", type: "uint160", internalType: "uint160" },
+      { name: "initializedTicksCrossed", type: "uint32", internalType: "uint32" },
+      { name: "gasEstimate", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "quoteExactInput",
+    inputs: [
+      { name: "path", type: "bytes", internalType: "bytes" },
+      { name: "amountIn", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [
+      { name: "amountOut", type: "uint256", internalType: "uint256" },
+      { name: "sqrtPriceX96AfterList", type: "uint160[]", internalType: "uint160[]" },
+      { name: "initializedTicksCrossedList", type: "uint32[]", internalType: "uint32[]" },
+      { name: "gasEstimate", type: "uint256", internalType: "uint256" }
     ],
+    stateMutability: "nonpayable"
+  }
+];
+
+// src/contracts/abis/RewardsDistributor.abi.json
+var RewardsDistributor_abi_default = [
+  {
+    type: "function",
+    name: "WEEK",
+    inputs: [],
     outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "balanceOfNFT",
+    name: "startTime",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "timeCursorOf",
     inputs: [{ name: "tokenId", type: "uint256", internalType: "uint256" }],
     outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "lastTokenTime",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "token",
@@ -348,18 +544,329 @@ var VotingEscrow_abi_default = [
   },
   {
     type: "function",
-    name: "supply",
+    name: "minter",
     inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "claimable",
+    inputs: [{ name: "tokenId", type: "uint256", internalType: "uint256" }],
     outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   }
 ];
 
-// src/contracts/abis.ts
-var clFactoryAbi = CLFactory_abi_default;
-var poolFactoryAbi = PoolFactory_abi_default;
+// src/contracts/abis/Voter.abi.json
+var Voter_abi_default = [
+  {
+    type: "function",
+    name: "length",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalWeight",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "gauges",
+    inputs: [{ name: "pool", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "poolForGauge",
+    inputs: [{ name: "gauge", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "gaugeToFees",
+    inputs: [{ name: "gauge", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "gaugeToBribe",
+    inputs: [{ name: "gauge", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "weights",
+    inputs: [{ name: "pool", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "votes",
+    inputs: [
+      { name: "tokenId", type: "uint256", internalType: "uint256" },
+      { name: "pool", type: "address", internalType: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "usedWeights",
+    inputs: [{ name: "tokenId", type: "uint256", internalType: "uint256" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "lastVoted",
+    inputs: [{ name: "tokenId", type: "uint256", internalType: "uint256" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isAlive",
+    inputs: [{ name: "gauge", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isGauge",
+    inputs: [{ name: "", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ve",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "minter",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "factoryRegistry",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "forwarder",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "governor",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "epochGovernor",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "emergencyCouncil",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "maxVotingNum",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "claimable",
+    inputs: [{ name: "gauge", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  }
+];
+
+// src/contracts/abis/VotingEscrow.abi.json
+var VotingEscrow_abi_default = [
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "supply",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "permanentLockBalance",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "epoch",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pointHistory",
+    inputs: [{ name: "_loc", type: "uint256", internalType: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct IVotingEscrow.GlobalPoint",
+        components: [
+          { name: "bias", type: "int128", internalType: "int128" },
+          { name: "slope", type: "int128", internalType: "int128" },
+          { name: "ts", type: "uint256", internalType: "uint256" },
+          { name: "blk", type: "uint256", internalType: "uint256" },
+          {
+            name: "permanentLockBalance",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "owner", type: "address", internalType: "address" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "locked",
+    inputs: [{ name: "tokenId", type: "uint256", internalType: "uint256" }],
+    outputs: [
+      { name: "amount", type: "int128", internalType: "int128" },
+      { name: "end", type: "uint256", internalType: "uint256" },
+      { name: "isPermanent", type: "bool", internalType: "bool" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ownerOf",
+    inputs: [{ name: "tokenId", type: "uint256", internalType: "uint256" }],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tokenOfOwnerByIndex",
+    inputs: [
+      { name: "owner", type: "address", internalType: "address" },
+      { name: "index", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOfNFT",
+    inputs: [{ name: "tokenId", type: "uint256", internalType: "uint256" }],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "token",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  }
+];
+
+// src/contracts/abis/VotingReward.abi.json
+var VotingReward_abi_default = [
+  {
+    type: "function",
+    name: "rewardsListLength",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "rewards",
+    inputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tokenRewardsPerEpoch",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "epochStart", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "earned",
+    inputs: [
+      { name: "token", type: "address", internalType: "address" },
+      { name: "tokenId", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  }
+];
+
+// src/contracts/abis.ts
+var clFactoryAbi = CLFactory_abi_default;
+var clPoolAbi = CLPool_abi_default;
+var gaugeAbi = Gauge_abi_default;
+var minterAbi = Minter_abi_default;
+var nonfungiblePositionManagerAbi = NonfungiblePositionManager_abi_default;
+var poolFactoryAbi = PoolFactory_abi_default;
+var quoterV2Abi = QuoterV2_abi_default;
+var rewardsDistributorAbi = RewardsDistributor_abi_default;
 var voterAbi = Voter_abi_default;
 var votingEscrowAbi = VotingEscrow_abi_default;
+var votingRewardAbi = VotingReward_abi_default;
 
 // src/contracts/addresses.ts
 var ABOREAN_V2_ADDRESSES = {
@@ -423,28 +930,1544 @@ var ABOREAN_ADDRESSES = {
   ...ABOREAN_CL_ADDRESSES
 };
 
-// src/contracts/client.ts
-import { http, createPublicClient, defineChain } from "viem";
-var abstractMainnet = defineChain({
-  id: 2741,
-  name: "Abstract Mainnet",
-  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
-  rpcUrls: {
-    default: { http: ["https://api.mainnet.abs.xyz"] },
-    public: { http: ["https://api.mainnet.abs.xyz"] }
-  },
-  contracts: {
-    multicall3: {
-      address: "0xcA11bde05977b3631167028862bE2a173976CA11"
+// src/contracts/client.ts
+import { http, createPublicClient, defineChain } from "viem";
+var abstractMainnet = defineChain({
+  id: 2741,
+  name: "Abstract Mainnet",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: { http: ["https://api.mainnet.abs.xyz"] },
+    public: { http: ["https://api.mainnet.abs.xyz"] }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11"
+    }
+  }
+});
+function createAboreanPublicClient(rpcUrl) {
+  return createPublicClient({
+    chain: abstractMainnet,
+    transport: http(rpcUrl ?? process.env.ABSTRACT_RPC_URL ?? "https://api.mainnet.abs.xyz")
+  });
+}
+
+// src/commands/cl.ts
+var Q96 = 2n ** 96n;
+var MULTICALL_BATCH_SIZE = 100;
+var env = z.object({
+  ABSTRACT_RPC_URL: z.string().optional().describe("Abstract RPC URL override")
+});
+var tokenSchema = z.object({
+  address: z.string(),
+  symbol: z.string(),
+  decimals: z.number()
+});
+var poolRowSchema = z.object({
+  pool: z.string(),
+  pair: z.string(),
+  token0: tokenSchema,
+  token1: tokenSchema,
+  fee: z.number(),
+  feePercent: z.number(),
+  tickSpacing: z.number(),
+  liquidity: z.string(),
+  currentTick: z.number(),
+  sqrtPriceX96: z.string(),
+  activeLiquidityEstimate: z.object({
+    token0: z.string(),
+    token1: z.string(),
+    totalInToken0: z.number().nullable(),
+    totalInToken1: z.number().nullable()
+  }),
+  price: z.object({
+    token1PerToken0: z.number().nullable(),
+    token0PerToken1: z.number().nullable()
+  })
+});
+var quoteOutputSchema = z.object({
+  pool: z.string(),
+  selectedFee: z.number(),
+  selectedTickSpacing: z.number(),
+  tokenIn: tokenSchema,
+  tokenOut: tokenSchema,
+  amountIn: z.object({
+    raw: z.string(),
+    decimal: z.string()
+  }),
+  amountOut: z.object({
+    raw: z.string(),
+    decimal: z.string()
+  }),
+  execution: z.object({
+    sqrtPriceX96After: z.string(),
+    initializedTicksCrossed: z.number(),
+    gasEstimate: z.string()
+  }),
+  prices: z.object({
+    poolMidPriceOutPerIn: z.number().nullable(),
+    quotePriceOutPerIn: z.number().nullable(),
+    priceImpactPct: z.number().nullable()
+  })
+});
+var erc20MetadataAbi = [
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "string" }]
+  },
+  {
+    type: "function",
+    name: "decimals",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint8" }]
+  }
+];
+function shortAddress(address) {
+  return `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
+}
+function finiteOrNull(value) {
+  return Number.isFinite(value) ? value : null;
+}
+function toTokenMetaFallback(address) {
+  return {
+    address,
+    symbol: shortAddress(checksumAddress(address)),
+    decimals: 18
+  };
+}
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) {
+    out.push(items.slice(i, i + size));
+  }
+  return out;
+}
+async function multicallAllowFailure(client, contracts) {
+  const batches = chunk(contracts, MULTICALL_BATCH_SIZE);
+  const out = [];
+  for (const batch of batches) {
+    const res = await client.multicall({
+      allowFailure: true,
+      contracts: batch
+    });
+    out.push(...res);
+  }
+  return out;
+}
+async function multicallStrict(client, contracts) {
+  const batches = chunk(contracts, MULTICALL_BATCH_SIZE);
+  const out = [];
+  for (const batch of batches) {
+    const res = await client.multicall({
+      allowFailure: false,
+      contracts: batch
+    });
+    out.push(...res);
+  }
+  return out;
+}
+function derivePrices(sqrtPriceX96, token0Decimals, token1Decimals) {
+  const sqrtRatio = Number(sqrtPriceX96) / 2 ** 96;
+  const rawPrice = sqrtRatio * sqrtRatio;
+  const decimalScale = 10 ** (token0Decimals - token1Decimals);
+  const token1PerToken0 = finiteOrNull(rawPrice * decimalScale);
+  const token0PerToken1 = token1PerToken0 === null || token1PerToken0 === 0 ? null : finiteOrNull(1 / token1PerToken0);
+  return {
+    token1PerToken0,
+    token0PerToken1
+  };
+}
+function estimateActiveLiquidity(liquidity, sqrtPriceX96, token0Decimals, token1Decimals, prices) {
+  if (sqrtPriceX96 === 0n) {
+    return {
+      token0: "0",
+      token1: "0",
+      totalInToken0: null,
+      totalInToken1: null
+    };
+  }
+  const reserve0Raw = liquidity * Q96 / sqrtPriceX96;
+  const reserve1Raw = liquidity * sqrtPriceX96 / Q96;
+  const reserve0 = Number(formatUnits(reserve0Raw, token0Decimals));
+  const reserve1 = Number(formatUnits(reserve1Raw, token1Decimals));
+  const totalInToken1 = prices.token1PerToken0 === null ? null : finiteOrNull(reserve1 + reserve0 * prices.token1PerToken0);
+  const totalInToken0 = prices.token0PerToken1 === null ? null : finiteOrNull(reserve0 + reserve1 * prices.token0PerToken1);
+  return {
+    token0: formatUnits(reserve0Raw, token0Decimals),
+    token1: formatUnits(reserve1Raw, token1Decimals),
+    totalInToken0,
+    totalInToken1
+  };
+}
+async function readTokenMetadata(client, tokenAddresses) {
+  const uniqueTokens = [...new Set(tokenAddresses.map((x) => x.toLowerCase()))];
+  if (uniqueTokens.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const contracts = uniqueTokens.flatMap((address) => [
+    {
+      abi: erc20MetadataAbi,
+      address,
+      functionName: "symbol"
+    },
+    {
+      abi: erc20MetadataAbi,
+      address,
+      functionName: "decimals"
+    }
+  ]);
+  const results = await multicallAllowFailure(client, contracts);
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0; i < uniqueTokens.length; i += 1) {
+    const address = uniqueTokens[i];
+    const symbolResult = results[i * 2];
+    const decimalsResult = results[i * 2 + 1];
+    const fallback = toTokenMetaFallback(address);
+    const symbol = symbolResult && symbolResult.status === "success" && typeof symbolResult.result === "string" ? symbolResult.result : fallback.symbol;
+    const decimals = decimalsResult && decimalsResult.status === "success" && typeof decimalsResult.result === "number" ? decimalsResult.result : fallback.decimals;
+    out.set(address, {
+      address: checksumAddress(address),
+      symbol,
+      decimals
+    });
+  }
+  return out;
+}
+async function listPoolAddresses(client) {
+  const count = await client.readContract({
+    abi: clFactoryAbi,
+    address: ABOREAN_CL_ADDRESSES.clFactory,
+    functionName: "allPoolsLength"
+  });
+  if (count === 0n) {
+    return [];
+  }
+  const poolIndexContracts = Array.from({ length: Number(count) }, (_, i) => ({
+    abi: clFactoryAbi,
+    address: ABOREAN_CL_ADDRESSES.clFactory,
+    functionName: "allPools",
+    args: [BigInt(i)]
+  }));
+  const poolAddresses = await multicallStrict(client, poolIndexContracts);
+  return poolAddresses;
+}
+async function readPoolStates(client, poolAddresses) {
+  if (poolAddresses.length === 0) {
+    return [];
+  }
+  const poolContracts = poolAddresses.flatMap((pool) => [
+    {
+      abi: clPoolAbi,
+      address: pool,
+      functionName: "token0"
+    },
+    {
+      abi: clPoolAbi,
+      address: pool,
+      functionName: "token1"
+    },
+    {
+      abi: clPoolAbi,
+      address: pool,
+      functionName: "tickSpacing"
+    },
+    {
+      abi: clPoolAbi,
+      address: pool,
+      functionName: "fee"
+    },
+    {
+      abi: clPoolAbi,
+      address: pool,
+      functionName: "liquidity"
+    },
+    {
+      abi: clPoolAbi,
+      address: pool,
+      functionName: "slot0"
+    }
+  ]);
+  const values = await multicallStrict(client, poolContracts);
+  return poolAddresses.map((pool, i) => ({
+    pool,
+    token0: values[i * 6],
+    token1: values[i * 6 + 1],
+    tickSpacing: Number(values[i * 6 + 2]),
+    fee: Number(values[i * 6 + 3]),
+    liquidity: values[i * 6 + 4],
+    slot0: values[i * 6 + 5]
+  }));
+}
+function toPoolRow(pool, tokenMeta) {
+  const token0 = tokenMeta.get(pool.token0) ?? toTokenMetaFallback(pool.token0);
+  const token1 = tokenMeta.get(pool.token1) ?? toTokenMetaFallback(pool.token1);
+  const prices = derivePrices(pool.slot0[0], token0.decimals, token1.decimals);
+  const activeLiquidityEstimate = estimateActiveLiquidity(
+    pool.liquidity,
+    pool.slot0[0],
+    token0.decimals,
+    token1.decimals,
+    prices
+  );
+  return {
+    pool: checksumAddress(pool.pool),
+    pair: `${token0.symbol}/${token1.symbol}`,
+    token0,
+    token1,
+    fee: pool.fee,
+    feePercent: pool.fee / 1e4,
+    tickSpacing: pool.tickSpacing,
+    liquidity: pool.liquidity.toString(),
+    currentTick: pool.slot0[1],
+    sqrtPriceX96: pool.slot0[0].toString(),
+    activeLiquidityEstimate,
+    price: prices
+  };
+}
+function normalizeAddress(address) {
+  return address.toLowerCase();
+}
+var cl = Cli.create("cl", {
+  description: "Concentrated liquidity (Slipstream) pools, positions, and quotes."
+});
+cl.command("pools", {
+  description: "List Slipstream pools with current state, prices, and active liquidity estimate.",
+  env,
+  output: z.object({
+    count: z.number(),
+    pools: z.array(poolRowSchema)
+  }),
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const pools = await listPoolAddresses(client);
+    const poolStates = await readPoolStates(client, pools);
+    const tokenMeta = await readTokenMetadata(
+      client,
+      poolStates.flatMap((pool) => [pool.token0, pool.token1])
+    );
+    const rows = poolStates.map((pool) => toPoolRow(pool, tokenMeta));
+    return c.ok({
+      count: rows.length,
+      pools: rows
+    });
+  }
+});
+cl.command("pool", {
+  description: "Get detailed state for a Slipstream pool address.",
+  args: z.object({
+    pool: z.string().describe("Pool address")
+  }),
+  env,
+  output: z.object({
+    pool: poolRowSchema
+  }),
+  async run(c) {
+    if (!isAddress(c.args.pool)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: `Invalid pool address: "${c.args.pool}". Use a valid 0x-prefixed 20-byte hex address.`
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const checksummedPool = checksumAddress(c.args.pool);
+    const [poolState] = await readPoolStates(client, [checksummedPool]);
+    const tokenMeta = await readTokenMetadata(client, [poolState.token0, poolState.token1]);
+    return c.ok({
+      pool: toPoolRow(poolState, tokenMeta)
+    });
+  }
+});
+cl.command("positions", {
+  description: "List concentrated liquidity NFT positions for an owner.",
+  args: z.object({
+    owner: z.string().describe("Owner wallet address")
+  }),
+  env,
+  output: z.object({
+    owner: z.string(),
+    count: z.number(),
+    positions: z.array(
+      z.object({
+        tokenId: z.string(),
+        pair: z.string(),
+        token0: tokenSchema,
+        token1: tokenSchema,
+        tickSpacing: z.number(),
+        tickLower: z.number(),
+        tickUpper: z.number(),
+        liquidity: z.string(),
+        tokensOwed0: z.object({ raw: z.string(), decimal: z.string() }),
+        tokensOwed1: z.object({ raw: z.string(), decimal: z.string() })
+      })
+    )
+  }),
+  async run(c) {
+    if (!isAddress(c.args.owner)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: `Invalid owner address: "${c.args.owner}". Use a valid 0x-prefixed 20-byte hex address.`
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const owner = checksumAddress(c.args.owner);
+    const balance = await client.readContract({
+      abi: nonfungiblePositionManagerAbi,
+      address: ABOREAN_CL_ADDRESSES.nonfungiblePositionManager,
+      functionName: "balanceOf",
+      args: [owner]
+    });
+    if (balance === 0n) {
+      return c.ok({ owner, count: 0, positions: [] });
+    }
+    const tokenIdContracts = Array.from({ length: Number(balance) }, (_, i) => ({
+      abi: nonfungiblePositionManagerAbi,
+      address: ABOREAN_CL_ADDRESSES.nonfungiblePositionManager,
+      functionName: "tokenOfOwnerByIndex",
+      args: [owner, BigInt(i)]
+    }));
+    const tokenIds = await multicallStrict(client, tokenIdContracts);
+    const positionContracts = tokenIds.map((tokenId) => ({
+      abi: nonfungiblePositionManagerAbi,
+      address: ABOREAN_CL_ADDRESSES.nonfungiblePositionManager,
+      functionName: "positions",
+      args: [tokenId]
+    }));
+    const positionsRaw = await multicallStrict(client, positionContracts);
+    const tokenMeta = await readTokenMetadata(
+      client,
+      positionsRaw.flatMap((position) => [position[2], position[3]])
+    );
+    const positions = tokenIds.map((tokenId, i) => {
+      const position = positionsRaw[i];
+      const token0 = tokenMeta.get(position[2]) ?? toTokenMetaFallback(position[2]);
+      const token1 = tokenMeta.get(position[3]) ?? toTokenMetaFallback(position[3]);
+      return {
+        tokenId: tokenId.toString(),
+        pair: `${token0.symbol}/${token1.symbol}`,
+        token0,
+        token1,
+        tickSpacing: position[4],
+        tickLower: position[5],
+        tickUpper: position[6],
+        liquidity: position[7].toString(),
+        tokensOwed0: {
+          raw: position[10].toString(),
+          decimal: formatUnits(position[10], token0.decimals)
+        },
+        tokensOwed1: {
+          raw: position[11].toString(),
+          decimal: formatUnits(position[11], token1.decimals)
+        }
+      };
+    });
+    return c.ok({
+      owner,
+      count: positions.length,
+      positions
+    });
+  }
+});
+cl.command("quote", {
+  description: "Quote a single-hop Slipstream swap via QuoterV2.",
+  args: z.object({
+    tokenIn: z.string().describe("Input token address"),
+    tokenOut: z.string().describe("Output token address"),
+    amountIn: z.string().describe("Input amount in human-readable decimal units")
+  }),
+  options: z.object({
+    fee: z.coerce.number().int().positive().optional().describe("Optional fee tier filter")
+  }),
+  env,
+  output: quoteOutputSchema,
+  async run(c) {
+    const { tokenIn, tokenOut, amountIn } = c.args;
+    if (!isAddress(tokenIn) || !isAddress(tokenOut)) {
+      return c.error({
+        code: "INVALID_ADDRESS",
+        message: "tokenIn and tokenOut must both be valid 0x-prefixed 20-byte addresses."
+      });
+    }
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const inAddress = checksumAddress(tokenIn);
+    const outAddress = checksumAddress(tokenOut);
+    const allPools = await listPoolAddresses(client);
+    const poolStates = await readPoolStates(client, allPools);
+    const pairPools = poolStates.filter((pool) => {
+      const a = normalizeAddress(pool.token0);
+      const b = normalizeAddress(pool.token1);
+      const tokenInNorm = normalizeAddress(inAddress);
+      const tokenOutNorm = normalizeAddress(outAddress);
+      return a === tokenInNorm && b === tokenOutNorm || a === tokenOutNorm && b === tokenInNorm;
+    });
+    const filteredPools = typeof c.options.fee === "number" ? pairPools.filter((pool) => pool.fee === c.options.fee) : pairPools;
+    if (filteredPools.length === 0) {
+      return c.error({
+        code: "POOL_NOT_FOUND",
+        message: typeof c.options.fee === "number" ? `No Slipstream pool found for pair ${inAddress}/${outAddress} at fee tier ${c.options.fee}.` : `No Slipstream pool found for pair ${inAddress}/${outAddress}.`
+      });
+    }
+    const selectedPool = [...filteredPools].sort((a, b) => {
+      if (a.liquidity === b.liquidity) return 0;
+      return a.liquidity > b.liquidity ? -1 : 1;
+    })[0];
+    const tokenMeta = await readTokenMetadata(client, [inAddress, outAddress]);
+    const inMeta = tokenMeta.get(inAddress) ?? toTokenMetaFallback(inAddress);
+    const outMeta = tokenMeta.get(outAddress) ?? toTokenMetaFallback(outAddress);
+    let amountInRaw;
+    try {
+      amountInRaw = parseUnits(amountIn, inMeta.decimals);
+    } catch {
+      return c.error({
+        code: "INVALID_AMOUNT",
+        message: `Invalid amountIn: "${amountIn}" for token ${inMeta.symbol} (${inMeta.decimals} decimals).`
+      });
+    }
+    const quote = await client.readContract({
+      abi: quoterV2Abi,
+      address: ABOREAN_CL_ADDRESSES.quoterV2,
+      functionName: "quoteExactInputSingle",
+      args: [
+        {
+          tokenIn: inAddress,
+          tokenOut: outAddress,
+          amountIn: amountInRaw,
+          tickSpacing: selectedPool.tickSpacing,
+          sqrtPriceLimitX96: 0n
+        }
+      ]
+    });
+    const amountOutRaw = quote[0];
+    const amountOutDecimal = formatUnits(amountOutRaw, outMeta.decimals);
+    const amountInDecimal = formatUnits(amountInRaw, inMeta.decimals);
+    const quotePriceOutPerIn = Number(amountInDecimal) === 0 ? null : finiteOrNull(Number(amountOutDecimal) / Number(amountInDecimal));
+    const poolTokenMeta = await readTokenMetadata(client, [
+      selectedPool.token0,
+      selectedPool.token1
+    ]);
+    const poolToken0Meta = poolTokenMeta.get(selectedPool.token0) ?? toTokenMetaFallback(selectedPool.token0);
+    const poolToken1Meta = poolTokenMeta.get(selectedPool.token1) ?? toTokenMetaFallback(selectedPool.token1);
+    const poolPrices = derivePrices(
+      selectedPool.slot0[0],
+      poolToken0Meta.decimals,
+      poolToken1Meta.decimals
+    );
+    const inIsToken0 = normalizeAddress(inAddress) === normalizeAddress(selectedPool.token0);
+    const poolMidPriceOutPerIn = inIsToken0 ? poolPrices.token1PerToken0 : poolPrices.token0PerToken1;
+    const priceImpactPct = quotePriceOutPerIn === null || poolMidPriceOutPerIn === null || poolMidPriceOutPerIn === 0 ? null : finiteOrNull((poolMidPriceOutPerIn - quotePriceOutPerIn) / poolMidPriceOutPerIn * 100);
+    return c.ok({
+      pool: checksumAddress(selectedPool.pool),
+      selectedFee: selectedPool.fee,
+      selectedTickSpacing: selectedPool.tickSpacing,
+      tokenIn: inMeta,
+      tokenOut: outMeta,
+      amountIn: {
+        raw: amountInRaw.toString(),
+        decimal: amountInDecimal
+      },
+      amountOut: {
+        raw: amountOutRaw.toString(),
+        decimal: amountOutDecimal
+      },
+      execution: {
+        sqrtPriceX96After: quote[1].toString(),
+        initializedTicksCrossed: quote[2],
+        gasEstimate: quote[3].toString()
+      },
+      prices: {
+        poolMidPriceOutPerIn,
+        quotePriceOutPerIn,
+        priceImpactPct
+      }
+    });
+  }
+});
+
+// src/commands/gauges.ts
+import { Cli as Cli2, z as z2 } from "incur";
+
+// src/commands/_common.ts
+import { checksumAddress as checksumAddress2, weiToEth } from "@spectratools/cli-shared";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function toChecksum(address) {
+  try {
+    return checksumAddress2(address);
+  } catch {
+    return address;
+  }
+}
+function asNum(value) {
+  return Number(value);
+}
+function relTime(unixSeconds) {
+  const ts = typeof unixSeconds === "bigint" ? Number(unixSeconds) : unixSeconds;
+  if (!Number.isFinite(ts) || ts <= 0) return "n/a";
+  const delta = ts - Math.floor(Date.now() / 1e3);
+  const abs = Math.abs(delta);
+  const hours = Math.floor(abs / 3600);
+  const minutes = Math.floor(abs % 3600 / 60);
+  const label = hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
+  return delta >= 0 ? `in ${label}` : `${label} ago`;
+}
+function clampPositive(seconds) {
+  return seconds > 0 ? seconds : 0;
+}
+
+// src/commands/gauges.ts
+var env2 = z2.object({
+  ABSTRACT_RPC_URL: z2.string().optional().describe("Abstract RPC URL override")
+});
+async function discoverGaugePools(client) {
+  const [v2PoolCount, clPoolCount] = await Promise.all([
+    client.readContract({
+      abi: poolFactoryAbi,
+      address: ABOREAN_V2_ADDRESSES.poolFactory,
+      functionName: "allPoolsLength"
+    }),
+    client.readContract({
+      abi: clFactoryAbi,
+      address: ABOREAN_CL_ADDRESSES.clFactory,
+      functionName: "allPoolsLength"
+    })
+  ]);
+  const v2Indices = Array.from({ length: asNum(v2PoolCount) }, (_, i) => BigInt(i));
+  const clIndices = Array.from({ length: asNum(clPoolCount) }, (_, i) => BigInt(i));
+  const [v2Pools, clPools] = await Promise.all([
+    v2Indices.length ? client.multicall({
+      allowFailure: false,
+      contracts: v2Indices.map((index) => ({
+        abi: poolFactoryAbi,
+        address: ABOREAN_V2_ADDRESSES.poolFactory,
+        functionName: "allPools",
+        args: [index]
+      }))
+    }) : 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 pools = [...v2Pools, ...clPools];
+  if (!pools.length) return [];
+  const gauges2 = await client.multicall({
+    allowFailure: false,
+    contracts: pools.map((pool) => ({
+      abi: voterAbi,
+      address: ABOREAN_V2_ADDRESSES.voter,
+      functionName: "gauges",
+      args: [pool]
+    }))
+  });
+  return pools.map((pool, index) => ({ pool, gauge: gauges2[index] })).filter(({ gauge }) => gauge.toLowerCase() !== ZERO_ADDRESS.toLowerCase());
+}
+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()
+  }),
+  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;
+      const rewardToken = details[offset];
+      const rewardRate = details[offset + 1];
+      const totalStaked = details[offset + 2];
+      const periodFinish = details[offset + 3];
+      const claimableEmissions = details[offset + 4];
+      return {
+        pool: toChecksum(pool),
+        gauge: toChecksum(gauge),
+        rewardToken: toChecksum(rewardToken),
+        rewardRate: rewardRate.toString(),
+        totalStaked: totalStaked.toString(),
+        claimableEmissions: claimableEmissions.toString(),
+        periodFinish: asNum(periodFinish),
+        periodFinishRelative: relTime(periodFinish)
+      };
+    });
+    return c.ok({
+      gauges: items,
+      count: items.length
+    });
+  }
+});
+gauges.command("info", {
+  description: "Get detailed state for one gauge address.",
+  args: z2.object({
+    gauge: z2.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()
+  }),
+  examples: [
+    {
+      args: { gauge: "0x0000000000000000000000000000000000000001" },
+      description: "Inspect one gauge in detail"
+    }
+  ],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const gauge = c.args.gauge;
+    const [
+      pool,
+      isAlive,
+      bribeContract,
+      feeContract,
+      stakingToken,
+      rewardToken,
+      totalStaked,
+      rewardRate,
+      periodFinish,
+      lastUpdateTime,
+      rewardPerTokenStored,
+      fees0,
+      fees1,
+      left
+    ] = await Promise.all([
+      client.readContract({
+        abi: voterAbi,
+        address: ABOREAN_V2_ADDRESSES.voter,
+        functionName: "poolForGauge",
+        args: [gauge]
+      }),
+      client.readContract({
+        abi: voterAbi,
+        address: ABOREAN_V2_ADDRESSES.voter,
+        functionName: "isAlive",
+        args: [gauge]
+      }),
+      client.readContract({
+        abi: voterAbi,
+        address: ABOREAN_V2_ADDRESSES.voter,
+        functionName: "gaugeToBribe",
+        args: [gauge]
+      }),
+      client.readContract({
+        abi: voterAbi,
+        address: ABOREAN_V2_ADDRESSES.voter,
+        functionName: "gaugeToFees",
+        args: [gauge]
+      }),
+      client.readContract({
+        abi: gaugeAbi,
+        address: gauge,
+        functionName: "stakingToken"
+      }),
+      client.readContract({
+        abi: gaugeAbi,
+        address: gauge,
+        functionName: "rewardToken"
+      }),
+      client.readContract({
+        abi: gaugeAbi,
+        address: gauge,
+        functionName: "totalSupply"
+      }),
+      client.readContract({
+        abi: gaugeAbi,
+        address: gauge,
+        functionName: "rewardRate"
+      }),
+      client.readContract({
+        abi: gaugeAbi,
+        address: gauge,
+        functionName: "periodFinish"
+      }),
+      client.readContract({
+        abi: gaugeAbi,
+        address: gauge,
+        functionName: "lastUpdateTime"
+      }),
+      client.readContract({
+        abi: gaugeAbi,
+        address: gauge,
+        functionName: "rewardPerTokenStored"
+      }),
+      client.readContract({
+        abi: gaugeAbi,
+        address: gauge,
+        functionName: "fees0"
+      }),
+      client.readContract({
+        abi: gaugeAbi,
+        address: gauge,
+        functionName: "fees1"
+      }),
+      client.readContract({
+        abi: gaugeAbi,
+        address: gauge,
+        functionName: "left"
+      })
+    ]);
+    return c.ok({
+      gauge: toChecksum(gauge),
+      pool: toChecksum(pool),
+      isAlive,
+      stakingToken: toChecksum(stakingToken),
+      rewardToken: toChecksum(rewardToken),
+      totalStaked: totalStaked.toString(),
+      rewardRate: rewardRate.toString(),
+      rewardPerTokenStored: rewardPerTokenStored.toString(),
+      fees0: fees0.toString(),
+      fees1: fees1.toString(),
+      left: left.toString(),
+      periodFinish: asNum(periodFinish),
+      periodFinishRelative: relTime(periodFinish),
+      lastUpdateTime: asNum(lastUpdateTime),
+      bribeContract: toChecksum(bribeContract),
+      feeContract: toChecksum(feeContract)
+    });
+  }
+});
+gauges.command("staked", {
+  description: "Show one address staking positions across all gauges.",
+  args: z2.object({
+    address: z2.string().describe("Wallet address to inspect")
+  }),
+  env: env2,
+  output: z2.object({
+    address: z2.string(),
+    positions: z2.array(
+      z2.object({
+        pool: z2.string(),
+        gauge: z2.string(),
+        rewardToken: z2.string(),
+        staked: z2.string(),
+        earned: z2.string()
+      })
+    ),
+    count: z2.number()
+  }),
+  examples: [
+    {
+      args: { address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" },
+      description: "List gauge positions for a wallet"
+    }
+  ],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const gaugePools = await discoverGaugePools(client);
+    if (!gaugePools.length) {
+      return c.ok({
+        address: toChecksum(c.args.address),
+        positions: [],
+        count: 0
+      });
+    }
+    const positionData = await client.multicall({
+      allowFailure: false,
+      contracts: gaugePools.flatMap(({ gauge }) => [
+        {
+          abi: gaugeAbi,
+          address: gauge,
+          functionName: "balanceOf",
+          args: [c.args.address]
+        },
+        {
+          abi: gaugeAbi,
+          address: gauge,
+          functionName: "earned",
+          args: [c.args.address]
+        },
+        {
+          abi: gaugeAbi,
+          address: gauge,
+          functionName: "rewardToken"
+        }
+      ])
+    });
+    const positions = gaugePools.map(({ pool, gauge }, index) => {
+      const offset = index * 3;
+      const staked = positionData[offset];
+      const earned = positionData[offset + 1];
+      const rewardToken = positionData[offset + 2];
+      return {
+        pool: toChecksum(pool),
+        gauge: toChecksum(gauge),
+        rewardToken: toChecksum(rewardToken),
+        staked,
+        earned
+      };
+    }).filter((position) => position.staked > 0n || position.earned > 0n).map((position) => ({
+      pool: position.pool,
+      gauge: position.gauge,
+      rewardToken: position.rewardToken,
+      staked: position.staked.toString(),
+      earned: position.earned.toString()
+    }));
+    return c.ok({
+      address: toChecksum(c.args.address),
+      positions,
+      count: positions.length
+    });
+  }
+});
+
+// src/commands/ve.ts
+import { Cli as Cli3, z as z3 } from "incur";
+var env3 = z3.object({
+  ABSTRACT_RPC_URL: z3.string().optional().describe("Abstract RPC URL override")
+});
+var ve = Cli3.create("ve", {
+  description: "Inspect Aborean VotingEscrow (veABX) global and per-NFT lock state."
+});
+ve.command("stats", {
+  description: "Get global VotingEscrow supply, locks, and decay checkpoint data.",
+  env: env3,
+  output: z3.object({
+    token: z3.string(),
+    totalVotingPower: z3.string(),
+    totalLocked: z3.string(),
+    permanentLocked: z3.string(),
+    epoch: z3.number(),
+    decayBias: z3.string(),
+    decaySlope: z3.string(),
+    lastCheckpointTimestamp: z3.number(),
+    lastCheckpointBlock: z3.number()
+  }),
+  examples: [{ description: "Show global veABX state and decay metrics" }],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const [token, totalVotingPower, totalLocked, permanentLocked, epoch] = await Promise.all([
+      client.readContract({
+        abi: votingEscrowAbi,
+        address: ABOREAN_V2_ADDRESSES.votingEscrow,
+        functionName: "token"
+      }),
+      client.readContract({
+        abi: votingEscrowAbi,
+        address: ABOREAN_V2_ADDRESSES.votingEscrow,
+        functionName: "totalSupply"
+      }),
+      client.readContract({
+        abi: votingEscrowAbi,
+        address: ABOREAN_V2_ADDRESSES.votingEscrow,
+        functionName: "supply"
+      }),
+      client.readContract({
+        abi: votingEscrowAbi,
+        address: ABOREAN_V2_ADDRESSES.votingEscrow,
+        functionName: "permanentLockBalance"
+      }),
+      client.readContract({
+        abi: votingEscrowAbi,
+        address: ABOREAN_V2_ADDRESSES.votingEscrow,
+        functionName: "epoch"
+      })
+    ]);
+    const point = await client.readContract({
+      abi: votingEscrowAbi,
+      address: ABOREAN_V2_ADDRESSES.votingEscrow,
+      functionName: "pointHistory",
+      args: [epoch]
+    });
+    return c.ok({
+      token: toChecksum(token),
+      totalVotingPower: totalVotingPower.toString(),
+      totalLocked: totalLocked.toString(),
+      permanentLocked: permanentLocked.toString(),
+      epoch: asNum(epoch),
+      decayBias: point.bias.toString(),
+      decaySlope: point.slope.toString(),
+      lastCheckpointTimestamp: asNum(point.ts),
+      lastCheckpointBlock: asNum(point.blk)
+    });
+  }
+});
+ve.command("lock", {
+  description: "Get lock details and voting power for one veNFT token id.",
+  args: z3.object({
+    tokenId: z3.coerce.number().int().nonnegative().describe("veNFT token id")
+  }),
+  env: env3,
+  output: z3.object({
+    tokenId: z3.number(),
+    owner: z3.string(),
+    amount: z3.string(),
+    unlockTime: z3.number(),
+    isPermanent: z3.boolean(),
+    votingPower: z3.string()
+  }),
+  examples: [{ args: { tokenId: 1 }, description: "Inspect lock details for veNFT #1" }],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const tokenId = BigInt(c.args.tokenId);
+    const [owner, locked, votingPower] = await Promise.all([
+      client.readContract({
+        abi: votingEscrowAbi,
+        address: ABOREAN_V2_ADDRESSES.votingEscrow,
+        functionName: "ownerOf",
+        args: [tokenId]
+      }),
+      client.readContract({
+        abi: votingEscrowAbi,
+        address: ABOREAN_V2_ADDRESSES.votingEscrow,
+        functionName: "locked",
+        args: [tokenId]
+      }),
+      client.readContract({
+        abi: votingEscrowAbi,
+        address: ABOREAN_V2_ADDRESSES.votingEscrow,
+        functionName: "balanceOfNFT",
+        args: [tokenId]
+      })
+    ]);
+    return c.ok({
+      tokenId: c.args.tokenId,
+      owner: toChecksum(owner),
+      amount: locked.amount.toString(),
+      unlockTime: asNum(locked.end),
+      isPermanent: locked.isPermanent,
+      votingPower: votingPower.toString()
+    });
+  }
+});
+ve.command("locks", {
+  description: "List all veNFT locks owned by an address.",
+  args: z3.object({
+    address: z3.string().describe("Owner address")
+  }),
+  env: env3,
+  output: z3.object({
+    address: z3.string(),
+    locks: z3.array(
+      z3.object({
+        tokenId: z3.string(),
+        amount: z3.string(),
+        unlockTime: z3.number(),
+        isPermanent: z3.boolean(),
+        votingPower: z3.string()
+      })
+    ),
+    count: z3.number()
+  }),
+  examples: [
+    {
+      args: { address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" },
+      description: "List all veNFT locks for an address"
+    }
+  ],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const balance = await client.readContract({
+      abi: votingEscrowAbi,
+      address: ABOREAN_V2_ADDRESSES.votingEscrow,
+      functionName: "balanceOf",
+      args: [c.args.address]
+    });
+    const count = asNum(balance);
+    if (!count) {
+      return c.ok({
+        address: toChecksum(c.args.address),
+        locks: [],
+        count: 0
+      });
     }
+    const indices = Array.from({ length: count }, (_, i) => BigInt(i));
+    const tokenIds = await client.multicall({
+      allowFailure: false,
+      contracts: indices.map((index) => ({
+        abi: votingEscrowAbi,
+        address: ABOREAN_V2_ADDRESSES.votingEscrow,
+        functionName: "tokenOfOwnerByIndex",
+        args: [c.args.address, index]
+      }))
+    });
+    const lockData = await client.multicall({
+      allowFailure: false,
+      contracts: tokenIds.flatMap((tokenId) => [
+        {
+          abi: votingEscrowAbi,
+          address: ABOREAN_V2_ADDRESSES.votingEscrow,
+          functionName: "locked",
+          args: [tokenId]
+        },
+        {
+          abi: votingEscrowAbi,
+          address: ABOREAN_V2_ADDRESSES.votingEscrow,
+          functionName: "balanceOfNFT",
+          args: [tokenId]
+        }
+      ])
+    });
+    const locks = tokenIds.map((tokenId, index) => {
+      const offset = index * 2;
+      const locked = lockData[offset];
+      const votingPower = lockData[offset + 1];
+      return {
+        tokenId: tokenId.toString(),
+        amount: locked.amount.toString(),
+        unlockTime: asNum(locked.end),
+        isPermanent: locked.isPermanent,
+        votingPower: votingPower.toString()
+      };
+    });
+    return c.ok({
+      address: toChecksum(c.args.address),
+      locks,
+      count: locks.length
+    });
   }
 });
-function createAboreanPublicClient(rpcUrl) {
-  return createPublicClient({
-    chain: abstractMainnet,
-    transport: http(rpcUrl ?? process.env.ABSTRACT_RPC_URL ?? "https://api.mainnet.abs.xyz")
-  });
+ve.command("voting-power", {
+  description: "Get current voting power for one veNFT token id.",
+  args: z3.object({
+    tokenId: z3.coerce.number().int().nonnegative().describe("veNFT token id")
+  }),
+  env: env3,
+  output: z3.object({
+    tokenId: z3.number(),
+    votingPower: z3.string()
+  }),
+  examples: [{ args: { tokenId: 1 }, description: "Get current voting power for veNFT #1" }],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const votingPower = await client.readContract({
+      abi: votingEscrowAbi,
+      address: ABOREAN_V2_ADDRESSES.votingEscrow,
+      functionName: "balanceOfNFT",
+      args: [BigInt(c.args.tokenId)]
+    });
+    return c.ok({
+      tokenId: c.args.tokenId,
+      votingPower: votingPower.toString()
+    });
+  }
+});
+
+// src/commands/voter.ts
+import { Cli as Cli4, z as z4 } from "incur";
+var env4 = z4.object({
+  ABSTRACT_RPC_URL: z4.string().optional().describe("Abstract RPC URL override")
+});
+async function discoverPools(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([])
+  ]);
+  return [...v2Pools, ...clPools];
 }
+var voter = Cli4.create("voter", {
+  description: "Inspect Aborean voter epoch, pool weights, and claimable rewards context."
+});
+voter.command("epoch", {
+  description: "Show current emissions epoch timing from Minter.",
+  env: env4,
+  output: z4.object({
+    activePeriod: z4.number(),
+    epochEnd: z4.number(),
+    secondsRemaining: z4.number(),
+    timeRemaining: z4.string(),
+    weekSeconds: z4.number(),
+    epochCount: z4.number(),
+    weeklyEmission: z4.string()
+  }),
+  examples: [{ description: "Inspect current voter epoch boundaries" }],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const [activePeriod, weekSeconds, epochCount, weeklyEmission] = await Promise.all([
+      client.readContract({
+        abi: minterAbi,
+        address: ABOREAN_V2_ADDRESSES.minter,
+        functionName: "activePeriod"
+      }),
+      client.readContract({
+        abi: minterAbi,
+        address: ABOREAN_V2_ADDRESSES.minter,
+        functionName: "WEEK"
+      }),
+      client.readContract({
+        abi: minterAbi,
+        address: ABOREAN_V2_ADDRESSES.minter,
+        functionName: "epochCount"
+      }),
+      client.readContract({
+        abi: minterAbi,
+        address: ABOREAN_V2_ADDRESSES.minter,
+        functionName: "weekly"
+      })
+    ]);
+    const now = Math.floor(Date.now() / 1e3);
+    const epochEnd = asNum(activePeriod + weekSeconds);
+    return c.ok({
+      activePeriod: asNum(activePeriod),
+      epochEnd,
+      secondsRemaining: clampPositive(epochEnd - now),
+      timeRemaining: relTime(activePeriod + weekSeconds),
+      weekSeconds: asNum(weekSeconds),
+      epochCount: asNum(epochCount),
+      weeklyEmission: weeklyEmission.toString()
+    });
+  }
+});
+voter.command("weights", {
+  description: "Show current pool voting weight distribution.",
+  env: env4,
+  output: z4.object({
+    totalWeight: z4.string(),
+    pools: z4.array(
+      z4.object({
+        pool: z4.string(),
+        gauge: z4.string(),
+        weight: z4.string()
+      })
+    ),
+    count: z4.number()
+  }),
+  examples: [{ description: "List all pools with non-zero voting weight" }],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const pools = await discoverPools(client);
+    if (!pools.length) {
+      return c.ok({ totalWeight: "0", pools: [], count: 0 });
+    }
+    const [totalWeight, poolData] = await Promise.all([
+      client.readContract({
+        abi: voterAbi,
+        address: ABOREAN_V2_ADDRESSES.voter,
+        functionName: "totalWeight"
+      }),
+      client.multicall({
+        allowFailure: false,
+        contracts: pools.flatMap((pool) => [
+          {
+            abi: voterAbi,
+            address: ABOREAN_V2_ADDRESSES.voter,
+            functionName: "gauges",
+            args: [pool]
+          },
+          {
+            abi: voterAbi,
+            address: ABOREAN_V2_ADDRESSES.voter,
+            functionName: "weights",
+            args: [pool]
+          }
+        ])
+      })
+    ]);
+    const entries = pools.map((pool, index) => {
+      const offset = index * 2;
+      const gauge = poolData[offset] ?? ZERO_ADDRESS;
+      const weight = poolData[offset + 1] ?? 0n;
+      return {
+        pool,
+        gauge,
+        weight
+      };
+    }).filter(
+      (entry) => entry.gauge.toLowerCase() !== ZERO_ADDRESS.toLowerCase() && entry.weight > 0n
+    ).sort((a, b) => a.weight > b.weight ? -1 : a.weight < b.weight ? 1 : 0).map((entry) => ({
+      pool: toChecksum(entry.pool),
+      gauge: toChecksum(entry.gauge),
+      weight: entry.weight.toString()
+    }));
+    return c.ok({
+      totalWeight: totalWeight.toString(),
+      pools: entries,
+      count: entries.length
+    });
+  }
+});
+voter.command("rewards", {
+  description: "Show claimable rebase rewards and voting context for a veNFT.",
+  args: z4.object({
+    tokenId: z4.coerce.number().int().nonnegative().describe("veNFT token id")
+  }),
+  env: env4,
+  output: z4.object({
+    tokenId: z4.number(),
+    rewardToken: z4.string(),
+    claimableRebase: z4.string(),
+    timeCursor: z4.number(),
+    lastTokenTime: z4.number(),
+    distributorStartTime: z4.number(),
+    usedWeight: z4.string(),
+    lastVoted: z4.number()
+  }),
+  examples: [{ args: { tokenId: 1 }, description: "Check claimable voter/distributor rewards" }],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const tokenId = BigInt(c.args.tokenId);
+    const [
+      rewardToken,
+      claimableRebase,
+      timeCursor,
+      lastTokenTime,
+      distributorStartTime,
+      usedWeight,
+      lastVoted
+    ] = await Promise.all([
+      client.readContract({
+        abi: rewardsDistributorAbi,
+        address: ABOREAN_V2_ADDRESSES.rewardsDistributor,
+        functionName: "token"
+      }),
+      client.readContract({
+        abi: rewardsDistributorAbi,
+        address: ABOREAN_V2_ADDRESSES.rewardsDistributor,
+        functionName: "claimable",
+        args: [tokenId]
+      }),
+      client.readContract({
+        abi: rewardsDistributorAbi,
+        address: ABOREAN_V2_ADDRESSES.rewardsDistributor,
+        functionName: "timeCursorOf",
+        args: [tokenId]
+      }),
+      client.readContract({
+        abi: rewardsDistributorAbi,
+        address: ABOREAN_V2_ADDRESSES.rewardsDistributor,
+        functionName: "lastTokenTime"
+      }),
+      client.readContract({
+        abi: rewardsDistributorAbi,
+        address: ABOREAN_V2_ADDRESSES.rewardsDistributor,
+        functionName: "startTime"
+      }),
+      client.readContract({
+        abi: voterAbi,
+        address: ABOREAN_V2_ADDRESSES.voter,
+        functionName: "usedWeights",
+        args: [tokenId]
+      }),
+      client.readContract({
+        abi: voterAbi,
+        address: ABOREAN_V2_ADDRESSES.voter,
+        functionName: "lastVoted",
+        args: [tokenId]
+      })
+    ]);
+    return c.ok({
+      tokenId: c.args.tokenId,
+      rewardToken: toChecksum(rewardToken),
+      claimableRebase: claimableRebase.toString(),
+      timeCursor: asNum(timeCursor),
+      lastTokenTime: asNum(lastTokenTime),
+      distributorStartTime: asNum(distributorStartTime),
+      usedWeight: usedWeight.toString(),
+      lastVoted: asNum(lastVoted)
+    });
+  }
+});
+voter.command("bribes", {
+  description: "Show active bribe reward tokens and current-epoch amounts for a pool.",
+  args: z4.object({
+    pool: z4.string().describe("Pool address")
+  }),
+  env: env4,
+  output: z4.object({
+    pool: z4.string(),
+    gauge: z4.string(),
+    bribeContract: z4.string(),
+    epochStart: z4.number(),
+    rewardTokens: z4.array(
+      z4.object({
+        token: z4.string(),
+        epochAmount: z4.string()
+      })
+    ),
+    count: z4.number()
+  }),
+  examples: [
+    {
+      args: { pool: "0x0000000000000000000000000000000000000001" },
+      description: "Inspect bribe reward tokens for one pool"
+    }
+  ],
+  async run(c) {
+    const client = createAboreanPublicClient(c.env.ABSTRACT_RPC_URL);
+    const [gauge, epochStart] = await Promise.all([
+      client.readContract({
+        abi: voterAbi,
+        address: ABOREAN_V2_ADDRESSES.voter,
+        functionName: "gauges",
+        args: [c.args.pool]
+      }),
+      client.readContract({
+        abi: minterAbi,
+        address: ABOREAN_V2_ADDRESSES.minter,
+        functionName: "activePeriod"
+      })
+    ]);
+    if (gauge.toLowerCase() === ZERO_ADDRESS.toLowerCase()) {
+      return c.error({
+        code: "NOT_FOUND",
+        message: `No gauge exists for pool ${c.args.pool}`,
+        retryable: false
+      });
+    }
+    const bribeContract = await client.readContract({
+      abi: voterAbi,
+      address: ABOREAN_V2_ADDRESSES.voter,
+      functionName: "gaugeToBribe",
+      args: [gauge]
+    });
+    if (bribeContract.toLowerCase() === ZERO_ADDRESS.toLowerCase()) {
+      return c.ok({
+        pool: toChecksum(c.args.pool),
+        gauge: toChecksum(gauge),
+        bribeContract: toChecksum(bribeContract),
+        epochStart: asNum(epochStart),
+        rewardTokens: [],
+        count: 0
+      });
+    }
+    const rewardsLength = await client.readContract({
+      abi: votingRewardAbi,
+      address: bribeContract,
+      functionName: "rewardsListLength"
+    });
+    const tokenCount = asNum(rewardsLength);
+    if (!tokenCount) {
+      return c.ok({
+        pool: toChecksum(c.args.pool),
+        gauge: toChecksum(gauge),
+        bribeContract: toChecksum(bribeContract),
+        epochStart: asNum(epochStart),
+        rewardTokens: [],
+        count: 0
+      });
+    }
+    const tokenIndices = Array.from({ length: tokenCount }, (_, i) => BigInt(i));
+    const rewardTokens = await client.multicall({
+      allowFailure: false,
+      contracts: tokenIndices.map((index) => ({
+        abi: votingRewardAbi,
+        address: bribeContract,
+        functionName: "rewards",
+        args: [index]
+      }))
+    });
+    const epochAmounts = await client.multicall({
+      allowFailure: false,
+      contracts: rewardTokens.map((token) => ({
+        abi: votingRewardAbi,
+        address: bribeContract,
+        functionName: "tokenRewardsPerEpoch",
+        args: [token, epochStart]
+      }))
+    });
+    const items = rewardTokens.map((token, index) => ({
+      token: toChecksum(token),
+      epochAmount: epochAmounts[index].toString()
+    }));
+    return c.ok({
+      pool: toChecksum(c.args.pool),
+      gauge: toChecksum(gauge),
+      bribeContract: toChecksum(bribeContract),
+      epochStart: asNum(epochStart),
+      rewardTokens: items,
+      count: items.length
+    });
+  }
+});
 
 // src/error-handling.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -576,23 +2599,27 @@ function applyFriendlyErrorHandling(cli2) {
 // src/cli.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf8"));
-var cli = Cli.create("aborean", {
+var cli = Cli5.create("aborean", {
   version: pkg.version,
   description: "Aborean Finance DEX CLI for Abstract chain."
 });
-var rootEnv = z.object({
-  ABSTRACT_RPC_URL: z.string().optional().describe("Abstract RPC URL override")
+cli.command(gauges);
+cli.command(ve);
+cli.command(voter);
+var rootEnv = z5.object({
+  ABSTRACT_RPC_URL: z5.string().optional().describe("Abstract RPC URL override")
 });
+cli.command(cl);
 cli.command("status", {
   description: "Get a cross-contract Aborean protocol snapshot (pool counts, gauge count, veABX supply).",
   env: rootEnv,
-  output: z.object({
-    v2PoolCount: z.number().describe("Number of V2 AMM pools"),
-    clPoolCount: z.number().describe("Number of Slipstream (CL) pools"),
-    gaugeCount: z.number().describe("Number of pools with gauges"),
-    totalVotingWeight: z.string().describe("Total voting weight (wei)"),
-    veABXTotalSupply: z.string().describe("Total veABX supply (wei)"),
-    veABXLockedSupply: z.string().describe("Total ABX locked in VotingEscrow (wei)")
+  output: z5.object({
+    v2PoolCount: z5.number().describe("Number of V2 AMM pools"),
+    clPoolCount: z5.number().describe("Number of Slipstream (CL) pools"),
+    gaugeCount: z5.number().describe("Number of pools with gauges"),
+    totalVotingWeight: z5.string().describe("Total voting weight (wei)"),
+    veABXTotalSupply: z5.string().describe("Total veABX supply (wei)"),
+    veABXLockedSupply: z5.string().describe("Total ABX locked in VotingEscrow (wei)")
   }),
   examples: [{ description: "Fetch the current Aborean protocol status" }],
   async run(c) {