Add basic invalid tx support (#1677)

### Description

Resolves
#1611
Upstreamed from taikoxyz#157 with
some additional changes.

Adds an additional execution state for transactions that are invalid and
need to be skipped. This execution state needs to be enabled instead of
the normal BeginTx/EndTx for valid transactions.

Support skipping the following invalid transactions for now:
- nonce too low
- nonce too high
- intrinsic gas too low
- insufficient funds for gas * price + value

More cases will be added in future PRs.

### Issue Link


#1611

### Type of change

- [ ] Bug fix (non-breaking change which fixes an issue)
- [x] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to not work as expected)
- [ ] This change requires a documentation update

### Contents

- [_item_]

### Rationale

[_design decisions and extended information_]

### How Has This Been Tested?

- Added required unit tests
- make test-all passes

---------

Co-authored-by: Cecilia Zhang <[email protected]>

Author: Brechtpd

Cargo.lock

@@ -250,28 +250,37 @@ impl<'a, C: CircuitsParams> CircuitInputBuilder<C> {
         let mut tx = self.new_tx(tx_index, eth_tx, !geth_trace.failed)?;
         let mut tx_ctx = TransactionContext::new(eth_tx, geth_trace, is_last_tx)?;
 
-        // Generate BeginTx step
-        let begin_tx_step = gen_associated_steps(
-            &mut self.state_ref(&mut tx, &mut tx_ctx),
-            ExecState::BeginTx,
-        )?;
-        tx.steps_mut().push(begin_tx_step);
-
-        for (index, geth_step) in geth_trace.struct_logs.iter().enumerate() {
-            let mut state_ref = self.state_ref(&mut tx, &mut tx_ctx);
-            log::trace!("handle {}th opcode {:?} ", index, geth_step.op);
-            let exec_steps = gen_associated_ops(
-                &geth_step.op,
-                &mut state_ref,
-                &geth_trace.struct_logs[index..],
+        if !geth_trace.invalid {
+            // Generate BeginTx step
+            let begin_tx_step = gen_associated_steps(
+                &mut self.state_ref(&mut tx, &mut tx_ctx),
+                ExecState::BeginTx,
             )?;
-            tx.steps_mut().extend(exec_steps);
-        }
+            tx.steps_mut().push(begin_tx_step);
+
+            for (index, geth_step) in geth_trace.struct_logs.iter().enumerate() {
+                let mut state_ref = self.state_ref(&mut tx, &mut tx_ctx);
+                log::trace!("handle {}th opcode {:?} ", index, geth_step.op);
+                let exec_steps = gen_associated_ops(
+                    &geth_step.op,
+                    &mut state_ref,
+                    &geth_trace.struct_logs[index..],
+                )?;
+                tx.steps_mut().extend(exec_steps);
+            }
 
-        // Generate EndTx step
-        let end_tx_step =
-            gen_associated_steps(&mut self.state_ref(&mut tx, &mut tx_ctx), ExecState::EndTx)?;
-        tx.steps_mut().push(end_tx_step);
+            // Generate EndTx step
+            let end_tx_step =
+                gen_associated_steps(&mut self.state_ref(&mut tx, &mut tx_ctx), ExecState::EndTx)?;
+            tx.steps_mut().push(end_tx_step);
+        } else {
+            // Generate InvalidTx step
+            let invalid_tx_step = gen_associated_steps(
+                &mut self.state_ref(&mut tx, &mut tx_ctx),
+                ExecState::InvalidTx,
+            )?;
+            tx.steps_mut().push(invalid_tx_step);
+        }
 
         self.sdb.commit_tx();
         self.block.txs.push(tx);

bus-mapping/src/circuit_input_builder.rs

@@ -130,6 +130,8 @@ pub enum ExecState {
     EndTx,
     /// Virtual step End Block
     EndBlock,
+    /// Invalid Tx
+    InvalidTx,
 }
 
 impl Default for ExecState {

bus-mapping/src/circuit_input_builder/execution.rs

@@ -58,6 +58,16 @@ impl<'a> CircuitInputStateRef<'a> {
         ))
     }
 
+    /// Create a new InvalidTx step
+    pub fn new_invalid_tx_step(&self) -> ExecStep {
+        ExecStep {
+            exec_state: ExecState::InvalidTx,
+            gas_left: self.tx.gas(),
+            rwc: self.block_ctx.rwc,
+            ..Default::default()
+        }
+    }
+
     /// Create a new BeginTx step
     pub fn new_begin_tx_step(&self) -> ExecStep {
         ExecStep {

bus-mapping/src/circuit_input_builder/input_state_ref.rs

@@ -16,6 +16,7 @@ use eth_types::{
 };
 use lazy_static::lazy_static;
 use mock::{
+    eth,
     test_ctx::{helpers::*, LoggerConfig, TestContext},
     MOCK_COINBASE,
 };
@@ -44,6 +45,7 @@ impl CircuitInputBuilderTx {
             &GethExecTrace {
                 gas: 0,
                 failed: false,
+                invalid: false,
                 return_value: "".to_owned(),
                 struct_logs: vec![geth_step.clone()],
             },
@@ -339,6 +341,90 @@ fn tracer_call_success() {
     assert_eq!(error.unwrap(), None);
 }
 
+#[test]
+fn tracer_invalid_tx_invalid_nonce() {
+    let code_a = bytecode! {
+        PUSH1(0x0)
+    };
+
+    // Get the execution steps from the external tracer
+    let block: GethData = TestContext::<3, 1>::new(
+        None,
+        |accs| {
+            accs[0]
+                .address(address!("0x0000000000000000000000000000000000000000"))
+                .code(code_a);
+            accs[1]
+                .address(address!("0x000000000000000000000000000000000cafe001"))
+                .nonce(3);
+        },
+        |mut txs, accs| {
+            txs[0]
+                .to(accs[0].address)
+                .from(accs[1].address)
+                .invalid()
+                .set_nonce(1);
+        },
+        |block, _tx| block.number(0xcafeu64),
+    )
+    .unwrap()
+    .into();
+
+    assert!(block.geth_traces[0].invalid);
+}
+
+#[test]
+fn tracer_invalid_tx_insufficient_gas() {
+    // Get the execution steps from the external tracer
+    let block: GethData = TestContext::<3, 1>::new(
+        None,
+        |accs| {
+            accs[0].address(address!("0x0000000000000000000000000000000000000000"));
+            accs[1]
+                .address(address!("0x000000000000000000000000000000000cafe001"))
+                .balance(eth(1));
+        },
+        |mut txs, accs| {
+            txs[0]
+                .to(accs[0].address)
+                .from(accs[1].address)
+                .gas(Word::from(20_000))
+                .invalid();
+        },
+        |block, _tx| block.number(0xcafeu64),
+    )
+    .unwrap()
+    .into();
+
+    assert!(block.geth_traces[0].invalid);
+}
+
+#[test]
+fn tracer_invalid_tx_insufficient_balance() {
+    // Get the execution steps from the external tracer
+    let block: GethData = TestContext::<3, 1>::new(
+        None,
+        |accs| {
+            accs[0].address(address!("0x0000000000000000000000000000000000000000"));
+            accs[1]
+                .address(address!("0x000000000000000000000000000000000cafe001"))
+                .balance(Word::from(1));
+        },
+        |mut txs, accs| {
+            txs[0]
+                .to(accs[0].address)
+                .from(accs[1].address)
+                .value(100.into())
+                .invalid();
+        },
+        |block, _tx| block.number(0xcafeu64),
+    )
+    .unwrap()
+    .into();
+
+    assert!(block.geth_traces[0].invalid);
+}
+
 #[test]
 fn tracer_err_address_collision() {
     // We do CREATE2 twice with the same parameters, with a code_creater

bus-mapping/src/circuit_input_builder/tracer_tests.rs

@@ -28,6 +28,7 @@ mod extcodecopy;
 mod extcodehash;
 mod extcodesize;
 mod gasprice;
+mod invalid_tx;
 mod logs;
 mod mload;
 mod mstore;
@@ -60,7 +61,7 @@ mod error_write_protection;
 #[cfg(test)]
 mod memory_expansion_test;
 
-use self::sha3::Sha3;
+use self::{invalid_tx::InvalidTx, sha3::Sha3};
 use address::Address;
 use balance::Balance;
 use begin_end_tx::BeginEndTx;
@@ -408,6 +409,7 @@ pub fn gen_associated_steps(
 ) -> Result<ExecStep, Error> {
     let fn_gen_associated_steps = match execution_step {
         ExecState::BeginTx | ExecState::EndTx => BeginEndTx::gen_associated_steps,
+        ExecState::InvalidTx => InvalidTx::gen_associated_steps,
         _ => {
             unreachable!()
         }

bus-mapping/src/evm/opcodes.rs

@@ -1,6 +1,6 @@
 use super::TxExecSteps;
 use crate::{
-    circuit_input_builder::{CircuitInputStateRef, ExecState, ExecStep},
+    circuit_input_builder::{Call, CircuitInputStateRef, ExecState, ExecStep},
     operation::{AccountField, AccountOp, CallContextField, TxReceiptField, TxRefundOp, RW},
     state_db::CodeDB,
     Error,
@@ -33,8 +33,9 @@ fn gen_begin_tx_steps(state: &mut CircuitInputStateRef) -> Result<ExecStep, Erro
     let mut exec_step = state.new_begin_tx_step();
     let call = state.call()?.clone();
 
+    begin_tx(state, &mut exec_step, &call)?;
+
     for (field, value) in [
-        (CallContextField::TxId, state.tx_ctx.id().into()),
         (
             CallContextField::RwCounterEndOfReversion,
             call.rw_counter_end_of_reversion.into(),
@@ -313,17 +314,62 @@ fn gen_end_tx_steps(state: &mut CircuitInputStateRef) -> Result<ExecStep, Error>
         false,
     )?;
 
+    end_tx(state, &mut exec_step, &call)?;
+
+    Ok(exec_step)
+}
+
+pub(crate) fn begin_tx(
+    state: &mut CircuitInputStateRef,
+    exec_step: &mut ExecStep,
+    call: &Call,
+) -> Result<(), Error> {
+    // Write the transaction id
+    state.call_context_write(
+        exec_step,
+        call.call_id,
+        CallContextField::TxId,
+        state.tx_ctx.id().into(),
+    )?;
+    Ok(())
+}
+
+pub(crate) fn end_tx(
+    state: &mut CircuitInputStateRef,
+    exec_step: &mut ExecStep,
+    call: &Call,
+) -> Result<(), Error> {
+    // Write the tx receipt
+    write_tx_receipt(state, exec_step, call.is_persistent)?;
+
+    // Write the next transaction id if we're not at the last tx
+    if !state.tx_ctx.is_last_tx() {
+        state.call_context_write(
+            exec_step,
+            state.block_ctx.rwc.0 + 1,
+            CallContextField::TxId,
+            (state.tx_ctx.id() + 1).into(),
+        )?;
+    }
+    Ok(())
+}
+
+fn write_tx_receipt(
+    state: &mut CircuitInputStateRef,
+    exec_step: &mut ExecStep,
+    is_persistent: bool,
+) -> Result<(), Error> {
     // handle tx receipt tag
     state.tx_receipt_write(
-        &mut exec_step,
+        exec_step,
         state.tx_ctx.id(),
         TxReceiptField::PostStateOrStatus,
-        call.is_persistent as u64,
+        is_persistent as u64,
     )?;
 
     let log_id = exec_step.log_id;
     state.tx_receipt_write(
-        &mut exec_step,
+        exec_step,
         state.tx_ctx.id(),
         TxReceiptField::LogLength,
         log_id as u64,
@@ -332,7 +378,7 @@ fn gen_end_tx_steps(state: &mut CircuitInputStateRef) -> Result<ExecStep, Error>
     if state.tx_ctx.id() > 1 {
         // query pre tx cumulative gas
         state.tx_receipt_read(
-            &mut exec_step,
+            exec_step,
             state.tx_ctx.id() - 1,
             TxReceiptField::CumulativeGasUsed,
             state.block_ctx.cumulative_gas_used,
@@ -341,20 +387,11 @@ fn gen_end_tx_steps(state: &mut CircuitInputStateRef) -> Result<ExecStep, Error>
 
     state.block_ctx.cumulative_gas_used += state.tx.gas() - exec_step.gas_left;
     state.tx_receipt_write(
-        &mut exec_step,
+        exec_step,
         state.tx_ctx.id(),
         TxReceiptField::CumulativeGasUsed,
         state.block_ctx.cumulative_gas_used,
     )?;
 
-    if !state.tx_ctx.is_last_tx() {
-        state.call_context_write(
-            &mut exec_step,
-            state.block_ctx.rwc.0 + 1,
-            CallContextField::TxId,
-            (state.tx_ctx.id() + 1).into(),
-        )?;
-    }
-
-    Ok(exec_step)
+    Ok(())
 }

bus-mapping/src/evm/opcodes/begin_end_tx.rs

@@ -0,0 +1,47 @@
+use super::{
+    begin_end_tx::{begin_tx, end_tx},
+    TxExecSteps,
+};
+use crate::{
+    circuit_input_builder::{CircuitInputStateRef, ExecState, ExecStep},
+    operation::AccountField,
+    Error,
+};
+
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct InvalidTx;
+
+impl TxExecSteps for InvalidTx {
+    fn gen_associated_steps(
+        state: &mut CircuitInputStateRef,
+        _execution_step: ExecState,
+    ) -> Result<ExecStep, Error> {
+        let mut exec_step = state.new_invalid_tx_step();
+        let call = state.call()?.clone();
+        let caller = call.caller_address;
+
+        // Start processing the tx
+        begin_tx(state, &mut exec_step, &call)?;
+
+        // Read the nonce to prove mismatch
+        state.account_read(
+            &mut exec_step,
+            caller,
+            AccountField::Nonce,
+            state.sdb.get_account(&caller).1.nonce.into(),
+        )?;
+
+        // Read the balance to compare with intrinsic gas cost + value
+        state.account_read(
+            &mut exec_step,
+            caller,
+            AccountField::Balance,
+            state.sdb.get_account(&caller).1.balance,
+        )?;
+
+        // Stop processing the tx
+        end_tx(state, &mut exec_step, &call)?;
+
+        Ok(exec_step)
+    }
+}