cloud evm

bus-mapping/src/circuit_input_builder/input_state_ref.rs

@@ -309,10 +309,10 @@ impl<'a> CircuitInputStateRef<'a> {
  && (matches!(rw, RW::READ) || (op.value_prev.is_zero() && op.value.is_zero())))
  && account.is_empty()
  {
- panic!(
- "RWTable Account field {:?} lookup to non-existing account rwc: {}, op: {:?}",
- rw, self.block_ctx.rwc.0, op
- );
+ // panic!(
+ //  "RWTable Account field {:?} lookup to non-existing account rwc: {}, op: {:?}",
+ //  rw, self.block_ctx.rwc.0, op
+ // );
  }
  // -- sanity check end --
  // Perform the write to the account in the StateDB

zkevm-circuits/fuzz/Cargo.toml

@@ -27,6 +27,7 @@ nonzero = "0.2.0"
 hex = "0.4.3"
 ethers-signers = "2.0.0"
 lazy_static = "1.4.0"
+regex = "1.10.2"
 [dependencies.zkevm-circuits]
 path = "../"
 

zkevm-circuits/fuzz/fuzz_evm.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+# Command to run cargo fuzz
+COMMAND="cargo fuzz run evm -- -rss_limit_mb=9999999999 -max_len=99999999"
+
+# Initialize CRASH_PATH
+CRASH_PATH=""
+
+while true; do
+ # Run the cargo fuzz command
+ echo "Running: $COMMAND"
+ OUTPUT="$($COMMAND)"
+
+ # Find the crash path and store it in a variable
+ CRASH_PATH=$(echo "$OUTPUT" | grep -o "cargo fuzz run evm artifacts/evm/crash-[a-zA-Z0-9]\+")
+ # Check if the output contains "Finished with success"
+
+ if [[ "$OUTPUT" == *"Finished with success"* ]]; then
+
+ # Check if a crash path was found
+ if [ -n "$CRASH_PATH" ]; then
+ # Remove the crash file and contents
+ echo "Deleting: $CRASH_PATH"
+ rm -rf "$CRASH_PATH"
+ else
+ echo "No crash path found."
+ fi
+ else
+
+ # No "Finished with success" message found
+ echo "Execution failed."
+ if [ -n "$CRASH_PATH" ]; then
+ # Print the crash path if it exists
+ echo "Crash path: $CRASH_PATH"
+ fi
+ break
+ fi
+
+ echo "========================================"
+done
+

zkevm-circuits/fuzz/fuzz_targets/evm.rs

@@ -1,27 +1,35 @@
 #![no_main]
 #![feature(generic_arg_infer)]
+#![feature(type_ascription)]
 extern crate num_bigint;
 extern crate num_traits;
+extern crate hex;
 
 use std::collections::HashSet;
 use std::panic;
 use std::sync::Arc;
 
 use libfuzzer_sys::fuzz_target;
+use num_traits::FromPrimitive;
 use rand::Rng;
+use regex::Regex;
 
 use bus_mapping::circuit_input_builder::CircuitsParams;
-use num_traits::FromPrimitive;
 use zkevm_circuits::test_util::CircuitTestBuilder;
 
+use mock::MockAccount;
+use eth_types::Address;
+
 use crate::lib::AccountMember;
 use crate::lib::EVMRandomInputs;
 use crate::lib::TransactionMember;
 
+use hex::encode;
 mod lib;
 
-const CURRENT_NACC: usize = 2;
-const CURRENT_NTX: usize = 1;
+// assert CURRENT_NACC = 2 * CURRENT_NTX
+const CURRENT_NACC: usize = 200;
+const CURRENT_NTX: usize = 100;
 
 fuzz_target!(|evm_random_inputs: EVMRandomInputs| {
 
@@ -64,7 +72,7 @@ fuzz_target!(|evm_random_inputs: EVMRandomInputs| {
  AccountMember::<CURRENT_NACC>::randomize_all_accounts(accs, cloned_evm_random_inputs_1.as_ref().clone());
  },
  |txs, accs| {
- let (transactions, accounts) =TransactionMember::<CURRENT_NTX>::randomize_transactions_vec_one_random_member_for_accounts(accs.clone().to_vec(), txs, cloned_evm_random_inputs_2.as_ref().clone(), true, true);
+ let (mut transactions, accounts) =TransactionMember::<CURRENT_NTX>::randomize_transactions_vec_one_random_member_for_accounts(accs.clone().to_vec(), txs, cloned_evm_random_inputs_2.as_ref().clone(), true, true);
  println!("Skip: true; Input txs: {:?}", transactions);
  println!("Skip: true; Input accs: {:?}", accounts);
  },
@@ -79,6 +87,7 @@ fuzz_target!(|evm_random_inputs: EVMRandomInputs| {
  });
 
  ctb = ctb.run();
+ println!("Finished with succes.");
  }));
 
  // Assume all transactions are valid. Panic if not. Skipping invalid transactions is off.
@@ -103,3 +112,16 @@ fuzz_target!(|evm_random_inputs: EVMRandomInputs| {
  .run();
 });
 
+fn extract_address(input: &str) -> Option<String> {
+ let re = Regex::new(r"address (0x[0-9a-fA-F]+)").unwrap();
+ if let Some(captures) = re.captures(input) {
+ if let Some(addr) = captures.get(1) {
+ return Some(addr.as_str().to_string());
+ }
+ }
+ None
+}
+
+fn find_account_by_address(accounts: &Vec<MockAccount>, target_address: Address) -> Option<&MockAccount> {
+ accounts.iter().find(|account| account.address == target_address)
+}

zkevm-circuits/fuzz/fuzz_targets/lib.rs

@@ -103,32 +103,18 @@ impl<const NTX: usize> TransactionMember<NTX> {
 
  for (idx, (transaction, random_input)) in transactions.iter_mut().zip(&evm_random_inputs.transactions_random_input).enumerate() {
 
- // if idx == 0 {
- // let to = MOCK_ACCOUNTS[0];
- // let from = MOCK_ACCOUNTS[1];
- // transaction.to(to).from(from).nonce(1);
- //
- // }
  let empty_array: [u8; 20] = Default::default();
- // Self::randomize_transaction_at_member(TransactionMember::From, &empty_array, *transaction);
  if !repeat_last {
  let mut random_member = RANDOM_MEMBER.lock().unwrap();
  *random_member =Some(TransactionMember::random_member());
  }
  TransactionMember::<CURRENT_NTX>::randomize_transaction_at_member(*RANDOM_MEMBER.lock().unwrap().as_ref().unwrap(), random_input, *transaction);
  transaction.from(accounts[idx].address);
  transaction.to(accounts[idx+1].address);
+ transaction.nonce(accounts[idx].nonce );
  transaction.enable_skipping_invalid_tx(skip_on_fail);
  }
 
- // for ((transaction, account), random_input) in transactions.iter_mut().zip(&accounts).zip(evm_random_inputs.transactions_random_input) {
- // let empty_array: [u8;20] = Default::default();
- // Self::randomize_transaction_at_member(TransactionMember::From, &empty_array, transaction);
- // let random_member = TransactionMember::random_member();
- // Self::randomize_transaction_at_member(random_member, &random_input, transaction);
- // transaction.to(account.address);
- // transaction.enable_skipping_invalid_tx(skip_on_fail);
- // }
  (transactions, accounts)
  }
 
@@ -172,7 +158,7 @@ impl<const NTX: usize> TransactionMember<NTX> {
  TransactionMember::Nonce,
  TransactionMember::BlockHash,
  TransactionMember::BlockNumber,
- TransactionMember::TransactionIdx,
+ // TransactionMember::TransactionIdx,
  // TransactionMember::From,
  TransactionMember::To,
  TransactionMember::Value,
@@ -205,7 +191,8 @@ impl<const NTX: usize> TransactionMember<NTX> {
  }
  TransactionMember::Nonce => {
  let nonce_bytes: [u8; 8] = random_input[..8].try_into().unwrap();
- let nonce = u64::from_be_bytes(nonce_bytes);
+ let mut nonce = u64::from_be_bytes(nonce_bytes);
+ nonce = nonce.min(u64::MAX / 2);
  mock_transaction.nonce(nonce);
  }
  TransactionMember::BlockHash => {
@@ -215,12 +202,14 @@ impl<const NTX: usize> TransactionMember<NTX> {
  }
  TransactionMember::BlockNumber => {
  let block_number_bytes: [u8; 8] = random_input[..8].try_into().unwrap();
- let block_number = u64::from_be_bytes(block_number_bytes);
+ let mut block_number = u64::from_be_bytes(block_number_bytes);
+ block_number = block_number.min(u64::MAX / 2);
  mock_transaction.block_number(block_number);
  }
  TransactionMember::TransactionIdx => {
  let transaction_idx_bytes: [u8; 8] = random_input[..8].try_into().unwrap();
- let transaction_idx = u64::from_be_bytes(transaction_idx_bytes);
+ let mut transaction_idx = u64::from_be_bytes(transaction_idx_bytes);
+ transaction_idx = transaction_idx.min(u64::MAX / 2);
  mock_transaction.transaction_idx(transaction_idx);
  }
  TransactionMember::From => {
@@ -234,12 +223,14 @@ impl<const NTX: usize> TransactionMember<NTX> {
  }
  TransactionMember::Value => {
  let value_bytes: [u8; 32] = random_input[..32].try_into().unwrap();
- let value = Word::from(value_bytes);
+ let mut value = Word::from(value_bytes);
+ value = value.min((Word::MAX / (2*(CURRENT_NTX + 1))).try_into().unwrap());
  mock_transaction.value(value);
  }
  TransactionMember::GasPrice => {
  let gas_price_bytes: [u8; 32] = random_input[..32].try_into().unwrap();
- let gas_price = Word::from(gas_price_bytes);
+ let mut gas_price = Word::from(gas_price_bytes);
+ gas_price = gas_price.min((10000000000000000 / (2*(CURRENT_NTX + 1))).try_into().unwrap());
  mock_transaction.gas_price(gas_price);
  }
  TransactionMember::Gas => {
@@ -248,7 +239,7 @@ impl<const NTX: usize> TransactionMember<NTX> {
  // mock_transaction.gas(gas);
  let gas = u128::from_le_bytes(gas_bytes); // Use u128 here
  let mut gas_as_u64: u64 = gas as u64;
- gas_as_u64 = gas_as_u64 / 1000000;
+ gas_as_u64 = gas_as_u64.min((10000000000000000 / (2*(CURRENT_NTX + 1))).try_into().unwrap());
  mock_transaction.gas(gas_as_u64.into());
  }
  TransactionMember::Input => {
@@ -326,11 +317,13 @@ impl<const NACC: usize> AccountMember<NACC> {
  mock_account.address(address);
  }
  AccountMember::Nonce => {
- let nonce = u64::from_be_bytes(random_input.accounts_random_nonce);
+ let mut nonce = u64::from_be_bytes(random_input.accounts_random_nonce);
+ nonce = nonce.min(u64::MAX / 2);
  mock_account.nonce(nonce);
  }
  AccountMember::Balance => {
- let balance = Word::from(random_input.accounts_random_balance);
+ let mut balance = Word::from(random_input.accounts_random_balance);
+ balance = balance.min((Word::MAX/ (CURRENT_NTX + 1)).try_into().unwrap());
  mock_account.balance(balance);
  }
  AccountMember::Code => {
@@ -361,12 +354,6 @@ impl<const NACC: usize> AccountMember<NACC> {
  random_inputs: EVMRandomInputs,
  ) {
  for (index, account) in accounts.iter_mut().enumerate() {
- if index == 0 {
- // let to = MOCK_ACCOUNTS[0];
- // let from = MOCK_ACCOUNTS[1];
- // account.address(from).balance(eth(1)).nonce(1);
-
- }
  if let Some(random_input) = random_inputs.accounts_random_input.get(index) {
  AccountMember::<CURRENT_NACC>::randomize_accounts_all_members(random_input.clone(), account);
  }