refactor(axelar-gateway): use typed events

contracts/axelar-gateway/Cargo.toml

@@ -14,9 +14,11 @@ axelar-soroban-std = { workspace = true }
 cfg-if = { workspace = true }
 ed25519-dalek = { version = "^2.1", default-features = false, optional = true }
 rand = { version = "0.8.5", optional = true }
+rand_chacha = "0.3"
 soroban-sdk = { workspace = true }
 
 [dev-dependencies]
+axelar-gateway = { workspace = true, features = ["testutils"] }
 axelar-soroban-std = { workspace = true, features = ["testutils"] }
 ed25519-dalek = { version = "^2.1" }
 goldie = { workspace = true }

contracts/axelar-gateway/src/auth.rs

@@ -4,7 +4,7 @@ use axelar_soroban_std::ensure;
 use axelar_soroban_std::events::Event;
 use soroban_sdk::{crypto::Hash, Bytes, BytesN, Env, Vec};
 
-use crate::event;
+use crate::event::SignersRotatedEvent;
 use crate::storage_types::DataKey;
 use crate::types::{Proof, WeightedSigners};
 
@@ -105,9 +105,9 @@ pub fn rotate_signers(
         &new_epoch,
     );
 
-    event::SignersRotatedEvent {
-        epoch: new_epoch.clone(),
-        signers_hash: new_signers_hash.clone(),
+    SignersRotatedEvent {
+        epoch: new_epoch,
+        signers_hash: new_signers_hash,
     }
     .emit(env);
 

contracts/axelar-gateway/src/contract.rs

@@ -1,9 +1,10 @@
+use crate::auth;
 use crate::error::ContractError;
+use crate::event::{ContractCalledEvent, MessageApprovedEvent, MessageExecutedEvent};
 use crate::interface::AxelarGatewayInterface;
 use crate::messaging_interface::AxelarGatewayMessagingInterface;
 use crate::storage_types::{DataKey, MessageApprovalKey, MessageApprovalValue};
 use crate::types::{CommandType, Message, Proof, WeightedSigners};
-use crate::{auth, event};
 use axelar_soroban_std::events::Event;
 use axelar_soroban_std::ttl::extend_instance_ttl;
 use axelar_soroban_std::{ensure, interfaces, Operatable, Ownable, Upgradable};
@@ -52,11 +53,11 @@ impl AxelarGatewayMessagingInterface for AxelarGateway {
 
         let payload_hash = env.crypto().keccak256(&payload).into();
 
-        event::ContractCalledEvent {
-            caller: caller.clone(),
-            destination_chain: destination_chain.clone(),
-            destination_address: destination_address.clone(),
-            payload: payload.clone(),
+        ContractCalledEvent {
+            caller,
+            destination_chain,
+            destination_address,
+            payload,
             payload_hash,
         }
         .emit(&env);
@@ -121,17 +122,15 @@ impl AxelarGatewayMessagingInterface for AxelarGateway {
                 &MessageApprovalValue::Executed,
             );
 
-            event::MessageExecutedEvent {
-                message: message.clone(),
-            }
-            .emit(&env);
+            MessageExecutedEvent { message }.emit(&env);
 
             return true;
         }
 
         false
     }
 }
+
 #[contractimpl]
 impl AxelarGatewayInterface for AxelarGateway {
     fn approve_messages(
@@ -165,10 +164,7 @@ impl AxelarGatewayInterface for AxelarGateway {
                 &Self::message_approval_hash(&env, message.clone()),
             );
 
-            event::MessageApprovedEvent {
-                message: message.clone(),
-            }
-            .emit(&env);
+            MessageApprovedEvent { message }.emit(&env);
         }
 
         extend_instance_ttl(&env);

contracts/axelar-gateway/src/event.rs

@@ -42,7 +42,7 @@ impl Event for ContractCalledEvent {
     }
 
     fn data(&self, _env: &Env) -> impl IntoVal<Env, Val> + Debug {
-        (self.payload.clone(),)
+        (self.payload.to_val(),)
     }
 }
 
@@ -80,21 +80,16 @@ impl Event for SignersRotatedEvent {
     }
 }
 
-#[cfg(any(test, feature = "testutils"))]
-use axelar_soroban_std::impl_event_testutils;
-
-#[cfg(any(test, feature = "testutils"))]
-impl_event_testutils!(
-    ContractCalledEvent,
-    (Symbol, Address, String, String, BytesN<32>),
-    (Bytes)
-);
-
-#[cfg(any(test, feature = "testutils"))]
-impl_event_testutils!(MessageApprovedEvent, (Symbol, Message), ());
-
-#[cfg(any(test, feature = "testutils"))]
-impl_event_testutils!(MessageExecutedEvent, (Symbol, Message), ());
-
-#[cfg(any(test, feature = "testutils"))]
-impl_event_testutils!(SignersRotatedEvent, (Symbol, u64, BytesN<32>), ());
+cfg_if::cfg_if! {
+    if #[cfg(any(test, feature = "testutils"))] {
+        use axelar_soroban_std::impl_event_testutils;
+        impl_event_testutils!(
+            ContractCalledEvent,
+            (Symbol, Address, String, String, BytesN<32>),
+            (Bytes)
+        );
+        impl_event_testutils!(MessageApprovedEvent, (Symbol, Message), ());
+        impl_event_testutils!(MessageExecutedEvent, (Symbol, Message), ());
+        impl_event_testutils!(SignersRotatedEvent, (Symbol, u64, BytesN<32>), ());
+    }
+}

contracts/axelar-gateway/src/lib.rs

@@ -6,7 +6,6 @@
 extern crate std;
 
 pub mod error;
-pub mod event;
 pub mod executable;
 mod messaging_interface;
 pub mod types;
@@ -25,6 +24,7 @@ cfg_if::cfg_if! {
         pub use interface::{AxelarGatewayClient, AxelarGatewayInterface};
     } else {
         mod auth;
+        pub mod event;
         mod storage_types;
         mod contract;
 

contracts/axelar-gateway/src/testutils.rs

@@ -59,24 +59,24 @@ pub fn get_approve_hash(env: &Env, messages: Vec<Message>) -> BytesN<32> {
         .into()
 }
 
-pub fn generate_test_message(env: &Env) -> (Message, Bytes) {
-    generate_test_message_with_randomness(env, true)
+pub fn get_deterministic_rng() -> rand_chacha::ChaCha20Rng {
+    use rand::SeedableRng;
+    rand_chacha::ChaCha20Rng::seed_from_u64(42)
 }
 
-pub fn generate_deterministic_test_message(env: &Env) -> (Message, Bytes) {
-    generate_test_message_with_randomness(env, false)
+pub fn generate_test_message(env: &Env) -> (Message, Bytes) {
+    generate_test_message_with_rng(env, rand::thread_rng())
 }
 
-fn generate_test_message_with_randomness(env: &Env, use_rng: bool) -> (Message, Bytes) {
-    let payload = if use_rng {
-        let mut rng = rand::thread_rng();
-        let len = rng.gen_range(0..20);
-        let mut payload = std::vec![0u8; len];
-        rng.fill(&mut payload[..]);
-        Bytes::from_slice(env, &payload[..])
-    } else {
-        Bytes::from_array(env, &[0xde, 0xad, 0xbe, 0xef])
-    };
+pub fn generate_test_message_with_rng(
+    env: &Env,
+    mut rng: impl Rng + rand::CryptoRng,
+) -> (Message, Bytes) {
+    let len = rng.gen_range(0..20);
+    let mut payload = std::vec![0u8; len];
+    rng.fill(&mut payload[..]);
+
+    let payload = Bytes::from_slice(env, &payload[..]);
 
     (
         Message {
@@ -99,41 +99,19 @@ pub fn generate_signers_set(
     num_signers: u32,
     domain_separator: BytesN<32>,
 ) -> TestSignerSet {
-    generate_signers_set_with_randomness(env, num_signers, domain_separator, true)
-}
-
-pub fn generate_deterministic_signers_set(
-    env: &Env,
-    num_signers: u32,
-    domain_separator: BytesN<32>,
-) -> TestSignerSet {
-    generate_signers_set_with_randomness(env, num_signers, domain_separator, false)
+    generate_signers_set_with_rng(env, num_signers, domain_separator, rand::thread_rng())
 }
 
-fn generate_signers_set_with_randomness(
+pub fn generate_signers_set_with_rng(
     env: &Env,
     num_signers: u32,
     domain_separator: BytesN<32>,
-    use_rng: bool,
+    mut rng: impl Rng + rand::CryptoRng,
 ) -> TestSignerSet {
-    let mut rng = rand::thread_rng();
-
     let mut signer_keypair: std::vec::Vec<_> = (0..num_signers)
-        .map(|s| {
-            let signing_key = if use_rng {
-                SigningKey::generate(&mut rng)
-            } else {
-                let mut seed = [0u8; 32];
-                seed[0] = s as u8;
-                SigningKey::from_bytes(&seed)
-            };
-
-            let weight = if use_rng {
-                rng.gen_range(1..10) as u128
-            } else {
-                (s as u128 % 9) + 1
-            };
-
+        .map(|_| {
+            let signing_key = SigningKey::generate(&mut rng);
+            let weight = rng.gen_range(1..10) as u128;
             (signing_key, weight)
         })
         .collect();
@@ -155,11 +133,7 @@ fn generate_signers_set_with_randomness(
         })
         .collect();
 
-    let threshold = if use_rng {
-        rng.gen_range(1..=total_weight)
-    } else {
-        total_weight / 2 + 1
-    };
+    let threshold = rng.gen_range(1..=total_weight);
 
     let signers = WeightedSigners {
         signers: signer_vec.into_vec(env),
@@ -238,35 +212,3 @@ pub fn rotate_signers(env: &Env, contract_id: &Address, new_signers: TestSignerS
         (),
     );
 }
-
-pub fn rotate_to_new_signers<'a>(
-    env: &Env,
-    signers: TestSignerSet,
-    client: &AxelarGatewayClient<'a>,
-    bypass_rotation_delay: bool,
-    num_signers: u32,
-    use_rng: bool,
-) -> TestSignerSet {
-    let (new_signers, proof) = generate_new_signers(env, signers, num_signers, use_rng);
-
-    client.rotate_signers(&new_signers.signers, &proof, &bypass_rotation_delay);
-    new_signers
-}
-
-pub fn generate_new_signers(
-    env: &Env,
-    signers: TestSignerSet,
-    num_signers: u32,
-    use_rng: bool,
-) -> (TestSignerSet, Proof) {
-    let new_signers = if use_rng {
-        generate_signers_set(env, num_signers, signers.domain_separator.clone())
-    } else {
-        generate_deterministic_signers_set(env, num_signers, signers.domain_separator.clone())
-    };
-
-    let data_hash = new_signers.signers.signers_rotation_hash(env);
-    let proof = generate_proof(env, data_hash, signers);
-
-    (new_signers, proof)
-}