feat(multisig-prover): start update worker set

ampd/src/evm/verifier.rs

@@ -37,7 +37,7 @@ impl PartialEq<&WorkerSetConfirmation> for IAxelarGatewayEventsWithLog<'_> {
             IAxelarGatewayEvents::OperatorshipTransferredFilter(event) => {
                 let (operators, weights): (Vec<_>, Vec<_>) = worker_set
                     .operators
-                    .weights
+                    .weights_by_addresses
                     .iter()
                     .map(|(operator, weight)| {
                         (
@@ -243,7 +243,7 @@ mod tests {
             log_index,
             operators: Operators {
                 threshold: Uint256::from(40u64).into(),
-                weights: vec![
+                weights_by_addresses: vec![
                     (EVMAddress::random(), Uint256::from(10u64).into()),
                     (EVMAddress::random(), Uint256::from(20u64).into()),
                     (EVMAddress::random(), Uint256::from(30u64).into()),
@@ -252,7 +252,7 @@ mod tests {
         };
         let (operators, weights): (Vec<_>, Vec<_>) = worker_set
             .operators
-            .weights
+            .weights_by_addresses
             .iter()
             .map(|(operator, weight)| {
                 (

ampd/src/handlers/evm_verify_worker_set.rs

@@ -25,7 +25,7 @@ type Result<T> = error_stack::Result<T, Error>;
 
 #[derive(Deserialize, Debug)]
 pub struct Operators {
-    pub weights: Vec<(EVMAddress, U256)>,
+    pub weights_by_addresses: Vec<(EVMAddress, U256)>,
     pub threshold: U256,
 }
 
@@ -220,7 +220,7 @@ mod tests {
                 log_index: 100,
                 operators: Operators {
                     threshold: 40u64.into(),
-                    weights: vec![
+                    weights_by_addresses: vec![
                         (
                             HexBinary::from(EVMAddress::random().as_bytes()),
                             10u64.into(),

contracts/multisig-prover/src/contract.rs

@@ -41,6 +41,7 @@ pub fn instantiate(
         service_name: msg.service_name,
         chain_name: ChainName::from_str(&msg.chain_name)
             .map_err(|_| ContractError::InvalidChainName)?,
+        worker_set_diff_threshold: msg.worker_set_diff_threshold,
     };
 
     CONFIG.save(deps.storage, &config)?;
@@ -65,6 +66,7 @@ pub fn execute(
 
             execute::rotate_snapshot(deps, env, config, pub_keys, key_id)
         }
+        ExecuteMsg::UpdateWorkerSet {} => execute::update_worker_set(deps, env),
     }
 }
 
@@ -204,6 +206,7 @@ mod test {
             signing_threshold,
             service_name: service_name.to_string(),
             chain_name: "Ethereum".to_string(),
+            worker_set_diff_threshold: 0,
         };
 
         let res = instantiate(deps.as_mut(), env, info, msg);
@@ -285,3 +288,57 @@ mod test {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use multisig::msg::Signer;
+
+    use crate::{contract::execute::should_update_worker_set, test::test_data};
+
+    #[test]
+    fn should_update_worker_set_no_change() {
+        let worker_set = test_data::new_worker_set();
+        assert!(!should_update_worker_set(&worker_set, &worker_set, 0));
+    }
+
+    #[test]
+    fn should_update_worker_set_one_more() {
+        let worker_set = test_data::new_worker_set();
+        let mut new_worker_set = worker_set.clone();
+        new_worker_set.signers.pop_first();
+        assert!(should_update_worker_set(&worker_set, &new_worker_set, 0));
+    }
+
+    #[test]
+    fn should_update_worker_set_one_less() {
+        let worker_set = test_data::new_worker_set();
+        let mut new_worker_set = worker_set.clone();
+        new_worker_set.signers.pop_first();
+        assert!(should_update_worker_set(&new_worker_set, &worker_set, 0));
+    }
+
+    #[test]
+    fn should_update_worker_set_one_more_higher_threshold() {
+        let worker_set = test_data::new_worker_set();
+        let mut new_worker_set = worker_set.clone();
+        new_worker_set.signers.pop_first();
+        assert!(!should_update_worker_set(&worker_set, &new_worker_set, 1));
+    }
+
+    #[test]
+    fn should_update_worker_set_diff_pub_key() {
+        let worker_set = test_data::new_worker_set();
+        let mut new_worker_set = worker_set.clone();
+        let first = new_worker_set.signers.pop_first();
+        let last = new_worker_set.signers.pop_last();
+        new_worker_set.signers.insert(Signer {
+            pub_key: first.clone().unwrap().pub_key,
+            ..last.clone().unwrap()
+        });
+        new_worker_set.signers.insert(Signer {
+            pub_key: last.unwrap().pub_key,
+            ..first.unwrap()
+        });
+        assert!(should_update_worker_set(&worker_set, &new_worker_set, 0));
+    }
+}