Extracted common functionality for example tests

alexandrosfilios · alexandrosfilios · commit 5fb82160ad07 · 2025-10-24T15:32:44.000+02:00
diff --git a/examples/abi_decode/tests/abi_decode_integration_test.rs b/examples/abi_decode/tests/abi_decode_integration_test.rs
@@ -8,7 +8,7 @@ mod integration_test {
         sol,
     };
     use eyre::Result;
-    use stylus_tools::devnet::Node;
+    use stylus_tools::utils::testing::ExampleContractTester;
 
     sol! {
         #[sol(rpc)]
@@ -18,53 +18,20 @@ mod integration_test {
         }
     }
 
-    const EXPECTED_ABI: &str = "\
+    struct AbiDecodeIntegrationTester {}
+
+    impl ExampleContractTester for AbiDecodeIntegrationTester {
+        const EXPECTED_ABI: &'static str = "\
 interface IDecoder {
     function encodeAndDecode(address _address, uint256 amount) external view returns (bool);
 
     error DecodedFailed();
 }";
-    const EXPECTED_CONSTRUCTOR: &str = "";
+    }
 
     #[tokio::test]
     async fn abi_decode() -> Result<()> {
-        let exporter = stylus_tools::Exporter::builder().build();
-        assert_eq!(exporter.export_abi()?, EXPECTED_ABI);
-        assert_eq!(exporter.export_constructor()?, EXPECTED_CONSTRUCTOR);
-
-        let devnode = Node::new().await?;
-        let rpc = devnode.rpc();
-
-        println!("Checking contract on Nitro ({rpc})...");
-        stylus_tools::Checker::builder().rpc(rpc).build().check()?;
-        println!("Checked contract");
-
-        let deployer = stylus_tools::Deployer::builder().rpc(rpc).build();
-        println!("Estimating gas...");
-        let gas_estimate = deployer.estimate_gas()?;
-        println!("Estimated deployment gas: {gas_estimate} ETH");
-
-        println!("Deploying contract to Nitro ({rpc})...");
-        let (address, tx_hash, gas_used) = deployer.deploy()?;
-        println!("Deployed contract to {address}");
-
-        // Approximate equality is usually expected, but given the test conditions, the gas estimate equals the gas used
-        assert_eq!(gas_used, gas_estimate);
-
-        println!("Activating contract at {address} on Nitro ({rpc})...");
-        stylus_tools::Activator::builder()
-            .rpc(rpc)
-            .contract_address(address.to_string())
-            .build()
-            .activate()?;
-        println!("Activated contract at {address}");
-
-        let verify = stylus_tools::Verifier::builder()
-            .rpc(rpc)
-            .deployment_tx_hash(tx_hash.to_string())
-            .build()
-            .verify();
-        assert!(verify.is_ok(), "Failed to verify contract");
+        let (devnode, address) = AbiDecodeIntegrationTester::init().await?;
         let provider = devnode.create_provider().await?;
 
         // Instantiate contract
diff --git a/examples/abi_encode/tests/abi_encode_integration_test.rs b/examples/abi_encode/tests/abi_encode_integration_test.rs
@@ -8,7 +8,7 @@ mod integration_test {
         sol,
     };
     use eyre::Result;
-    use stylus_tools::devnet::Node;
+    use stylus_tools::utils::testing::ExampleContractTester;
 
     sol! {
         #[sol(rpc)]
@@ -20,7 +20,9 @@ mod integration_test {
         }
     }
 
-    const EXPECTED_ABI: &str = "\
+    struct AbiEncodeIntegrationTester {}
+    impl ExampleContractTester for AbiEncodeIntegrationTester {
+        const EXPECTED_ABI: &'static str = "\
 interface IEncoder {
     function encode(address target, uint256 value, string calldata func, bytes calldata data, uint256 timestamp) external view returns (uint8[] memory);
 
@@ -30,48 +32,11 @@ interface IEncoder {
 
     function encodeWithSignature(string calldata func, address _address, uint256 amount) external view returns (uint8[] memory);
 }";
-
-    const EXPECTED_CONSTRUCTOR: &str = "";
+    }
 
     #[tokio::test]
     async fn abi_encode() -> Result<()> {
-        let exporter = stylus_tools::Exporter::builder().build();
-        assert_eq!(exporter.export_abi()?, EXPECTED_ABI);
-        assert_eq!(exporter.export_constructor()?, EXPECTED_CONSTRUCTOR);
-
-        let devnode = Node::new().await?;
-        let rpc = devnode.rpc();
-
-        println!("Checking contract on Nitro ({rpc})...");
-        stylus_tools::Checker::builder().rpc(rpc).build().check()?;
-        println!("Checked contract");
-
-        let deployer = stylus_tools::Deployer::builder().rpc(rpc).build();
-        println!("Estimating gas...");
-        let gas_estimate = deployer.estimate_gas()?;
-        println!("Estimated deployment gas: {gas_estimate} ETH");
-
-        println!("Deploying contract to Nitro ({rpc})...");
-        let (address, tx_hash, gas_used) = deployer.deploy()?;
-        println!("Deployed contract to {address}");
-
-        // Approximate equality is usually expected, but given the test conditions, the gas estimate equals the gas used
-        assert_eq!(gas_used, gas_estimate);
-
-        println!("Activating contract at {address} on Nitro ({rpc})...");
-        stylus_tools::Activator::builder()
-            .rpc(rpc)
-            .contract_address(address.to_string())
-            .build()
-            .activate()?;
-        println!("Activated contract at {address}");
-
-        let verify = stylus_tools::Verifier::builder()
-            .rpc(rpc)
-            .deployment_tx_hash(tx_hash.to_string())
-            .build()
-            .verify();
-        assert!(verify.is_ok(), "Failed to verify contract");
+        let (devnode, address) = AbiEncodeIntegrationTester::init().await?;
         let provider = devnode.create_provider().await?;
 
         // Instantiate contract
diff --git a/examples/arrays/tests/arrays_integration_test.rs b/examples/arrays/tests/arrays_integration_test.rs
@@ -5,7 +5,8 @@
 mod integration_test {
     use alloy::{primitives::U256, sol};
     use eyre::Result;
-    use stylus_tools::devnet::{addresses::OWNER, Node};
+    use stylus_tools::devnet::addresses::OWNER;
+    use stylus_tools::utils::testing::ExampleContractTester;
 
     sol! {
         #[sol(rpc)]
@@ -24,7 +25,10 @@ mod integration_test {
         }
     }
 
-    const EXPECTED_ABI: &str = "\
+    struct ArraysIntegrationTester {}
+
+    impl ExampleContractTester for ArraysIntegrationTester {
+        const EXPECTED_ABI: &'static str = "\
 interface IArrays {
     function push(uint256 i) external;
 
@@ -48,47 +52,11 @@ interface IArrays {
 
     function findArr3FirstExpectedValue(uint256 expected_value) external view returns (uint256);
 }";
-    const EXPECTED_CONSTRUCTOR: &str = "";
+    }
 
     #[tokio::test]
     async fn arrays() -> Result<()> {
-        let exporter = stylus_tools::Exporter::builder().build();
-        assert_eq!(exporter.export_abi()?, EXPECTED_ABI);
-        assert_eq!(exporter.export_constructor()?, EXPECTED_CONSTRUCTOR);
-
-        let devnode = Node::new().await?;
-        let rpc = devnode.rpc();
-
-        println!("Checking contract on Nitro ({rpc})...");
-        stylus_tools::Checker::builder().rpc(rpc).build().check()?;
-        println!("Checked contract");
-
-        let deployer = stylus_tools::Deployer::builder().rpc(rpc).build();
-        println!("Estimating gas...");
-        let gas_estimate = deployer.estimate_gas()?;
-        println!("Estimated deployment gas: {gas_estimate} ETH");
-
-        println!("Deploying contract to Nitro ({rpc})...");
-        let (address, tx_hash, gas_used) = deployer.deploy()?;
-        println!("Deployed contract to {address}");
-
-        // Approximate equality is usually expected, but given the test conditions, the gas estimate equals the gas used
-        assert_eq!(gas_used, gas_estimate);
-
-        println!("Activating contract at {address} on Nitro ({rpc})...");
-        stylus_tools::Activator::builder()
-            .rpc(rpc)
-            .contract_address(address.to_string())
-            .build()
-            .activate()?;
-        println!("Activated contract at {address}");
-
-        let verify = stylus_tools::Verifier::builder()
-            .rpc(rpc)
-            .deployment_tx_hash(tx_hash.to_string())
-            .build()
-            .verify();
-        assert!(verify.is_ok(), "Failed to verify contract");
+        let (devnode, address) = ArraysIntegrationTester::init().await?;
         let provider = devnode.create_provider().await?;
 
         // Instantiate contract
diff --git a/examples/constructor/tests/constructor_integration_test.rs b/examples/constructor/tests/constructor_integration_test.rs
@@ -8,8 +8,11 @@ mod integration_test {
         providers::Provider,
         sol,
     };
+    use alloy_primitives::TxHash;
     use eyre::Result;
-    use stylus_tools::devnet::{addresses::OWNER, Node};
+    use stylus_tools::devnet::addresses::OWNER;
+    use stylus_tools::utils::testing::ExampleContractTester;
+    use stylus_tools::{Deployer, Verifier};
 
     sol! {
         #[sol(rpc)]
@@ -21,7 +24,10 @@ mod integration_test {
         }
     }
 
-    const EXPECTED_ABI: &str = "\
+    struct ConstructorIntegrationTester {}
+
+    impl ExampleContractTester for ConstructorIntegrationTester {
+        const EXPECTED_ABI: &str = "\
 interface IContract {
     function setNumber(uint256 number) external;
 
@@ -31,61 +37,38 @@ interface IContract {
 
     error Unauthorized();
 }";
-    const EXPECTED_CONSTRUCTOR: &str = "constructor(uint256 initial_number) payable";
+        const EXPECTED_CONSTRUCTOR: &'static str = "constructor(uint256 initial_number) payable";
+
+        fn deployer(rpc: &str) -> Deployer {
+            Deployer::builder()
+                .rpc(rpc.to_owned())
+                .constructor_args(vec!["0xbeef".to_owned()])
+                .constructor_value("12.34".to_owned())
+                .build()
+        }
+
+        fn test_verify(rpc: &str, tx_hash: TxHash) -> Result<()> {
+            let verify = Verifier::builder()
+                .rpc(rpc)
+                .deployment_tx_hash(tx_hash.to_string())
+                .build()
+                .verify();
+            assert!(verify.is_ok(), "Failed to verify contract");
+            let verify = Verifier::builder()
+                .rpc(rpc)
+                .dir("../callee".to_owned())
+                .deployment_tx_hash(tx_hash.to_string())
+                .build()
+                .verify();
+            assert!(verify.is_err(), "Should fail verifying wrong contract");
+            println!("Verified contract with tx hash {tx_hash}");
+            Ok(())
+        }
+    }
 
     #[tokio::test]
     async fn constructor() -> Result<()> {
-        let exporter = stylus_tools::Exporter::builder().build();
-        assert_eq!(exporter.export_abi()?, EXPECTED_ABI);
-        assert_eq!(exporter.export_constructor()?, EXPECTED_CONSTRUCTOR);
-
-        let devnode = Node::new().await?;
-        let rpc = devnode.rpc();
-
-        println!("Checking contract on Nitro ({rpc})...");
-        stylus_tools::Checker::builder().rpc(rpc).build().check()?;
-        println!("Checked contract");
-
-        let deployer = stylus_tools::Deployer::builder()
-            .rpc(rpc.to_owned())
-            .constructor_args(vec!["0xbeef".to_owned()])
-            .constructor_value("12.34".to_owned())
-            .build();
-        println!("Estimating gas...");
-        let gas_estimate = deployer.estimate_gas()?;
-        println!("Estimated deployment gas: {gas_estimate} ETH");
-
-        println!("Deploying contract to Nitro ({rpc})...");
-        let (address, tx_hash, gas_used) = deployer.deploy()?;
-        println!("Deployed contract to {address}");
-
-        // Approximate equality is usually expected, but given the test conditions, the gas estimate equals the gas used
-        assert_eq!(gas_used, gas_estimate);
-
-        println!("Activating contract at {address} on Nitro ({rpc})...");
-        stylus_tools::Activator::builder()
-            .rpc(rpc)
-            .contract_address(address.to_string())
-            .build()
-            .activate()?;
-        println!("Activated contract at {address}");
-
-        let verify = stylus_tools::Verifier::builder()
-            .rpc(rpc)
-            .deployment_tx_hash(tx_hash.to_string())
-            .build()
-            .verify();
-        assert!(verify.is_ok(), "Failed to verify contract");
-
-        let verify = stylus_tools::Verifier::builder()
-            .rpc(rpc)
-            .dir("../callee".to_owned())
-            .deployment_tx_hash(tx_hash.to_string())
-            .build()
-            .verify();
-        assert!(verify.is_err(), "Should fail verifying wrong contract");
-        println!("Verified contract with tx hash {tx_hash}");
-
+        let (devnode, address) = ConstructorIntegrationTester::init().await?;
         let provider = devnode.create_provider().await?;
 
         // Check balance sent in constructor
diff --git a/stylus-tools/src/utils/mod.rs b/stylus-tools/src/utils/mod.rs
@@ -27,6 +27,9 @@ pub(crate) mod stylus_sdk;
 pub(crate) mod toolchain;
 pub(crate) mod wasm;
 
+#[cfg(feature = "integration-tests")]
+pub mod testing;
+
 /// Pretty-prints a data fee.
 pub fn format_data_fee(fee: U256) -> String {
     // TODO: alternative to magic numbers
diff --git a/stylus-tools/src/utils/testing.rs b/stylus-tools/src/utils/testing.rs
