add finalized flag (#18)

* add finalized flag

* add update snapshot interface

* add oerator releasetime cond

Author: JSHan94

precompile/binaries/minlib/vip_score.mv

@@ -45,6 +45,8 @@ module initia_std::vip {
     const ESNAPSHOT_ALREADY_EXISTS: u64 = 16;
     const EINVALID_BATCH_ARGUMENT: u64 = 17;
     const EINVALID_TOTAL_REWARD: u64 = 18;
+    const ESNAPSHOT_NOT_EXISTS: u64 = 19;
+    const EALREADY_RELEASED: u64 = 20;
 
     //
     //  Constants
@@ -134,6 +136,11 @@ module initia_std::vip {
         maximum_tvl: u64,
     }
 
+    struct SnapshotResponse has drop {
+        merkle_root: vector<u8>,
+        total_l2_score: u64
+    }
+
     struct StageDataResponse has drop {
         pool_split_ratio: Decimal256, 
         total_operator_funded_reward: u64,
@@ -758,6 +765,28 @@ module initia_std::vip {
         });
     }
 
+    public entry fun update_snapshot(
+        agent: &signer,
+        bridge_id: u64,
+        stage: u64,
+        merkle_root: vector<u8>,
+        total_l2_score: u64,
+    )  acquires ModuleStore {
+        check_agent_permission(agent);
+        let module_store = borrow_global_mut<ModuleStore>(@initia_std);
+        assert!(table::contains(&module_store.stage_data, table_key::encode_u64(stage)), error::not_found(ESTAGE_DATA_NOT_FOUND));
+        let stage_data = table::borrow_mut(&mut module_store.stage_data, table_key::encode_u64(stage));
+
+        let (_, block_time) = block::get_block_info();
+        assert!(block_time < stage_data.user_vesting_release_time, error::unavailable(EALREADY_RELEASED));
+        assert!(block_time < stage_data.operator_vesting_release_time, error::unavailable(EALREADY_RELEASED));
+        assert!(table::contains(&stage_data.snapshots, table_key::encode_u64(bridge_id)), error::not_found(ESNAPSHOT_NOT_EXISTS));
+
+        let snapshot = table::borrow_mut(&mut stage_data.snapshots, table_key::encode_u64(bridge_id));
+        snapshot.merkle_root = merkle_root;
+        snapshot.total_l2_score = total_l2_score;
+    }
+
     public entry fun claim_operator_reward_script(
         operator: &signer,
         bridge_id: u64,
@@ -973,6 +1002,21 @@ module initia_std::vip {
     //
     // View Functions
     //
+
+    #[view]
+    public fun get_snapshot(bridge_id: u64, stage: u64): SnapshotResponse acquires ModuleStore {
+        let module_store = borrow_global<ModuleStore>(@initia_std);
+
+        assert!(table::contains(&module_store.stage_data, table_key::encode_u64(stage)), error::not_found(ESTAGE_DATA_NOT_FOUND));
+        let snapshots = table::borrow(&module_store.stage_data, table_key::encode_u64(stage));
+        assert!(table::contains(&snapshots.snapshots, table_key::encode_u64(bridge_id)), error::not_found(ESNAPSHOT_NOT_EXISTS));
+        let snapshot = table::borrow(&snapshots.snapshots, table_key::encode_u64(bridge_id));
+
+        SnapshotResponse {
+            merkle_root: snapshot.merkle_root,
+            total_l2_score: snapshot.total_l2_score,
+        }
+    }
 
     #[view]
     public fun get_expected_reward(bridge_id: u64, fund_reward_amount: u64): u64 acquires ModuleStore {
@@ -1993,6 +2037,47 @@ module initia_std::vip {
         ), 0);
     }
 
+    #[test(chain=@0x1, operator=@0x111)]
+    fun test_update_snapshot(chain: &signer, operator: &signer) 
+        acquires ModuleStore {
+        let bridge_id = test_setup(
+            chain,
+            operator,
+            1,
+            @0x1111,
+            10000000000000000,
+        );
+        let release_time = 1000;
+        fund_reward_script(chain, 1, release_time, release_time);
+        submit_snapshot(chain, bridge_id, 1, x"8888888888888888888888888888888888888888888888888888888888888888", 0);
+        let snapshot = get_snapshot(bridge_id, 1);
+        assert!(snapshot.merkle_root == x"8888888888888888888888888888888888888888888888888888888888888888", 0);
+        assert!(snapshot.total_l2_score == 0, 0);
+
+        update_snapshot(chain, bridge_id, 1, x"7777777777777777777777777777777777777777777777777777777777777777", 100);
+        let snapshot = get_snapshot(bridge_id, 1);
+        assert!(snapshot.merkle_root == x"7777777777777777777777777777777777777777777777777777777777777777", 100);
+        assert!(snapshot.total_l2_score == 100, 0);
+    }
+
+    #[test(chain=@0x1, operator=@0x111)]
+    #[expected_failure(abort_code = 0xD0014, location = Self)]
+    fun failed_update_snapshot(chain: &signer, operator: &signer) 
+        acquires ModuleStore {
+        let bridge_id = test_setup(
+            chain,
+            operator,
+            1,
+            @0x1111,
+            10000000000000000,
+        );
+        let release_time = 0;
+        fund_reward_script(chain, 1, release_time, release_time);
+        submit_snapshot(chain, bridge_id, 1, x"8888888888888888888888888888888888888888888888888888888888888888", 0);
+        update_snapshot(chain, bridge_id, 1, x"7777777777777777777777777777777777777777777777777777777777777777", 100);
+    }
+
+
     #[test(chain=@0x1, operator=@0x111, operator2=@0x222)]
     fun test_get_next_stage(chain: &signer, operator: &signer, operator2: &signer) 
         acquires ModuleStore, TestCapability {

precompile/binaries/stdlib/vip.mv

@@ -15,6 +15,7 @@ module minitia_std::vip_score {
 
     struct Scores has store {
         total_score: u64,
+        is_finalized: bool,
         score: table::Table<address /* user */, u64>,
     }
 
@@ -43,6 +44,9 @@ module minitia_std::vip_score {
     /// The score is invalid.
     const EINVALID_SCORE: u64 = 7;
 
+    /// The stage is already finalized.
+    const EFINALIED_STAGE: u64 = 8;
+
     //
     // Events
     //
@@ -126,6 +130,7 @@ module minitia_std::vip_score {
         if (!table::contains(&module_store.scores, stage)) {
             table::add(&mut module_store.scores, stage, Scores {
                 total_score: 0,
+                is_finalized: false,
                 score: table::new<address, u64>()
             });
         };
@@ -144,7 +149,10 @@ module minitia_std::vip_score {
         assert!(table::contains(&module_store.scores, stage), error::invalid_argument(EINVALID_STAGE));
 
         let scores = table::borrow_mut(&mut module_store.scores, stage);
+        assert!(!scores.is_finalized, error::invalid_argument(EFINALIED_STAGE));
+        
         let score = table::borrow_mut_with_default(&mut scores.score, addr, 0);
+
         *score = *score + amount;
         scores.total_score = scores.total_score + amount;
 
@@ -171,6 +179,8 @@ module minitia_std::vip_score {
         assert!(table::contains(&module_store.scores, stage), error::invalid_argument(EINVALID_STAGE));
 
         let scores = table::borrow_mut(&mut module_store.scores, stage);
+        assert!(!scores.is_finalized, error::invalid_argument(EFINALIED_STAGE));
+
         let score = table::borrow_mut(&mut scores.score, addr);
         assert!(*score >= amount, error::invalid_argument(EINSUFFICIENT_SCORE));
         *score = *score - amount;
@@ -193,12 +203,14 @@ module minitia_std::vip_score {
         amount: u64
     ) acquires ModuleStore {
         check_deployer_permission(deployer);
-        assert!(amount > 0, error::invalid_argument(EINVALID_SCORE));
+        assert!(amount >= 0, error::invalid_argument(EINVALID_SCORE));
 
         let module_store = borrow_global_mut<ModuleStore>(@minitia_std);
         assert!(table::contains(&module_store.scores, stage), error::invalid_argument(EINVALID_STAGE));
 
         let scores = table::borrow_mut(&mut module_store.scores, stage);
+        assert!(!scores.is_finalized, error::invalid_argument(EFINALIED_STAGE));
+
         let score = table::borrow_mut_with_default(&mut scores.score, addr, 0);
 
         if (*score > amount) {
@@ -222,6 +234,18 @@ module minitia_std::vip_score {
     //
     // Entry functions
     //
+    public entry fun finalize_script(
+        deployer: &signer,
+        stage: u64
+    ) acquires ModuleStore {
+        check_deployer_permission(deployer);
+        let module_store = borrow_global_mut<ModuleStore>(@minitia_std);
+        assert!(table::contains(&module_store.scores, stage), error::invalid_argument(EINVALID_STAGE));
+
+        let scores = table::borrow_mut(&mut module_store.scores, stage);
+        assert!(!scores.is_finalized, error::invalid_argument(EFINALIED_STAGE));
+        scores.is_finalized = true;
+    }
 
     public entry fun update_score_script(
         deployer: &signer,
@@ -339,6 +363,34 @@ module minitia_std::vip_score {
         init_module_for_test(chain);
         remove_deployer_script(chain, signer::address_of(deployer));
     }
+    
+    #[test(chain = @0x1, deployer = @0x2)]
+    #[expected_failure(abort_code = 0x10006, location = Self)]
+    fun failed_not_match_length(chain: &signer, deployer: &signer) acquires ModuleStore {
+        init_module_for_test(chain);
+        add_deployer_script(chain, signer::address_of(deployer));
+
+        update_score_script(
+            deployer, 
+            1,
+            vector[@0x123, @0x234],
+            vector[]
+        );
+    }
+
+    #[test(chain = @0x1, deployer = @0x2, user = @0x123)]
+    #[expected_failure(abort_code = 0x10008, location = Self)]
+    fun failed_finalized_stage(chain: &signer, deployer: &signer, user: address) acquires ModuleStore {
+        init_module_for_test(chain);
+        add_deployer_script(chain, signer::address_of(deployer));
+        prepare_stage(deployer, 1);
+
+        increase_score(deployer, user, 1, 100);
+        assert!(get_score(user, 1) == 100, 1);
+        finalize_script(deployer, 1);
+        increase_score(deployer, user, 1, 100);
+    }
+
 
     #[test(chain = @0x1, deployer_a = @0x2, deployer_b = @0x3, user_a = @0x123, user_b = @0x456)]
     fun test_e2e(chain: &signer, deployer_a: &signer, deployer_b: &signer, user_a: address, user_b: address) acquires ModuleStore {