feat: fuzzing

Cargo.toml

@@ -14,3 +14,9 @@ opt-level = "z"
 lto = true
 codegen-units = 1
 panic = "abort"
+
+[patch."https://github.com/rust-blockchain/evm"]
+evm = { git = "https://github.com/gakonst/evm", branch = "feat/clone-debug" }
+
+[patch."https://github.com/vorot93/evmodin"]
+evmodin = { git = "https://github.com/gakonst/evmodin", branch = "feat/clone-debug" }

dapp/Cargo.toml

@@ -26,9 +26,10 @@ glob = "0.3.0"
 tokio = { version = "1.10.1" }
 tracing = "0.1.26"
 tracing-subscriber = "0.2.20"
+proptest = "1.0.0"
 
 [dev-dependencies]
 evm-adapters = { path = "./../evm-adapters", features = ["sputnik", "sputnik-helpers", "evmodin", "evmodin-helpers"] }
 evmodin = { git = "https://github.com/vorot93/evmodin", features = ["util"] }
 # evm = { version = "0.30.1" }
-evm = { git = "https://github.com/gakonst/evm" }
+evm = { git = "https://github.com/rust-blockchain/evm" }

dapp/GreetTest.sol

@@ -30,6 +30,15 @@ contract GreeterTest is GreeterTestSetup {
         greeter.greet(greeting);
     }
 
+    function testFuzzing(string memory myGreeting) public {
+        greeter.greet(myGreeting);
+        require(keccak256(abi.encodePacked(greeter.greeting())) == keccak256(abi.encodePacked(myGreeting)), "not equal");
+    }
+
+    function testFuzzShrinking(uint256 x, uint256 y) public {
+        require(x * y <= 100, "product greater than 100");
+    }
+
     // check the positive case
     function testGreeting() public {
         greeter.greet("yo");

dapp/src/fuzz.rs

@@ -0,0 +1,37 @@
+use ethers::{
+    abi::{Function, ParamType, Token, Tokenizable},
+    types::{Address, Bytes, U256},
+};
+
+use proptest::prelude::*;
+
+pub fn fuzz_calldata(func: &Function) -> impl Strategy<Value = Bytes> + '_ {
+    // We need to compose all the strategies generated for each parameter in all
+    // possible combinations
+    let strats = func.inputs.iter().map(|input| fuzz_param(&input.kind)).collect::<Vec<_>>();
+
+    strats.prop_map(move |tokens| func.encode_input(&tokens).unwrap().into())
+}
+
+fn fuzz_param(param: &ParamType) -> impl Strategy<Value = Token> {
+    match param {
+        ParamType::Address => {
+            // The key to making this work is the `boxed()` call which type erases everything
+            // https://altsysrq.github.io/proptest-book/proptest/tutorial/transforming-strategies.html
+            any::<[u8; 20]>().prop_map(|x| Address::from_slice(&x).into_token()).boxed()
+        }
+        ParamType::Uint(n) => match n / 8 {
+            1 => any::<u8>().prop_map(|x| x.into_token()).boxed(),
+            2 => any::<u16>().prop_map(|x| x.into_token()).boxed(),
+            3..=4 => any::<u32>().prop_map(|x| x.into_token()).boxed(),
+            5..=8 => any::<u64>().prop_map(|x| x.into_token()).boxed(),
+            9..=16 => any::<u128>().prop_map(|x| x.into_token()).boxed(),
+            17..=32 => any::<[u8; 32]>().prop_map(|x| U256::from(&x).into_token()).boxed(),
+            _ => panic!("unsupported solidity type uint{}", n),
+        },
+        ParamType::String => any::<String>().prop_map(|x| x.into_token()).boxed(),
+        ParamType::Bytes => any::<Vec<u8>>().prop_map(|x| Bytes::from(x).into_token()).boxed(),
+        // TODO: Implement the rest of the strategies
+        _ => unimplemented!(),
+    }
+}

dapp/src/lib.rs

@@ -7,6 +7,8 @@ pub use runner::{ContractRunner, TestResult};
 mod multi_runner;
 pub use multi_runner::{MultiContractRunner, MultiContractRunnerBuilder};
 
+mod fuzz;
+
 use ethers::abi;
 use eyre::Result;
 

dapp/src/multi_runner.rs

@@ -7,6 +7,7 @@ use ethers::{
     utils::{keccak256, CompiledContract},
 };
 
+use proptest::test_runner::TestRunner;
 use regex::Regex;
 
 use eyre::Result;
@@ -24,12 +25,14 @@ pub struct MultiContractRunnerBuilder<'a> {
     /// The path for the output file
     pub out_path: PathBuf,
     pub no_compile: bool,
+    /// The fuzzer to be used for running fuzz tests
+    pub fuzzer: Option<TestRunner>,
 }
 
 impl<'a> MultiContractRunnerBuilder<'a> {
     /// Given an EVM, proceeds to return a runner which is able to execute all tests
     /// against that evm
-    pub fn build<E, S>(&self, mut evm: E) -> Result<MultiContractRunner<E, S>>
+    pub fn build<E, S>(self, mut evm: E) -> Result<MultiContractRunner<E, S>>
     where
         E: Evm<S>,
     {
@@ -52,14 +55,25 @@ impl<'a> MultiContractRunnerBuilder<'a> {
         });
         evm.initialize_contracts(init_state);
 
-        Ok(MultiContractRunner { contracts, addresses, evm, state: PhantomData })
+        Ok(MultiContractRunner {
+            contracts,
+            addresses,
+            evm,
+            state: PhantomData,
+            fuzzer: self.fuzzer,
+        })
     }
 
     pub fn contracts(mut self, contracts: &'a str) -> Self {
         self.contracts = contracts;
         self
     }
 
+    pub fn fuzzer(mut self, fuzzer: TestRunner) -> Self {
+        self.fuzzer = Some(fuzzer);
+        self
+    }
+
     pub fn remappings(mut self, remappings: &'a [String]) -> Self {
         self.remappings = remappings;
         self
@@ -88,12 +102,13 @@ pub struct MultiContractRunner<E, S> {
     addresses: HashMap<String, Address>,
     /// The EVM instance used in the test runner
     evm: E,
+    fuzzer: Option<TestRunner>,
     state: PhantomData<S>,
 }
 
 impl<E, S> MultiContractRunner<E, S>
 where
-    E: Evm<S>,
+    E: Evm<S> + Clone,
 {
     pub fn test(&mut self, pattern: Regex) -> Result<HashMap<String, HashMap<String, TestResult>>> {
         // NB: We also have access to the contract's abi. When running the test.
@@ -143,15 +158,15 @@ where
         pattern: &Regex,
     ) -> Result<HashMap<String, TestResult>> {
         let mut runner = ContractRunner::new(&mut self.evm, contract, address);
-        runner.run_tests(pattern)
+        runner.run_tests(pattern, self.fuzzer.as_mut())
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    fn test_multi_runner<S, E: Evm<S>>(evm: E) {
+    fn test_multi_runner<S, E: Clone + Evm<S>>(evm: E) {
         let mut runner =
             MultiContractRunnerBuilder::default().contracts("./GreetTest.sol").build(evm).unwrap();
 
@@ -172,7 +187,7 @@ mod tests {
         assert_eq!(only_gm["GmTest"].len(), 1);
     }
 
-    fn test_ds_test_fail<S, E: Evm<S>>(evm: E) {
+    fn test_ds_test_fail<S, E: Clone + Evm<S>>(evm: E) {
         let mut runner =
             MultiContractRunnerBuilder::default().contracts("./../FooTest.sol").build(evm).unwrap();
         let results = runner.test(Regex::new(".*").unwrap()).unwrap();