Add ve(3,3) gauge staking, vote-escrow, and reward farming

- New Gauge, VoteEscrow, Voter traits in defi-core
- SolidlyGauge adapter for Ramses, NEST, Ring Few
- CLI `defi gauge` command: deposit, withdraw, claim, lock, vote
- RewardInfo, GaugeInfo, VeNftInfo types
- Ramses voter/ve_token/gauge_factory addresses from official docs
- NEST veNEST address verified on-chain

Supports full ve(3,3) farming cycle:
  LP stake → gauge rewards → lock veNFT → vote → claim bribes

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Hiksang

config/protocols/dex/nest.toml

@@ -8,9 +8,8 @@ native = true
 description = "Algebra V3 ve(3,3) MetaDEX on HyperEVM ($4M TVL)"
 
 [protocol.contracts]
-# NEST uses pool_deployer instead of a typical swap router.
-# Setting router = pool_deployer as workaround; needs custom handling for swaps.
 router = "0x3842CE04380b8655a3a47ed87ea0d311adca161f"
 pool_deployer = "0x3842CE04380b8655a3a47ed87ea0d311adca161f"
 position_manager = "0xeaf58788a405f3253814b4559391a22be8616250"
 voter = "0x566bdc5444fd5fe5d93ec379Bd66eC861ddbA901"
+ve_token = "0x2f2Ae07e3cc3391A2E27825652BA8DcdD5412074"

config/protocols/dex/ramses_cl.toml

@@ -11,3 +11,6 @@ description = "Ramses concentrated liquidity on HyperEVM ($2.8M TVL)"
 factory = "0x07E60782535752be279929e2DFfDd136Db2e6b45"
 router = "0x76D91074B46fF76E04FE59a90526a40009943fd2"
 quoter = "0x403Bf94fe505cA0F0b1563C350B57dCeC8303ECd"
+voter = "0x9aab8C415aF5936b09C595B09B1ff15cbaDCD843"
+ve_token = "0xAE6D5FcE541216BDA471D311425B5412D9f1DEb9"
+gauge_factory = "0xE17988013E15d29B655634Da0056ba27BA4D3E27"

config/protocols/dex/ramses_hl.toml

@@ -10,3 +10,7 @@ description = "Ramses V2 AMM on HyperEVM ($2.6M TVL)"
 [protocol.contracts]
 factory = "0xd0a07E160511c40ccD5340e94660E9C9c01b0D27"
 router = "0xdcC44285fBc236457A5cd91C2f77AD8421B0D8ED"
+voter = "0x9aab8C415aF5936b09C595B09B1ff15cbaDCD843"
+ve_token = "0xAE6D5FcE541216BDA471D311425B5412D9f1DEb9"
+gauge_factory = "0xE17988013E15d29B655634Da0056ba27BA4D3E27"
+minter = "0x252aCC15430a26748CED7376b317e74e250FcF00"

crates/defi-cli/src/commands/gauge.rs

@@ -0,0 +1,205 @@
+use alloy::primitives::{Address, U256};
+use clap::{Args, Subcommand};
+
+use defi_core::error::{DefiError, Result};
+use defi_core::registry::{ChainConfig, Registry};
+
+use crate::executor::Executor;
+use crate::output::OutputMode;
+
+#[derive(Args)]
+pub struct GaugeArgs {
+    #[command(subcommand)]
+    pub command: GaugeCommand,
+}
+
+#[derive(Subcommand)]
+pub enum GaugeCommand {
+    /// Deposit LP tokens into a gauge for farming
+    Deposit {
+        /// Protocol to use (e.g., ramses-cl, nest-v1)
+        #[arg(long)]
+        protocol: String,
+        /// Gauge contract address
+        #[arg(long)]
+        gauge: String,
+        /// LP token amount (raw U256)
+        #[arg(long)]
+        amount: String,
+        /// veNFT token ID for boosted rewards (optional)
+        #[arg(long)]
+        ve_nft: Option<String>,
+    },
+    /// Withdraw LP tokens from a gauge
+    Withdraw {
+        /// Protocol to use
+        #[arg(long)]
+        protocol: String,
+        /// Gauge contract address
+        #[arg(long)]
+        gauge: String,
+        /// LP token amount (raw U256)
+        #[arg(long)]
+        amount: String,
+    },
+    /// Claim earned rewards from a gauge
+    Claim {
+        /// Protocol to use
+        #[arg(long)]
+        protocol: String,
+        /// Gauge contract address
+        #[arg(long)]
+        gauge: String,
+    },
+    /// Create a veNFT lock
+    Lock {
+        /// Protocol to use
+        #[arg(long)]
+        protocol: String,
+        /// Amount to lock (human-readable, 18 decimals)
+        #[arg(long)]
+        amount: String,
+        /// Lock duration in days
+        #[arg(long, default_value = "365")]
+        days: u64,
+    },
+    /// Vote on gauge emissions with veNFT
+    Vote {
+        /// Protocol to use
+        #[arg(long)]
+        protocol: String,
+        /// veNFT token ID
+        #[arg(long)]
+        ve_nft: String,
+        /// Pool addresses (comma-separated)
+        #[arg(long)]
+        pools: String,
+        /// Vote weights (comma-separated, same order as pools)
+        #[arg(long)]
+        weights: String,
+    },
+}
+
+fn parse_amount_18(amount: &str) -> Result<U256> {
+    let parts: Vec<&str> = amount.split('.').collect();
+    let (whole, frac) = match parts.len() {
+        1 => (parts[0], ""),
+        2 => (parts[0], parts[1]),
+        _ => return Err(DefiError::InvalidParam("Invalid amount format".to_string())),
+    };
+    let whole_val = U256::from(
+        whole
+            .parse::<u64>()
+            .map_err(|e| DefiError::InvalidParam(format!("Invalid amount: {e}")))?,
+    );
+    let frac_val = if frac.is_empty() {
+        U256::ZERO
+    } else {
+        let frac_padded = format!("{:0<18}", frac);
+        U256::from(
+            frac_padded[..18]
+                .parse::<u64>()
+                .map_err(|e| DefiError::InvalidParam(format!("Invalid fractional amount: {e}")))?,
+        )
+    };
+    Ok(whole_val * U256::from(10u64).pow(U256::from(18)) + frac_val)
+}
+
+fn parse_address(s: &str) -> Result<Address> {
+    s.parse::<Address>()
+        .map_err(|e| DefiError::InvalidParam(format!("Invalid address '{s}': {e}")))
+}
+
+fn parse_u256(s: &str) -> Result<U256> {
+    U256::from_str_radix(s, 10)
+        .map_err(|e| DefiError::InvalidParam(format!("Invalid U256 '{s}': {e}")))
+}
+
+pub async fn run(
+    args: GaugeArgs,
+    registry: &Registry,
+    _chain: &ChainConfig,
+    executor: &Executor,
+    output: &OutputMode,
+) -> Result<()> {
+    match args.command {
+        GaugeCommand::Deposit {
+            protocol,
+            gauge,
+            amount,
+            ve_nft,
+        } => {
+            let entry = registry.get_protocol(&protocol)?;
+            let gauge_adapter = defi_protocols::factory::create_gauge(entry)?;
+            let gauge_addr = parse_address(&gauge)?;
+            let amount_val = parse_amount_18(&amount)?;
+            let token_id = ve_nft.as_deref().map(parse_u256).transpose()?;
+
+            let tx = gauge_adapter
+                .build_deposit(gauge_addr, amount_val, token_id)
+                .await?;
+            let result = executor.execute(tx).await?;
+            output.print(&result)?;
+        }
+        GaugeCommand::Withdraw {
+            protocol,
+            gauge,
+            amount,
+        } => {
+            let entry = registry.get_protocol(&protocol)?;
+            let gauge_adapter = defi_protocols::factory::create_gauge(entry)?;
+            let gauge_addr = parse_address(&gauge)?;
+            let amount_val = parse_amount_18(&amount)?;
+
+            let tx = gauge_adapter.build_withdraw(gauge_addr, amount_val).await?;
+            let result = executor.execute(tx).await?;
+            output.print(&result)?;
+        }
+        GaugeCommand::Claim { protocol, gauge } => {
+            let entry = registry.get_protocol(&protocol)?;
+            let gauge_adapter = defi_protocols::factory::create_gauge(entry)?;
+            let gauge_addr = parse_address(&gauge)?;
+
+            let tx = gauge_adapter.build_claim_rewards(gauge_addr).await?;
+            let result = executor.execute(tx).await?;
+            output.print(&result)?;
+        }
+        GaugeCommand::Lock {
+            protocol,
+            amount,
+            days,
+        } => {
+            let entry = registry.get_protocol(&protocol)?;
+            let system = defi_protocols::factory::create_gauge(entry)?;
+            let amount_val = parse_amount_18(&amount)?;
+            let lock_duration_secs = days * 86400;
+
+            let tx = system
+                .build_create_lock(amount_val, lock_duration_secs)
+                .await?;
+            let result = executor.execute(tx).await?;
+            output.print(&result)?;
+        }
+        GaugeCommand::Vote {
+            protocol,
+            ve_nft,
+            pools,
+            weights,
+        } => {
+            let entry = registry.get_protocol(&protocol)?;
+            let system = defi_protocols::factory::create_gauge(entry)?;
+            let token_id = parse_u256(&ve_nft)?;
+            let pool_addrs: Result<Vec<Address>> =
+                pools.split(',').map(|s| parse_address(s.trim())).collect();
+            let weight_vals: Result<Vec<U256>> =
+                weights.split(',').map(|s| parse_u256(s.trim())).collect();
+
+            let tx = system
+                .build_vote(token_id, pool_addrs?, weight_vals?)
+                .await?;
+            let result = executor.execute(tx).await?;
+            output.print(&result)?;
+        }
+    }
+    Ok(())
+}

crates/defi-cli/src/commands/mod.rs

@@ -1,6 +1,7 @@
 pub mod bridge;
 pub mod cdp;
 pub mod dex;
+pub mod gauge;
 pub mod lending;
 pub mod schema;
 pub mod staking;
@@ -52,6 +53,8 @@ pub enum Commands {
     Schema(schema::SchemaArgs),
     /// DEX operations: swap, quote, compare
     Dex(dex::DexArgs),
+    /// Gauge operations: deposit, withdraw, claim, lock, vote (ve(3,3))
+    Gauge(gauge::GaugeArgs),
     /// Lending operations: supply, borrow, repay, withdraw, rates, position
     Lending(lending::LendingArgs),
     /// CDP operations: open, adjust, close, info
@@ -82,6 +85,7 @@ pub async fn run(cli: Cli) -> Result<(), DefiError> {
         Commands::Status(args) => status::run(args, &registry, &output_mode).await,
         Commands::Schema(args) => schema::run(args, &output_mode).await,
         Commands::Dex(args) => dex::run(args, &registry, chain, &executor, &output_mode).await,
+        Commands::Gauge(args) => gauge::run(args, &registry, chain, &executor, &output_mode).await,
         Commands::Lending(args) => {
             lending::run(args, &registry, chain, &executor, &output_mode).await
         }

crates/defi-core/src/traits/gauge.rs

@@ -0,0 +1,78 @@
+use alloy::primitives::{Address, U256};
+use async_trait::async_trait;
+
+use crate::error::Result;
+use crate::types::{DeFiTx, RewardInfo};
+
+/// ve(3,3) Gauge operations — stake LP tokens to earn emissions
+#[async_trait]
+pub trait Gauge: Send + Sync {
+    fn name(&self) -> &str;
+
+    /// Deposit LP tokens into gauge
+    async fn build_deposit(
+        &self,
+        gauge: Address,
+        amount: U256,
+        token_id: Option<U256>,
+    ) -> Result<DeFiTx>;
+
+    /// Withdraw LP tokens from gauge
+    async fn build_withdraw(&self, gauge: Address, amount: U256) -> Result<DeFiTx>;
+
+    /// Claim earned rewards from gauge
+    async fn build_claim_rewards(&self, gauge: Address) -> Result<DeFiTx>;
+
+    /// Get pending rewards for a user
+    async fn get_pending_rewards(&self, gauge: Address, user: Address) -> Result<Vec<RewardInfo>>;
+}
+
+/// ve(3,3) Vote-escrow operations — lock tokens for veNFT
+#[async_trait]
+pub trait VoteEscrow: Send + Sync {
+    fn name(&self) -> &str;
+
+    /// Create a new veNFT lock
+    async fn build_create_lock(&self, amount: U256, lock_duration: u64) -> Result<DeFiTx>;
+
+    /// Increase lock amount
+    async fn build_increase_amount(&self, token_id: U256, amount: U256) -> Result<DeFiTx>;
+
+    /// Increase lock duration
+    async fn build_increase_unlock_time(
+        &self,
+        token_id: U256,
+        lock_duration: u64,
+    ) -> Result<DeFiTx>;
+
+    /// Withdraw after lock expires
+    async fn build_withdraw_expired(&self, token_id: U256) -> Result<DeFiTx>;
+}
+
+/// ve(3,3) Voter operations — vote on gauge emissions
+#[async_trait]
+pub trait Voter: Send + Sync {
+    fn name(&self) -> &str;
+
+    /// Vote for gauges with veNFT
+    async fn build_vote(
+        &self,
+        token_id: U256,
+        pools: Vec<Address>,
+        weights: Vec<U256>,
+    ) -> Result<DeFiTx>;
+
+    /// Claim bribes for voted pools
+    async fn build_claim_bribes(&self, bribes: Vec<Address>, token_id: U256) -> Result<DeFiTx>;
+
+    /// Claim trading fees
+    async fn build_claim_fees(&self, fees: Vec<Address>, token_id: U256) -> Result<DeFiTx>;
+}
+
+/// Combined ve(3,3) system — gauge staking + vote-escrow + voter
+///
+/// Implementors of this trait provide the full ve(3,3) stack.
+/// The trait is auto-implemented for any type implementing all three sub-traits.
+pub trait GaugeSystem: Gauge + VoteEscrow + Voter {}
+
+impl<T: Gauge + VoteEscrow + Voter> GaugeSystem for T {}

crates/defi-core/src/traits/mod.rs

@@ -2,6 +2,7 @@ pub mod bridge;
 pub mod cdp;
 pub mod derivatives;
 pub mod dex;
+pub mod gauge;
 pub mod lending;
 pub mod liquid_staking;
 pub mod options;
@@ -13,6 +14,7 @@ pub use bridge::Bridge;
 pub use cdp::Cdp;
 pub use derivatives::Derivatives;
 pub use dex::Dex;
+pub use gauge::{Gauge, GaugeSystem, VoteEscrow, Voter};
 pub use lending::Lending;
 pub use liquid_staking::LiquidStaking;
 pub use options::Options;

crates/defi-core/src/types.rs

@@ -325,6 +325,33 @@ pub struct OptionParams {
     pub amount: U256,
 }
 
+// === ve(3,3) Types ===
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RewardInfo {
+    pub token: Address,
+    pub symbol: String,
+    pub amount: U256,
+    pub value_usd: Option<f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GaugeInfo {
+    pub gauge: Address,
+    pub pool: Address,
+    pub total_staked: U256,
+    pub reward_rate: U256,
+    pub rewards: Vec<RewardInfo>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct VeNftInfo {
+    pub token_id: U256,
+    pub amount: U256,
+    pub unlock_time: u64,
+    pub voting_power: U256,
+}
+
 // === Yield Types ===
 
 #[derive(Debug, Clone, Serialize, Deserialize)]