feat: if rws reaches limit, stop early and return err (#1669)

### Description

solve
#1592

### 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?

[_explanation_]

<hr>

## How to fill a PR description 

Please give a concise description of your PR.

The target readers could be future developers, reviewers, and auditors.
By reading your description, they should easily understand the changes
proposed in this pull request.

MUST: Reference the issue to resolve

### Single responsability

Is RECOMMENDED to create single responsibility commits, but not
mandatory.

Anyway, you MUST enumerate the changes in a unitary way, e.g.

```
This PR contains:
- Cleanup of xxxx, yyyy
- Changed xxxx to yyyy in order to bla bla
- Added xxxx function to ...
- Refactored ....
```

### Design choices

RECOMMENDED to:
- What types of design choices did you face?
- What decisions you have made?
- Any valuable information that could help reviewers to think critically

Author: lispc

bus-mapping/src/circuit_input_builder.rs

@@ -82,10 +82,21 @@ pub struct FixedCParams {
 pub struct DynamicCParams {}
 
 /// Circuit Setup Parameters. These can be fixed/concrete or unset/dynamic.
-pub trait CircuitsParams: Debug + Copy {}
+pub trait CircuitsParams: Debug + Copy {
+    /// Returns the max number of rws allowed
+    fn max_rws(&self) -> Option<usize>;
+}
 
-impl CircuitsParams for FixedCParams {}
-impl CircuitsParams for DynamicCParams {}
+impl CircuitsParams for FixedCParams {
+    fn max_rws(&self) -> Option<usize> {
+        Some(self.max_rws)
+    }
+}
+impl CircuitsParams for DynamicCParams {
+    fn max_rws(&self) -> Option<usize> {
+        None
+    }
+}
 
 impl Default for FixedCParams {
     /// Default values for most of the unit tests of the Circuit Parameters
@@ -166,6 +177,7 @@ impl<'a, C: CircuitsParams> CircuitInputBuilder<C> {
             block_ctx: &mut self.block_ctx,
             tx,
             tx_ctx,
+            max_rws: self.circuits_params.max_rws(),
         }
     }
 
@@ -275,11 +287,11 @@ impl CircuitInputBuilder<FixedCParams> {
     ) -> Result<&CircuitInputBuilder<FixedCParams>, Error> {
         // accumulates gas across all txs in the block
         self.begin_handle_block(eth_block, geth_traces)?;
-        self.set_end_block(self.circuits_params.max_rws);
+        self.set_end_block(self.circuits_params.max_rws)?;
         Ok(self)
     }
 
-    fn set_end_block(&mut self, max_rws: usize) {
+    fn set_end_block(&mut self, max_rws: usize) -> Result<(), Error> {
         let mut end_block_not_last = self.block.block_steps.end_block_not_last.clone();
         let mut end_block_last = self.block.block_steps.end_block_last.clone();
         end_block_not_last.rwc = self.block_ctx.rwc;
@@ -295,7 +307,7 @@ impl CircuitInputBuilder<FixedCParams> {
                 call_id,
                 CallContextField::TxId,
                 Word::from(state.block.txs.len() as u64),
-            );
+            )?;
         }
 
         let mut push_op = |step: &mut ExecStep, rwc: RWCounter, rw: RW, op: StartOp| {
@@ -333,6 +345,7 @@ impl CircuitInputBuilder<FixedCParams> {
 
         self.block.block_steps.end_block_not_last = end_block_not_last;
         self.block.block_steps.end_block_last = end_block_last;
+        Ok(())
     }
 }
 
@@ -434,7 +447,7 @@ impl CircuitInputBuilder<DynamicCParams> {
             block_ctx: self.block_ctx,
         };
 
-        cib.set_end_block(c_params.max_rws);
+        cib.set_end_block(c_params.max_rws)?;
         Ok(cib)
     }
 }

bus-mapping/src/circuit_input_builder/input_state_ref.rs

@@ -40,6 +40,8 @@ pub struct CircuitInputStateRef<'a> {
     pub tx: &'a mut Transaction,
     /// Transaction Context
     pub tx_ctx: &'a mut TransactionContext,
+    /// Max rw number limit
+    pub max_rws: Option<usize>,
 }
 
 impl<'a> CircuitInputStateRef<'a> {
@@ -114,7 +116,7 @@ impl<'a> CircuitInputStateRef<'a> {
     /// reference to the stored operation ([`OperationRef`]) inside the
     /// bus-mapping instance of the current [`ExecStep`].  Then increase the
     /// block_ctx [`RWCounter`](crate::operation::RWCounter) by one.
-    pub fn push_op<T: Op>(&mut self, step: &mut ExecStep, rw: RW, op: T) {
+    pub fn push_op<T: Op>(&mut self, step: &mut ExecStep, rw: RW, op: T) -> Result<(), Error> {
         if let OpEnum::Account(op) = op.clone().into_enum() {
             self.check_update_sdb_account(rw, &op)
         }
@@ -123,6 +125,20 @@ impl<'a> CircuitInputStateRef<'a> {
                 .container
                 .insert(Operation::new(self.block_ctx.rwc.inc_pre(), rw, op));
         step.bus_mapping_instance.push(op_ref);
+        self.check_rw_num_limit()
+    }
+
+    /// Check whether rws will overflow circuit limit.
+    pub fn check_rw_num_limit(&self) -> Result<(), Error> {
+        if let Some(max_rws) = self.max_rws {
+            let rwc = self.block_ctx.rwc.0;
+            if rwc > max_rws {
+                log::error!("rwc > max_rws, rwc={}, max_rws={}", rwc, max_rws);
+                return Err(Error::RwsNotEnough(max_rws, rwc));
+            };
+        }
+
+        Ok(())
     }
 
     /// Push a read type [`CallContextOp`] into the
@@ -137,14 +153,14 @@ impl<'a> CircuitInputStateRef<'a> {
         call_id: usize,
         field: CallContextField,
         value: Word,
-    ) {
+    ) -> Result<(), Error> {
         let op = CallContextOp {
             call_id,
             field,
             value,
         };
 
-        self.push_op(step, RW::READ, op);
+        self.push_op(step, RW::READ, op)
     }
 
     /// Push a write type [`CallContextOp`] into the
@@ -159,14 +175,14 @@ impl<'a> CircuitInputStateRef<'a> {
         call_id: usize,
         field: CallContextField,
         value: Word,
-    ) {
+    ) -> Result<(), Error> {
         let op = CallContextOp {
             call_id,
             field,
             value,
         };
 
-        self.push_op(step, RW::WRITE, op);
+        self.push_op(step, RW::WRITE, op)
     }
 
     /// Push an [`Operation`](crate::operation::Operation) with reversible to be
@@ -203,7 +219,7 @@ impl<'a> CircuitInputStateRef<'a> {
                 .push((self.tx.steps().len(), op_ref));
         }
 
-        Ok(())
+        self.check_rw_num_limit()
     }
 
     /// Push a read type [`MemoryOp`] into the
@@ -219,7 +235,7 @@ impl<'a> CircuitInputStateRef<'a> {
         value: u8,
     ) -> Result<(), Error> {
         let call_id = self.call()?.call_id;
-        self.push_op(step, RW::READ, MemoryOp::new(call_id, address, value));
+        self.push_op(step, RW::READ, MemoryOp::new(call_id, address, value))?;
         Ok(())
     }
 
@@ -236,7 +252,7 @@ impl<'a> CircuitInputStateRef<'a> {
         value: u8,
     ) -> Result<(), Error> {
         let call_id = self.call()?.call_id;
-        self.push_op(step, RW::WRITE, MemoryOp::new(call_id, address, value));
+        self.push_op(step, RW::WRITE, MemoryOp::new(call_id, address, value))?;
         Ok(())
     }
 
@@ -253,7 +269,7 @@ impl<'a> CircuitInputStateRef<'a> {
         value: Word,
     ) -> Result<(), Error> {
         let call_id = self.call()?.call_id;
-        self.push_op(step, RW::WRITE, StackOp::new(call_id, address, value));
+        self.push_op(step, RW::WRITE, StackOp::new(call_id, address, value))?;
         Ok(())
     }
 
@@ -270,7 +286,7 @@ impl<'a> CircuitInputStateRef<'a> {
         value: Word,
     ) -> Result<(), Error> {
         let call_id = self.call()?.call_id;
-        self.push_op(step, RW::READ, StackOp::new(call_id, address, value));
+        self.push_op(step, RW::READ, StackOp::new(call_id, address, value))?;
         Ok(())
     }
 
@@ -352,9 +368,9 @@ impl<'a> CircuitInputStateRef<'a> {
         address: Address,
         field: AccountField,
         value: Word,
-    ) {
+    ) -> Result<(), Error> {
         let op = AccountOp::new(address, field, value, value);
-        self.push_op(step, RW::READ, op);
+        self.push_op(step, RW::READ, op)
     }
 
     /// Push a write type [`AccountOp`] into the
@@ -376,7 +392,7 @@ impl<'a> CircuitInputStateRef<'a> {
         if reversible {
             self.push_op_reversible(step, op)?;
         } else {
-            self.push_op(step, RW::WRITE, op);
+            self.push_op(step, RW::WRITE, op)?;
         }
         Ok(())
     }
@@ -400,8 +416,7 @@ impl<'a> CircuitInputStateRef<'a> {
             step,
             RW::WRITE,
             TxLogOp::new(tx_id, log_id, field, index, value),
-        );
-        Ok(())
+        )
     }
 
     /// Push a read type [`TxReceiptOp`] into the
@@ -425,8 +440,7 @@ impl<'a> CircuitInputStateRef<'a> {
                 field,
                 value,
             },
-        );
-        Ok(())
+        )
     }
 
     /// Push a write type [`TxReceiptOp`] into the
@@ -450,8 +464,7 @@ impl<'a> CircuitInputStateRef<'a> {
                 field,
                 value,
             },
-        );
-        Ok(())
+        )
     }
 
     /// Push a write type [`TxAccessListAccountOp`] into the
@@ -477,8 +490,7 @@ impl<'a> CircuitInputStateRef<'a> {
                 is_warm,
                 is_warm_prev,
             },
-        );
-        Ok(())
+        )
     }
 
     /// Add address to access list for the current transaction.
@@ -542,7 +554,7 @@ impl<'a> CircuitInputStateRef<'a> {
                     value: sender_balance,
                     value_prev: sender_balance_prev,
                 },
-            );
+            )?;
             sender_balance_prev = sender_balance;
         }
         let sender_balance = sender_balance_prev - value;
@@ -766,29 +778,39 @@ impl<'a> CircuitInputStateRef<'a> {
     }
 
     /// read reversion info
-    pub(crate) fn reversion_info_read(&mut self, step: &mut ExecStep, call: &Call) {
+    pub(crate) fn reversion_info_read(
+        &mut self,
+        step: &mut ExecStep,
+        call: &Call,
+    ) -> Result<(), Error> {
         for (field, value) in [
             (
                 CallContextField::RwCounterEndOfReversion,
                 call.rw_counter_end_of_reversion.to_word(),
             ),
             (CallContextField::IsPersistent, call.is_persistent.to_word()),
         ] {
-            self.call_context_read(step, call.call_id, field, value);
+            self.call_context_read(step, call.call_id, field, value)?;
         }
+        Ok(())
     }
 
     /// write reversion info
-    pub(crate) fn reversion_info_write(&mut self, step: &mut ExecStep, call: &Call) {
+    pub(crate) fn reversion_info_write(
+        &mut self,
+        step: &mut ExecStep,
+        call: &Call,
+    ) -> Result<(), Error> {
         for (field, value) in [
             (
                 CallContextField::RwCounterEndOfReversion,
                 call.rw_counter_end_of_reversion.to_word(),
             ),
             (CallContextField::IsPersistent, call.is_persistent.to_word()),
         ] {
-            self.call_context_write(step, call.call_id, field, value);
+            self.call_context_write(step, call.call_id, field, value)?;
         }
+        Ok(())
     }
 
     /// Check if address is a precompiled or not.
@@ -1128,7 +1150,7 @@ impl<'a> CircuitInputStateRef<'a> {
                 call.call_id,
                 CallContextField::IsSuccess,
                 0u64.into(),
-            );
+            )?;
 
             // Even call.rw_counter_end_of_reversion is zero for now, it will set in
             // set_value_ops_call_context_rwc_eor later
@@ -1139,7 +1161,7 @@ impl<'a> CircuitInputStateRef<'a> {
                 call.call_id,
                 CallContextField::RwCounterEndOfReversion,
                 call.rw_counter_end_of_reversion.into(),
-            );
+            )?;
 
             if call.is_root {
                 return Ok(());
@@ -1155,7 +1177,7 @@ impl<'a> CircuitInputStateRef<'a> {
             call.call_id,
             CallContextField::CallerId,
             caller.call_id.into(),
-        );
+        )?;
 
         let [last_callee_return_data_offset, last_callee_return_data_length] =
             if exec_step.error.is_some() {
@@ -1233,7 +1255,7 @@ impl<'a> CircuitInputStateRef<'a> {
                 self.caller_ctx()?.reversible_write_counter.into(),
             ),
         ] {
-            self.call_context_read(exec_step, caller.call_id, field, value);
+            self.call_context_read(exec_step, caller.call_id, field, value)?;
         }
 
         // EIP-211: CREATE/CREATE2 call successful case should set RETURNDATASIZE = 0
@@ -1258,7 +1280,7 @@ impl<'a> CircuitInputStateRef<'a> {
                 },
             ),
         ] {
-            self.call_context_write(exec_step, caller.call_id, field, value);
+            self.call_context_write(exec_step, caller.call_id, field, value)?;
         }
 
         Ok(())
@@ -1547,7 +1569,7 @@ impl<'a> CircuitInputStateRef<'a> {
                         exec_step,
                         RW::READ,
                         MemoryOp::new(self.call()?.caller_id, addr.into(), byte),
-                    );
+                    )?;
                 }
                 byte
             } else {

bus-mapping/src/error.rs

@@ -40,6 +40,8 @@ pub enum Error {
     ExecutionError(ExecError),
     /// Internal Code error
     InternalError(&'static str),
+    /// Rw number overflow
+    RwsNotEnough(usize, usize),
 }
 
 impl From<eth_types::Error> for Error {

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

@@ -26,7 +26,7 @@ impl Opcode for Address {
             state.call()?.call_id,
             CallContextField::CalleeAddress,
             address,
-        );
+        )?;
 
         // Write the address to stack.
         state.stack_write(