chore: update revm and map new errors to rpc

crates/revm/revm-inspectors/src/tracing/builder/parity.rs

@@ -398,7 +398,7 @@ impl ParityTraceBuilder {
 
         // Calculate the stack items at this step
         let push_stack = {
-            let step_op = step.op.u8();
+            let step_op = step.op.get();
             let show_stack: usize;
             if (opcode::PUSH0..=opcode::PUSH32).contains(&step_op) {
                 show_stack = 1;
@@ -482,7 +482,7 @@ impl ParityTraceBuilder {
         let cost = self
             .spec_id
             .and_then(|spec_id| {
-                spec_opcode_gas(spec_id).get(step.op.u8() as usize).map(|op| op.get_gas())
+                spec_opcode_gas(spec_id).get(step.op.get() as usize).map(|op| op.get_gas())
             })
             .unwrap_or_default();
 

crates/revm/revm-inspectors/src/tracing/js/bindings.rs

@@ -233,14 +233,14 @@ impl OpObj {
         let to_string = FunctionObjectBuilder::new(
             context,
             NativeFunction::from_copy_closure(move |_this, _args, _ctx| {
-                let op = OpCode::try_from_u8(value)
+                let op = OpCode::new(value)
                     .or_else(|| {
                         // if the opcode is invalid, we'll use the invalid opcode to represent it
                         // because this is invoked before the opcode is
                         // executed, the evm will eventually return a `Halt`
                         // with invalid/unknown opcode as result
                         let invalid_opcode = 0xfe;
-                        OpCode::try_from_u8(invalid_opcode)
+                        OpCode::new(invalid_opcode)
                     })
                     .expect("is valid opcode;");
                 let s = op.to_string();

crates/revm/revm-inspectors/src/tracing/mod.rs

@@ -282,13 +282,13 @@ impl TracingInspector {
         let stack =
             self.config.record_stack_snapshots.then(|| interp.stack.clone()).unwrap_or_default();
 
-        let op = OpCode::try_from_u8(interp.current_opcode())
+        let op = OpCode::new(interp.current_opcode())
             .or_else(|| {
                 // if the opcode is invalid, we'll use the invalid opcode to represent it because
                 // this is invoked before the opcode is executed, the evm will eventually return a
                 // `Halt` with invalid/unknown opcode as result
                 let invalid_opcode = 0xfe;
-                OpCode::try_from_u8(invalid_opcode)
+                OpCode::new(invalid_opcode)
             })
             .expect("is valid opcode;");
 

crates/revm/revm-inspectors/src/tracing/types.rs

@@ -637,15 +637,15 @@ impl CallTraceStep {
     /// Returns true if the step is a STOP opcode
     #[inline]
     pub(crate) fn is_stop(&self) -> bool {
-        matches!(self.op.u8(), opcode::STOP)
+        matches!(self.op.get(), opcode::STOP)
     }
 
     /// Returns true if the step is a call operation, any of
     /// CALL, CALLCODE, DELEGATECALL, STATICCALL, CREATE, CREATE2
     #[inline]
     pub(crate) fn is_calllike_op(&self) -> bool {
         matches!(
-            self.op.u8(),
+            self.op.get(),
             opcode::CALL |
                 opcode::DELEGATECALL |
                 opcode::STATICCALL |

crates/rpc/rpc/src/eth/error.rs

@@ -296,6 +296,18 @@ pub enum RpcInvalidTransactionError {
     /// Block `blob_gas_price` is greater than tx-specified `max_fee_per_blob_gas` after Cancun.
     #[error("max fee per blob gas less than block blob gas fee")]
     BlobFeeCapTooLow,
+    /// Blob transaction has a versioned hash with an invalid blob
+    #[error("blob hash version mismatch")]
+    BlobHashVersionMismatch,
+    /// Blob transaction has no versioned hashes
+    #[error("blob transaction missing blob hashes")]
+    BlobTransactionMissingBlobHashes,
+    /// Blob transaction has too many blobs
+    #[error("blob transaction exceeds max blobs per block")]
+    TooManyBlobs,
+    /// Blob transaction is a create transaction
+    #[error("blob transaction is a create transaction")]
+    BlobTransactionIsCreate,
 }
 
 impl RpcInvalidTransactionError {
@@ -394,6 +406,16 @@ impl From<revm::primitives::InvalidTransaction> for RpcInvalidTransactionError {
             InvalidTransaction::BlobGasPriceGreaterThanMax => {
                 RpcInvalidTransactionError::BlobFeeCapTooLow
             }
+            InvalidTransaction::EmptyBlobs => {
+                RpcInvalidTransactionError::BlobTransactionMissingBlobHashes
+            }
+            InvalidTransaction::BlobVersionNotSupported => {
+                RpcInvalidTransactionError::BlobHashVersionMismatch
+            }
+            InvalidTransaction::TooManyBlobs => RpcInvalidTransactionError::TooManyBlobs,
+            InvalidTransaction::BlobCreateTransaction => {
+                RpcInvalidTransactionError::BlobTransactionIsCreate
+            }
         }
     }
 }