[WIP] Gauges and bribes

Move.toml

@@ -7,6 +7,7 @@ liquidswap = "0x43417434fd869edee76cca2a4d2301e528a1551b1d719b75c350c3c97d15b8b9
 dao_admin = "0xb4d7b2466d211c1f4629e8340bb1a9e75e7f8fb38cc145c54c5c9f9d5017a318"
 emergency_admin = "0xb4d7b2466d211c1f4629e8340bb1a9e75e7f8fb38cc145c54c5c9f9d5017a318"
 staking_pool = "0x42"
+gov_admin = "0x43"
 
 # Addresses for tests.
 test_coin_admin = "0x11"

sources/gov/bribe.move

@@ -0,0 +1,18 @@
+module liquidswap::bribe {
+    use aptos_framework::coin::Coin;
+
+    use liquidswap::liquid::LAMM;
+    use aptos_framework::coin;
+
+    friend liquidswap::gauge;
+
+    struct Bribe has store {
+        rewards: Coin<LAMM>
+    }
+
+    public(friend) fun zero_bribe(): Bribe {
+        Bribe {
+            rewards: coin::zero()
+        }
+    }
+}

sources/gov/gauge.move

@@ -0,0 +1,71 @@
+module liquidswap::gauge {
+    use aptos_framework::coin::{Self, Coin};
+    use aptos_framework::timestamp;
+    use aptos_std::iterable_table::{Self, IterableTable};
+
+    use liquidswap::bribe::{Self, Bribe};
+    use liquidswap::liquid::LAMM;
+    use liquidswap::ve::{Self, VE_NFT};
+
+    friend liquidswap::voter;
+
+    const WEEK: u64 = 604800;
+
+    struct Gauge has store {
+        bribe: Bribe,
+        rewards: Coin<LAMM>,
+        reward_rate: u64,
+        period_finish: u64,
+        total_voted: u64,
+        voted_per_token: IterableTable<u64, u64>  // table<token_id, vote>
+    }
+
+    public(friend) fun vote(gauge: &mut Gauge, ve_nft: &VE_NFT, vote: u64) {
+        let ve_token_id = ve::get_nft_id(ve_nft);
+        let votes = iterable_table::borrow_mut_with_default(&mut gauge.voted_per_token, ve_token_id, 0);
+        *votes = vote;
+
+        gauge.total_voted = gauge.total_voted + vote;
+    }
+
+    public(friend) fun add_rewards(gauge: &mut Gauge, coin_in: Coin<LAMM>) {
+        let coin_in_value = coin::value(&coin_in);
+        let now = timestamp::now_seconds();
+        if (now >= gauge.period_finish) {
+            gauge.reward_rate = coin_in_value / WEEK;
+        } else {
+            let remaining = gauge.period_finish - now;
+            let left = remaining * gauge.reward_rate;
+            assert!(coin_in_value > left, 2);
+            gauge.reward_rate = (coin_in_value + left) / WEEK;
+        };
+
+        coin::merge(&mut gauge.rewards, coin_in);
+
+        assert!(gauge.reward_rate <= coin::value(&gauge.rewards) / WEEK, 3);
+        gauge.period_finish = now + WEEK;
+    }
+
+    public(friend) fun withdraw_rewards(gauge: &mut Gauge, ve_nft: &VE_NFT): Coin<LAMM> {
+        let ve_token_id = ve::get_nft_id(ve_nft);
+        let token_votes = iterable_table::borrow(&gauge.voted_per_token, ve_token_id);
+
+        let now = timestamp::now_seconds();
+        let time = if (now >= gauge.period_finish) { WEEK } else { now + WEEK - gauge.period_finish };
+        let amount = time * gauge.reward_rate * *token_votes / gauge.total_voted;
+        assert!(amount <= coin::value(&gauge.rewards), 1);
+
+        coin::extract(&mut gauge.rewards, amount)
+    }
+
+    public(friend) fun zero_gauge(): Gauge {
+        Gauge {
+            bribe: bribe::zero_bribe(),
+            rewards: coin::zero(),
+            reward_rate: 0,
+            period_finish: 0,
+            total_voted: 0,
+            voted_per_token: iterable_table::new<u64, u64>()
+        }
+    }
+}

sources/gov/voter.move

@@ -0,0 +1,105 @@
+module liquidswap::voter {
+    use std::option;
+    use std::signer;
+
+    use aptos_framework::coin::Coin;
+    use aptos_std::iterable_table::{Self, IterableTable};
+    use aptos_std::table::{Self, Table};
+    use aptos_std::type_info;
+
+    use liquidswap::gauge::{Self, Gauge};
+    use liquidswap::ve::{Self, VE_NFT};
+    use liquidswap::liquid::LAMM;
+    use liquidswap::liquidity_pool;
+
+    const ERR_WRONG_INITIALIZER: u64 = 100;
+
+    struct PoolId has copy, drop, store {
+        pool_address: address,
+        x_address: address,
+        y_address: address,
+        lp_address: address,
+    }
+
+    struct Voter has key {
+        gauges: Table<PoolId, Gauge>,
+        total_vote: u64,
+    }
+
+    public fun initialize(gov_admin: &signer) {
+        assert!(signer::address_of(gov_admin) == @gov_admin, ERR_WRONG_INITIALIZER);
+        move_to(gov_admin, Voter {
+            gauges: table::new<PoolId, Gauge>(),
+            total_vote: 0,
+        });
+    }
+
+    public fun register<X, Y, LP>(owner: &signer) acquires Voter {
+        let voter = borrow_global_mut<Voter>(@gov_admin);
+        let owner_addr = signer::address_of(owner);
+        let pool_id = get_liquidity_pool_id<X, Y, LP>(owner_addr);
+        table::add(&mut voter.gauges, pool_id, gauge::zero_gauge());
+    }
+
+    public fun vote(ve_nft: &VE_NFT, weights: IterableTable<PoolId, u64>) acquires Voter {
+        let voter = borrow_global_mut<Voter>(@gov_admin);
+
+        let total_weight = 0;
+        let key = iterable_table::head_key(&weights);
+        while (option::is_some(&key)) {
+            let (weight, _, next) =
+                iterable_table::borrow_iter(&weights, *option::borrow(&key));
+            total_weight = total_weight + *weight;
+            key = next;
+        };
+
+        let ve_voting_power = ve::get_nft_voting_power(ve_nft);
+        key = iterable_table::head_key(&weights);
+        while (option::is_some(&key)) {
+            let (weight, _, next) =
+                iterable_table::borrow_iter(&weights, *option::borrow(&key));
+            let pool_id = *option::borrow(&key);
+            let votes = *weight * ve_voting_power / total_weight;
+
+            if(!table::contains(&voter.gauges, pool_id))
+                table::add(&mut voter.gauges, pool_id, gauge::zero_gauge());
+            let gauge = table::borrow_mut(&mut voter.gauges, pool_id);
+            gauge::vote(gauge, ve_nft, votes);
+
+            key = next;
+        };
+        iterable_table::destroy_empty(weights);
+    }
+
+    public fun deposit(pool_id: PoolId, coin_in: Coin<LAMM>) acquires Voter {
+        let voter = borrow_global_mut<Voter>(@gov_admin);
+
+        if(!table::contains(&voter.gauges, pool_id))
+            table::add(&mut voter.gauges, pool_id, gauge::zero_gauge());
+        let gauge = table::borrow_mut(&mut voter.gauges, pool_id);
+        gauge::add_rewards(gauge, coin_in);
+    }
+
+    public fun claim(pool_id: PoolId, ve_nft: &VE_NFT): Coin<LAMM> acquires Voter {
+        let voter = borrow_global_mut<Voter>(@gov_admin);
+
+        assert!(table::contains(&voter.gauges, pool_id), 1);
+        let gauge = table::borrow_mut(&mut voter.gauges, pool_id);
+        gauge::withdraw_rewards(gauge, ve_nft)
+    }
+
+     fun get_liquidity_pool_id<X, Y, LP>(pool_addr: address): PoolId {
+         assert!(liquidity_pool::pool_exists_at<X, Y, LP>(pool_addr), 1);
+         PoolId {
+             pool_address: pool_addr,
+             x_address: coin_address<X>(),
+             y_address: coin_address<Y>(),
+             lp_address: coin_address<LP>(),
+         }
+    }
+
+    fun coin_address<CoinType>(): address {
+        let type_info = type_info::type_of<CoinType>();
+        type_info::account_address(&type_info)
+    }
+}

sources/staking/ve.move

@@ -435,6 +435,14 @@ module liquidswap::ve {
         *table_with_length::borrow(&nft.point_history, epoch)
     }
 
+    /// Get current VE NFT voting power.
+    /// `nft` - reference to `VE_NFT`.
+    public fun get_nft_voting_power(nft: &VE_NFT): u64 acquires StakingPool {
+        let epoch = get_current_epoch();
+        let point = get_nft_history_point(nft, epoch);
+        get_voting_power(&point)
+    }
+
     // Point getters.
 
     /// Get a time when `point` created.

tests/voter_tests.move

@@ -0,0 +1,37 @@
+#[test_only]
+module liquidswap::voter_tests {
+    use std::string::utf8;
+
+    use aptos_framework::genesis;
+
+    use liquidswap::voter;
+    use liquidswap::liquidity_pool;
+
+    use test_coin_admin::test_coins::{Self, BTC, USDT};
+    use test_helpers::test_account::create_account;
+    use test_pool_owner::test_lp::LP;
+
+    #[test(
+        coin_admin = @test_coin_admin,
+        pool_owner = @test_pool_owner,
+        gov_admin = @gov_admin
+    )]
+    fun test_vote_for_liquidity_pool(coin_admin: signer, pool_owner: signer, gov_admin: signer) {
+        genesis::setup();
+
+        create_account(&coin_admin);
+        create_account(&pool_owner);
+        create_account(&gov_admin);
+
+        voter::initialize(&gov_admin);
+
+        test_coins::register_coins(&coin_admin);
+
+        liquidity_pool::register<BTC, USDT, LP>(
+            &pool_owner,
+            utf8(b"LiquidSwap LP"),
+            utf8(b"LP-BTC-USDT"),
+            2
+        );
+    }
+}