Merge pull request #361 from OffchainLabs/afilios/nit-3581-add-examples-that-test-cargo-stylus

Test verify, activate, and export in the integration tests

Author: alexandrosfilios

Cargo.lock

@@ -22,6 +22,9 @@ pub struct Args {
     #[arg(long)]
     deployment_tx: Vec<String>,
 
+    #[arg(long)]
+    skip_clean: bool,
+
     #[command(flatten)]
     project: ProjectArgs,
     #[command(flatten)]
@@ -40,7 +43,17 @@ pub async fn exec(args: Args) -> CargoStylusResult {
                 return Err(eyre!("Invalid hash").into());
             }
             let hash = TxHash::from_slice(&hash);
-            contract.verify(hash, &provider).await?;
+            match contract.verify(hash, args.skip_clean, &provider).await? {
+                stylus_tools::core::verification::VerificationStatus::Success => {
+                    println!("Verification successful");
+                }
+                stylus_tools::core::verification::VerificationStatus::Failure(failure) => {
+                    println!("Verification failed");
+                    println!("prelude mismatch: {:?}", failure.prelude_mismatch);
+                    println!("tx wasm length: {}", failure.tx_wasm_length);
+                    println!("build wasm length: {}", failure.build_wasm_length);
+                }
+            }
         } else {
             println!("Running in a Docker container for reproducibility, this may take a while",);
             let mut cli_args: Vec<String> =

cargo-stylus/src/commands/verify.rs

@@ -23,7 +23,10 @@ mod integration_test {
         let devnode = Node::new().await?;
         let rpc = devnode.rpc();
         println!("Deploying contract to Nitro ({rpc})...");
-        let address = stylus_tools::Deployer::new(rpc.to_owned()).deploy()?;
+        let (address, _, _) = stylus_tools::Deployer::builder()
+            .rpc(rpc)
+            .build()
+            .deploy()?;
         println!("Deployed contract to {address}");
         let provider = devnode.create_provider().await?;
         let contract = IDecoder::IDecoderInstance::new(address, provider);

examples/abi_decode/tests/abi_decode_integration_test.rs

@@ -25,7 +25,10 @@ mod integration_test {
         let devnode = Node::new().await?;
         let rpc = devnode.rpc();
         println!("Deploying contract to Nitro ({rpc})...");
-        let address = stylus_tools::Deployer::new(rpc.to_owned()).deploy()?;
+        let (address, _, _) = stylus_tools::Deployer::builder()
+            .rpc(rpc)
+            .build()
+            .deploy()?;
         println!("Deployed contract to {address}");
         let provider = devnode.create_provider().await?;
         let contract = IEncoder::IEncoderInstance::new(address, provider);

examples/abi_encode/tests/abi_encode_integration_test.rs

@@ -29,7 +29,10 @@ mod integration_test {
         let devnode = Node::new().await?;
         let rpc = devnode.rpc();
         println!("Deploying contract to Nitro ({rpc})...");
-        let address = stylus_tools::Deployer::new(rpc.to_owned()).deploy()?;
+        let (address, _, _) = stylus_tools::Deployer::builder()
+            .rpc(rpc)
+            .build()
+            .deploy()?;
         println!("Deployed contract to {address}");
         let provider = devnode.create_provider().await?;
         let contract = IArrays::IArraysInstance::new(address, provider);

examples/arrays/tests/arrays_integration_test.rs

@@ -41,7 +41,10 @@ mod integration_test {
         let devnode = Node::new().await?;
         let rpc = devnode.rpc();
         println!("Deploying contract to Nitro ({rpc})...");
-        let address = stylus_tools::Deployer::new(rpc.to_owned()).deploy()?;
+        let (address, _, _) = stylus_tools::Deployer::builder()
+            .rpc(rpc)
+            .build()
+            .deploy()?;
         println!("Deployed contract to {address}");
         let provider = devnode.create_provider().await?;
         let contract = IExampleContract::IExampleContractInstance::new(address, provider);

examples/call/tests/call_integration_test.rs

@@ -40,13 +40,18 @@ mod integration_test {
         let provider = devnode.create_provider().await?;
 
         println!("Deploying callee contract to Nitro ({rpc})...");
-        let callee_address = stylus_tools::Deployer::new(rpc.to_owned())
-            .with_contract_dir("../callee".into())
+        let (callee_address, _, _) = stylus_tools::Deployer::builder()
+            .rpc(rpc)
+            .dir("../callee".to_owned())
+            .build()
             .deploy()?;
         println!("Deployed callee contract to {callee_address}");
 
         println!("Deploying caller contract to Nitro ({rpc})...");
-        let caller_address = stylus_tools::Deployer::new(rpc.to_owned()).deploy()?;
+        let (caller_address, _, _) = stylus_tools::Deployer::builder()
+            .rpc(rpc)
+            .build()
+            .deploy()?;
         println!("Deployed caller contract to {caller_address}");
 
         let caller = ICaller::ICallerInstance::new(caller_address, provider);

examples/caller/tests/caller_callee_integration_test.rs

@@ -20,7 +20,10 @@ mod integration_test {
         let devnode = Node::new().await?;
         let rpc = devnode.rpc();
         println!("Deploying contract to Nitro ({rpc})...");
-        let address = stylus_tools::Deployer::new(rpc.to_owned()).deploy()?;
+        let (address, _, _) = stylus_tools::Deployer::builder()
+            .rpc(rpc)
+            .build()
+            .deploy()?;
         println!("Deployed contract to {address}");
         let provider = devnode.create_provider().await?;
         let contract = IContract::IContractInstance::new(address, provider);

examples/constants/tests/constants_integration_test.rs

@@ -21,16 +21,55 @@ mod integration_test {
         }
     }
 
+    const EXPECTED_ABI: &str = "\
+interface IContract {
+    function setNumber(uint256 number) external;
+
+    function number() external view returns (uint256);
+
+    function owner() external view returns (address);
+
+    error Unauthorized();
+}";
+    const EXPECTED_CONSTRUCTOR: &str = "constructor(uint256 initial_number) payable";
+
     #[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 = stylus_tools::Deployer::new(rpc.to_owned())
-            .with_constructor_args(vec!["0xbeef".to_owned()])
-            .with_constructor_value("12.34".to_owned())
-            .deploy()?;
+        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 provider = devnode.create_provider().await?;
 
         // Check balance sent in constructor

examples/constructor/tests/constructor_integration_test.rs

@@ -20,7 +20,10 @@ mod integration_test {
         let devnode = Node::new().await?;
         let rpc = devnode.rpc();
         println!("Deploying contract to Nitro ({rpc})...");
-        let address = stylus_tools::Deployer::new(rpc.to_owned()).deploy()?;
+        let (address, _, _) = stylus_tools::Deployer::builder()
+            .rpc(rpc)
+            .build()
+            .deploy()?;
         println!("Deployed contract to {address}");
         let provider = devnode.create_provider().await?;
         let contract = IContract::IContractInstance::new(address, provider);