fix relayer fixture after merge

Author: Foivos

crates/relayer-discovery-test-fixtures/src/lib.rs

@@ -5,17 +5,16 @@
 use anchor_lang::prelude::thiserror;
 use anchor_lang::{AnchorDeserialize, Key};
 
-use solana_axelar_std::MerkleTree;
-use solana_axelar_std::{hasher::LeafHash, Message, MessageLeaf, VerifierSetLeaf};
+use solana_axelar_std::{Message, Messages, Payload, PayloadType};
 
 use libsecp256k1::SecretKey;
 use mollusk_svm::result::InstructionResult;
 use mollusk_svm::result::ProgramResult;
 use relayer_discovery::structs::RelayerTransaction;
 use relayer_discovery::{find_transaction_pda, ConvertError, RelayerDiscovery};
 use solana_axelar_gateway_test_fixtures::{
-    approve_message_helper, create_verifier_info, initialize_gateway,
-    initialize_payload_verification_session_with_root, setup_test_with_real_signers,
+    approve_message_helper, create_merklized_messages_from_std, create_signing_verifier_set_leaves,
+    initialize_gateway, initialize_payload_verification_session, setup_test_with_real_signers,
     verify_signature_helper, TestSetup,
 };
 use solana_sdk::pubkey::ParsePubkeyError;
@@ -30,8 +29,6 @@ pub struct RelayerDiscoveryTestFixture {
     /// This has the mollusk aslongside a lot of information about the gateway
     pub setup: TestSetup,
     /// The rest of the information is required to approve massages to the gateway
-    pub verifier_leaves: Vec<VerifierSetLeaf>,
-    pub verifier_merkle_tree: MerkleTree,
     pub secret_key_1: SecretKey,
     pub secret_key_2: SecretKey,
     pub init_result: InstructionResult,
@@ -78,16 +75,13 @@ impl RelayerDiscoveryTestFixture {
     ///
     /// Returns the `RelayerDiscoveryTestFixture` generated.
     pub fn new() -> RelayerDiscoveryTestFixture {
-        let (setup, verifier_leaves, verifier_merkle_tree, secret_key_1, secret_key_2) =
-            setup_test_with_real_signers();
+        let (setup, secret_key_1, secret_key_2) = setup_test_with_real_signers();
 
         // Step 2: Initialize gateway
         let init_result = initialize_gateway(&setup);
 
         RelayerDiscoveryTestFixture {
             setup,
-            verifier_leaves,
-            verifier_merkle_tree,
             secret_key_1,
             secret_key_2,
             init_result,
@@ -106,30 +100,9 @@ impl RelayerDiscoveryTestFixture {
     pub fn approve(&mut self, message: &Message) -> InstructionResult {
         let messages = vec![message.clone()];
 
-        let message_leaves: Vec<MessageLeaf> = messages
-            .iter()
-            .enumerate()
-            .map(|(i, msg)| MessageLeaf {
-                message: msg.clone(),
-                position: u16::try_from(i).unwrap(),
-                set_size: u16::try_from(messages.len()).unwrap(),
-                domain_separator: self.setup.domain_separator,
-            })
-            .collect();
-
-        let message_leaf_hashes: Vec<[u8; 32]> =
-            message_leaves.iter().map(MessageLeaf::hash).collect();
-
-        let message_merkle_tree = MerkleTree::from_leaves(&message_leaf_hashes);
-        let payload_merkle_root = message_merkle_tree.root().unwrap();
-
-        // Step 4: Initialize payload verification session
-        let (session_result, verification_session_pda) =
-            initialize_payload_verification_session_with_root(
-                &self.setup,
-                &self.init_result,
-                payload_merkle_root,
-            );
+        // Create payload merkle root using std crate approach
+        let (_, payload_merkle_root) =
+            create_merklized_messages_from_std(self.setup.domain_separator, &messages);
 
         let gateway_root_account = self
             .init_result
@@ -139,64 +112,84 @@ impl RelayerDiscoveryTestFixture {
         let verifier_set_tracker_account = self
             .init_result
             .get_account(&self.setup.verifier_set_tracker_pda)
-            .unwrap();
+            .unwrap()
+            .clone();
 
+        let (session_result, verification_session_pda) = initialize_payload_verification_session(
+            &self.setup,
+            gateway_root_account.clone(),
+            verifier_set_tracker_account.clone(),
+            payload_merkle_root,
+            PayloadType::ApproveMessages,
+        );
         let verification_session_account = session_result
             .get_account(&verification_session_pda)
             .unwrap();
 
         // Step 5: Sign the payload with both signers, verify both signatures on the gateway
-        let verifier_info_1 = create_verifier_info(
+        let payload_to_be_signed = Payload::Messages(Messages(messages.clone()));
+        let signing_verifier_set_leaves = create_signing_verifier_set_leaves(
+            self.setup.domain_separator,
             &self.secret_key_1,
-            payload_merkle_root,
-            &self.verifier_leaves[0],
-            0, // Position 0
-            &self.verifier_merkle_tree,
+            &self.secret_key_2,
+            payload_to_be_signed,
+            self.setup.verifier_set.clone(),
         );
 
+        let verifier_info_1 = signing_verifier_set_leaves[0].clone();
+
         let verify_result_1 = verify_signature_helper(
             &self.setup,
             payload_merkle_root,
             verifier_info_1,
-            verification_session_pda,
+            (
+                verification_session_pda,
+                verification_session_account.clone(),
+            ),
             gateway_root_account.clone(),
-            verification_session_account.clone(),
-            self.setup.verifier_set_tracker_pda,
-            verifier_set_tracker_account.clone(),
+            (
+                self.setup.verifier_set_tracker_pda,
+                verifier_set_tracker_account.clone(),
+            ),
         );
 
         let updated_verification_account_after_first = verify_result_1
             .get_account(&verification_session_pda)
-            .unwrap();
+            .unwrap()
+            .clone();
 
-        let verifier_info_2 = create_verifier_info(
-            &self.secret_key_2,
-            payload_merkle_root,
-            &self.verifier_leaves[1],
-            1, // Position 1
-            &self.verifier_merkle_tree,
-        );
+        let verifier_info_2 = signing_verifier_set_leaves[1].clone();
 
         let verify_result_2 = verify_signature_helper(
             &self.setup,
             payload_merkle_root,
             verifier_info_2,
-            verification_session_pda,
+            (
+                verification_session_pda,
+                updated_verification_account_after_first.clone(),
+            ),
             gateway_root_account.clone(),
-            updated_verification_account_after_first.clone(),
-            self.setup.verifier_set_tracker_pda,
-            verifier_set_tracker_account.clone(),
+            (
+                self.setup.verifier_set_tracker_pda,
+                verifier_set_tracker_account.clone(),
+            ),
         );
 
         // Step 6: Approve the message
+        let final_gateway_account = verify_result_2
+            .get_account(&self.setup.gateway_root_pda)
+            .unwrap()
+            .clone();
+        let final_verification_session_account = verify_result_2
+            .get_account(&verification_session_pda)
+            .unwrap()
+            .clone();
+
         let (approve_result, _) = approve_message_helper(
             &self.setup,
-            message_merkle_tree,
-            message_leaves,
             &messages,
-            payload_merkle_root,
-            verification_session_pda,
-            verify_result_2,
+            (verification_session_pda, final_verification_session_account),
+            final_gateway_account,
             0, // position
         );