Use anvil on tests (#129)

Changed tests to use anvil from a docker container instead of depending on anvil running externally. This will allow to run tests more easily, removing foundry as a dependency. Also fix some flaky tests that fail due to multiple tests running in parallel and making requests to the same anvil instance. --------- Co-authored-by: Pablo Deymonnaz <[email protected]>
Layr-Labs · Sep 24, 2024 · 3c0416e · 3c0416e
1 parent b394482
commit 3c0416e
Show file tree

Hide file tree

Showing 22 changed files with 595 additions and 425 deletions.
diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
@@ -81,9 +81,6 @@ jobs:
         with:
           cache-on-failure: true
 
-      - name: Install Foundry
-        run: cargo install --git https://github.com/foundry-rs/foundry --profile release --locked foundry-cast anvil
-
       - name: docker
         uses: docker-practice/actions-setup-docker@master
 

diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Makefile b/Makefile
@@ -14,18 +14,9 @@ reset-anvil:
 	-docker stop anvil
 	-docker rm anvil
 
-pr:
-	$(MAKE) start-anvil > /dev/null &
-	sleep 4 # needed to wait for anvil setup to finish
-	cargo test --workspace
-	docker stop anvil
-
 coverage:
-	$(MAKE) start-anvil > /dev/null &
-	sleep 4 # needed to wait for anvil setup to finish
 	cargo llvm-cov --lcov --output-path lcov.info --workspace --features fireblock-tests
 	cargo llvm-cov report --html
-	docker stop anvil
 
 deps:
 	@if ! command -v cargo-llvm-cov &> /dev/null; then \

diff --git a/crates/chainio/clients/avsregistry/src/writer.rs b/crates/chainio/clients/avsregistry/src/writer.rs
@@ -330,22 +330,28 @@ impl AvsRegistryChainWriter {
 #[cfg(test)]
 mod tests {
     use super::AvsRegistryChainWriter;
-    use alloy_node_bindings::Anvil;
     use alloy_primitives::{Address, Bytes, FixedBytes, U256};
     use eigen_crypto_bls::BlsKeyPair;
     use eigen_logging::get_test_logger;
+    use eigen_testing_utils::anvil::start_anvil_container;
     use eigen_testing_utils::anvil_constants::{
-        get_operator_state_retriever_address, get_registry_coordinator_address, ANVIL_HTTP_URL,
+        get_operator_state_retriever_address, get_registry_coordinator_address,
     };
     use eigen_testing_utils::transaction::get_transaction_status;
+    use std::str::FromStr;
 
-    async fn build_avs_registry_chain_writer(private_key: String) -> AvsRegistryChainWriter {
-        let registry_coordinator_address = get_registry_coordinator_address().await;
-        let operator_state_retriever_address = get_operator_state_retriever_address().await;
+    async fn build_avs_registry_chain_writer(
+        http_endpoint: String,
+        private_key: String,
+    ) -> AvsRegistryChainWriter {
+        let registry_coordinator_address =
+            get_registry_coordinator_address(http_endpoint.clone()).await;
+        let operator_state_retriever_address =
+            get_operator_state_retriever_address(http_endpoint.clone()).await;
 
         AvsRegistryChainWriter::build_avs_registry_chain_writer(
             get_test_logger(),
-            ANVIL_HTTP_URL.to_string(),
+            http_endpoint,
             private_key,
             registry_coordinator_address,
             operator_state_retriever_address,
@@ -356,33 +362,48 @@ mod tests {
 
     #[tokio::test]
     async fn test_avs_writer_methods() {
-        let account_idx = 5;
-        let anvil = Anvil::new().try_spawn().unwrap();
-        let private_key = anvil.keys().get(account_idx).unwrap();
-        let private_key_hex = hex::encode(private_key.to_bytes());
-        let private_key_decimal = U256::from_be_bytes(private_key.to_bytes().into()).to_string();
-        let avs_writer = build_avs_registry_chain_writer(private_key_hex).await;
-        let operator_id = anvil.addresses().get(account_idx).unwrap();
-
+        let (_container, http_endpoint, _ws_endpoint) = start_anvil_container().await;
+
+        let bls_key =
+            "1371012690269088913462269866874713266643928125698382731338806296762673180359922"
+                .to_string();
+        let private_key =
+            "8b3a350cf5c34c9194ca85829a2df0ec3153be0318b5e2d3348e872092edffba".to_string();
+        let avs_writer = build_avs_registry_chain_writer(http_endpoint.clone(), private_key).await;
+        let operator_addr = Address::from_str("9965507D1a55bcC2695C58ba16FB37d819B0A4dc").unwrap();
         let quorum_nums = Bytes::from([0]);
-        test_register_operator(&avs_writer, private_key_decimal, quorum_nums.clone()).await;
-        test_update_stake_of_operator_subset(&avs_writer, *operator_id).await;
-        test_update_stake_of_entire_operator_set(&avs_writer, *operator_id, quorum_nums.clone())
+
+        test_register_operator(
+            &avs_writer,
+            bls_key,
+            quorum_nums.clone(),
+            http_endpoint.clone(),
+        )
+        .await;
+        test_update_stake_of_operator_subset(&avs_writer, operator_addr, http_endpoint.clone())
             .await;
-        test_deregister_operator(&avs_writer, quorum_nums).await;
+        test_update_stake_of_entire_operator_set(
+            &avs_writer,
+            operator_addr,
+            quorum_nums.clone(),
+            http_endpoint.clone(),
+        )
+        .await;
+        test_deregister_operator(&avs_writer, quorum_nums, http_endpoint).await;
     }
 
     // this function is caller from test_avs_writer_methods
     async fn test_update_stake_of_operator_subset(
         avs_writer: &AvsRegistryChainWriter,
-        operator_id: Address,
+        operator_addr: Address,
+        http_url: String,
     ) {
         let tx_hash = avs_writer
-            .update_stakes_of_operator_subset_for_all_quorums(vec![operator_id])
+            .update_stakes_of_operator_subset_for_all_quorums(vec![operator_addr])
             .await
             .unwrap();
 
-        let tx_status = get_transaction_status(tx_hash).await;
+        let tx_status = get_transaction_status(http_url, tx_hash).await;
         assert!(tx_status);
     }
 
@@ -391,13 +412,14 @@ mod tests {
         avs_writer: &AvsRegistryChainWriter,
         operator_id: Address,
         quorum_nums: Bytes,
+        http_url: String,
     ) {
         let tx_hash = avs_writer
             .update_stakes_of_entire_operator_set_for_quorums(vec![vec![operator_id]], quorum_nums)
             .await
             .unwrap();
 
-        let tx_status = get_transaction_status(tx_hash).await;
+        let tx_status = get_transaction_status(http_url, tx_hash).await;
         assert!(tx_status);
     }
 
@@ -406,6 +428,7 @@ mod tests {
         avs_writer: &AvsRegistryChainWriter,
         private_key_decimal: String,
         quorum_nums: Bytes,
+        http_url: String,
     ) {
         let bls_key_pair = BlsKeyPair::new(private_key_decimal).unwrap();
         let digest_hash: FixedBytes<32> = FixedBytes::from([0x02; 32]);
@@ -423,15 +446,19 @@ mod tests {
             .await
             .unwrap();
 
-        let tx_status = get_transaction_status(tx_hash).await;
+        let tx_status = get_transaction_status(http_url, tx_hash).await;
         assert!(tx_status);
     }
 
     // this function is caller from test_avs_writer_methods
-    async fn test_deregister_operator(avs_writer: &AvsRegistryChainWriter, quorum_nums: Bytes) {
+    async fn test_deregister_operator(
+        avs_writer: &AvsRegistryChainWriter,
+        quorum_nums: Bytes,
+        http_url: String,
+    ) {
         let tx_hash = avs_writer.deregister_operator(quorum_nums).await.unwrap();
 
-        let tx_status = get_transaction_status(tx_hash).await;
+        let tx_status = get_transaction_status(http_url, tx_hash).await;
         assert!(tx_status);
     }
 }
diff --git a/crates/chainio/clients/elcontracts/src/reader.rs b/crates/chainio/clients/elcontracts/src/reader.rs
@@ -391,35 +391,33 @@ mod tests {
     use alloy_primitives::{address, keccak256, Address, FixedBytes, U256};
     use alloy_provider::Provider;
     use eigen_logging::get_test_logger;
-    use eigen_testing_utils::anvil_constants::{
-        self, get_erc20_mock_strategy, ANVIL_HTTP_URL, ANVIL_RPC_URL,
+    use eigen_testing_utils::{
+        anvil::start_anvil_container,
+        anvil_constants::{
+            get_delegation_manager_address, get_erc20_mock_strategy, get_service_manager_address,
+        },
     };
     use eigen_utils::binding::{
         mockAvsServiceManager, AVSDirectory,
         AVSDirectory::calculateOperatorAVSRegistrationDigestHashReturn, DelegationManager,
         DelegationManager::calculateDelegationApprovalDigestHashReturn,
     };
-    use serial_test::serial;
     use std::str::FromStr;
-    use tokio::time::{sleep, Duration};
 
     const OPERATOR_ADDRESS: &str = "0xa0Ee7A142d267C1f36714E4a8F75612F20a79720";
 
-    async fn build_el_chain_reader() -> ELChainReader {
-        let delegation_manager_address = anvil_constants::get_delegation_manager_address().await;
-        let delegation_manager_contract = DelegationManager::new(
-            delegation_manager_address,
-            anvil_constants::ANVIL_RPC_URL.clone(),
-        );
+    async fn build_el_chain_reader(http_endpoint: String) -> ELChainReader {
+        let delegation_manager_address =
+            get_delegation_manager_address(http_endpoint.clone()).await;
+        let delegation_manager_contract =
+            DelegationManager::new(delegation_manager_address, get_provider(&http_endpoint));
         let slasher_address_return = delegation_manager_contract.slasher().call().await.unwrap();
         let DelegationManager::slasherReturn {
             _0: slasher_address,
         } = slasher_address_return;
-        let service_manager_address = anvil_constants::get_service_manager_address().await;
-        let service_manager_contract = mockAvsServiceManager::new(
-            service_manager_address,
-            get_provider("http://localhost:8545"),
-        );
+        let service_manager_address = get_service_manager_address(http_endpoint.clone()).await;
+        let service_manager_contract =
+            mockAvsServiceManager::new(service_manager_address, get_provider(&http_endpoint));
         let avs_directory_address_return = service_manager_contract
             .avsDirectory()
             .call()
@@ -434,24 +432,24 @@ mod tests {
             slasher_address,
             delegation_manager_address,
             avs_directory_address,
-            ANVIL_HTTP_URL.to_string(),
+            http_endpoint,
         )
     }
 
     #[tokio::test]
-    #[serial]
     async fn test_calculate_delegation_approval_digest_hash() {
-        let el_chain_reader = build_el_chain_reader().await;
+        let (_container, http_endpoint, _ws_endpoint) = start_anvil_container().await;
+        let provider = get_provider(&http_endpoint);
+        let el_chain_reader = build_el_chain_reader(http_endpoint.clone()).await;
         let operator: Address = address!("5eb15C0992734B5e77c888D713b4FC67b3D679A2");
 
         let staker = operator;
 
         let delegation_approver = Address::ZERO;
 
         let approve_salt: FixedBytes<32> = FixedBytes::from([0x02; 32]);
-        let current_block_number = ANVIL_RPC_URL.clone().get_block_number().await.unwrap();
-        let block_info = ANVIL_RPC_URL
-            .clone()
+        let current_block_number = provider.get_block_number().await.unwrap();
+        let block_info = provider
             .get_block_by_number(Number(current_block_number), true)
             .await
             .unwrap();
@@ -471,11 +469,9 @@ mod tests {
             .unwrap();
 
         // Directly calling the function through bindings to compare with the sdk .
-        let delegation_manager_address = anvil_constants::get_delegation_manager_address().await;
-        let delegation_manager_contract = DelegationManager::new(
-            delegation_manager_address,
-            anvil_constants::ANVIL_RPC_URL.clone(),
-        );
+        let delegation_manager_address = get_delegation_manager_address(http_endpoint).await;
+        let delegation_manager_contract =
+            DelegationManager::new(delegation_manager_address, provider);
 
         let hash = delegation_manager_contract
             .calculateDelegationApprovalDigestHash(
@@ -495,16 +491,15 @@ mod tests {
     }
 
     #[tokio::test]
-    #[serial]
     async fn test_calculate_operator_avs_registration_digest_hash() {
-        sleep(Duration::from_secs(2)).await;
-        let el_chain_reader = build_el_chain_reader().await;
+        let (_container, http_endpoint, _ws_endpoint) = start_anvil_container().await;
+        let provider = get_provider(&http_endpoint);
+        let el_chain_reader = build_el_chain_reader(http_endpoint.clone()).await;
         let operator: Address = address!("5eb15C0992734B5e77c888D713b4FC67b3D679A2");
         let avs = Address::from_slice(&keccak256("avs ")[0..20]);
         let salt: FixedBytes<32> = FixedBytes::from([0x02; 32]);
-        let current_block_number = ANVIL_RPC_URL.clone().get_block_number().await.unwrap();
-        let block_info = ANVIL_RPC_URL
-            .clone()
+        let current_block_number = provider.get_block_number().await.unwrap();
+        let block_info = provider
             .get_block_by_number(Number(current_block_number), true)
             .await
             .unwrap();
@@ -519,7 +514,7 @@ mod tests {
 
         // Using bindings directly to compare with sdk's output
         let avs_registry_contract =
-            AVSDirectory::new(el_chain_reader.avs_directory, ANVIL_RPC_URL.clone());
+            AVSDirectory::new(el_chain_reader.avs_directory, provider.clone());
         let operator_hash_from_bindings = avs_registry_contract
             .calculateOperatorAVSRegistrationDigestHash(operator, avs, salt, expiry)
             .call()
@@ -533,12 +528,12 @@ mod tests {
     }
 
     #[tokio::test]
-    #[serial]
     async fn check_strategy_shares_and_operator_frozen() {
+        let (_container, http_endpoint, _ws_endpoint) = start_anvil_container().await;
         let operator_addr = Address::from_str(OPERATOR_ADDRESS).unwrap();
-        let strategy_addr = get_erc20_mock_strategy().await;
+        let strategy_addr = get_erc20_mock_strategy(http_endpoint.clone()).await;
 
-        let chain_reader = build_el_chain_reader().await;
+        let chain_reader = build_el_chain_reader(http_endpoint.clone()).await;
         let shares = chain_reader
             .get_operator_shares_in_strategy(operator_addr, strategy_addr)
             .await
@@ -554,7 +549,7 @@ mod tests {
             .unwrap();
         assert!(!frozen);
 
-        let service_manager_address = anvil_constants::get_service_manager_address().await;
+        let service_manager_address = get_service_manager_address(http_endpoint).await;
         let ret_can_slash = chain_reader
             .service_manager_can_slash_operator_until_block(operator_addr, service_manager_address)
             .await
@@ -565,10 +560,10 @@ mod tests {
     }
 
     #[tokio::test]
-    #[serial]
     async fn test_get_operator_details() {
+        let (_container, http_endpoint, _ws_endpoint) = start_anvil_container().await;
         let operator_addr = Address::from_str(OPERATOR_ADDRESS).unwrap();
-        let chain_reader = build_el_chain_reader().await;
+        let chain_reader = build_el_chain_reader(http_endpoint).await;
 
         let operator = chain_reader
             .get_operator_details(operator_addr)