Execute L1Handler transactions using the RpcState

rpc_state_reader/src/lib.rs

@@ -138,7 +138,7 @@ mod tests {
         );
 
         assert_eq!(
-            tx_trace.validate_invocation.calldata,
+            tx_trace.validate_invocation.as_ref().unwrap().calldata,
             Some(vec![
                 stark_felt!("1"),
                 stark_felt!("690c876e61beda61e994543af68038edac4e1cb1990ab06e52a2d27e56a1232"),
@@ -157,9 +157,16 @@ mod tests {
                 stark_felt!("38bd34c31a0a5c"),
             ])
         );
-        assert_eq!(tx_trace.validate_invocation.retdata, Some(vec![]));
+        assert_eq!(
+            tx_trace.validate_invocation.as_ref().unwrap().retdata,
+            Some(vec![])
+        );
         assert_eq_sorted!(
-            tx_trace.validate_invocation.execution_resources,
+            tx_trace
+                .validate_invocation
+                .as_ref()
+                .unwrap()
+                .execution_resources,
             ExecutionResources {
                 n_steps: 790,
                 n_memory_holes: 51,
@@ -170,7 +177,15 @@ mod tests {
                 ]),
             }
         );
-        assert_eq!(tx_trace.validate_invocation.internal_calls.len(), 1);
+        assert_eq!(
+            tx_trace
+                .validate_invocation
+                .as_ref()
+                .unwrap()
+                .internal_calls
+                .len(),
+            1
+        );
 
         assert_eq!(
             tx_trace.function_invocation.as_ref().unwrap().calldata,
@@ -243,19 +258,23 @@ mod tests {
         );
 
         assert_eq!(
-            tx_trace.fee_transfer_invocation.calldata,
+            tx_trace.fee_transfer_invocation.as_ref().unwrap().calldata,
             Some(vec![
                 stark_felt!("1176a1bd84444c89232ec27754698e5d2e7e1a7f1539f12027f28b23ec9f3d8"),
                 stark_felt!("2b0322a23ba4"),
                 stark_felt!("0"),
             ])
         );
         assert_eq!(
-            tx_trace.fee_transfer_invocation.retdata,
+            tx_trace.fee_transfer_invocation.as_ref().unwrap().retdata,
             Some(vec![1u128.into()])
         );
         assert_eq_sorted!(
-            tx_trace.fee_transfer_invocation.execution_resources,
+            tx_trace
+                .fee_transfer_invocation
+                .as_ref()
+                .unwrap()
+                .execution_resources,
             ExecutionResources {
                 n_steps: 586,
                 n_memory_holes: 42,
@@ -265,7 +284,15 @@ mod tests {
                 ]),
             }
         );
-        assert_eq!(tx_trace.fee_transfer_invocation.internal_calls.len(), 1);
+        assert_eq!(
+            tx_trace
+                .fee_transfer_invocation
+                .as_ref()
+                .unwrap()
+                .internal_calls
+                .len(),
+            1
+        );
     }
 
     #[test]

rpc_state_reader/src/rpc_state.rs

@@ -158,9 +158,9 @@ pub struct RpcResponse<T> {
 
 #[derive(Debug, Deserialize, Clone, Eq, PartialEq)]
 pub struct TransactionTrace {
-    pub validate_invocation: RpcCallInfo,
+    pub validate_invocation: Option<RpcCallInfo>,
     pub function_invocation: Option<RpcCallInfo>,
-    pub fee_transfer_invocation: RpcCallInfo,
+    pub fee_transfer_invocation: Option<RpcCallInfo>,
     pub signature: Vec<StarkFelt>,
     pub revert_error: Option<String>,
 }

rpc_state_reader/src/utils.rs

@@ -99,6 +99,7 @@ pub fn deserialize_transaction_json(
                 "unimplemented declare version: {x}"
             ))),
         },
+        "L1_HANDLER" => Ok(Transaction::L1Handler(serde_json::from_value(transaction)?)),
         x => Err(serde::de::Error::custom(format!(
             "unimplemented transaction type deserialization: {x}"
         ))),

rpc_state_reader/tests/blockifier_tests.rs

@@ -9,7 +9,10 @@ use blockifier::{
     transaction::{
         account_transaction::AccountTransaction,
         objects::TransactionExecutionInfo,
-        transactions::{DeclareTransaction, DeployAccountTransaction, ExecutableTransaction},
+        transactions::{
+            DeclareTransaction, DeployAccountTransaction, ExecutableTransaction,
+            L1HandlerTransaction,
+        },
     },
 };
 use blockifier::{
@@ -207,6 +210,21 @@ pub fn execute_tx(
             let declare = DeclareTransaction::new(tx, tx_hash, contract_class).unwrap();
             AccountTransaction::Declare(declare)
         }
+        SNTransaction::L1Handler(tx) => {
+            // As L1Hanlder is not an account transaction we execute it here and return the result
+            let blockifier_tx = L1HandlerTransaction {
+                tx,
+                tx_hash,
+                paid_fee_on_l1: starknet_api::transaction::Fee(u128::MAX),
+            };
+            return (
+                blockifier_tx
+                    .execute(&mut state, &block_context, true, true)
+                    .unwrap(),
+                trace,
+                receipt,
+            );
+        }
         _ => unimplemented!(),
     };
 
@@ -327,6 +345,16 @@ fn blockifier_test_recent_tx() {
     281513, // real block 281514
     RpcChain::MainNet
 )]
+#[test_case(
+    "0x26be3e906db66973de1ca5eec1ddb4f30e3087dbdce9560778937071c3d3a83",
+    351268, // real block 351269
+    RpcChain::MainNet
+)]
+#[test_case(
+    "0x4f552c9430bd21ad300db56c8f4cae45d554a18fac20bf1703f180fac587d7e",
+    351225, // real block 351226
+    RpcChain::MainNet
+)]
 // DeployAccount for different account providers (as of October 2023):
 // All of them were deployed on testnet using starkli
 // OpenZeppelin (v0.7.0)

rpc_state_reader/tests/sir_tests.rs

@@ -28,7 +28,7 @@ use starknet_in_rust::{
         state_cache::StorageEntry,
         BlockInfo,
     },
-    transaction::{Declare, DeclareV2, DeployAccount, InvokeFunction},
+    transaction::{Declare, DeclareV2, DeployAccount, InvokeFunction, L1Handler},
     utils::{Address, ClassHash},
 };
 
@@ -208,6 +208,13 @@ pub fn execute_tx_configurable(
                 declare.create_for_simulation(skip_validate, false, false, false)
             }
         }
+        SNTransaction::L1Handler(tx) => L1Handler::from_sn_api_tx(
+            tx,
+            Felt252::from_bytes_be(tx_hash.0.bytes()),
+            Some(Felt252::from(u128::MAX)),
+        )
+        .unwrap()
+        .create_for_simulation(skip_validate, false),
         _ => unimplemented!(),
     };
 
@@ -352,6 +359,16 @@ fn test_get_gas_price() {
     281513, // real block 281514
     RpcChain::MainNet
 )]
+#[test_case(
+    "0x26be3e906db66973de1ca5eec1ddb4f30e3087dbdce9560778937071c3d3a83",
+    351268, // real block 351269
+    RpcChain::MainNet
+)]
+#[test_case(
+    "0x4f552c9430bd21ad300db56c8f4cae45d554a18fac20bf1703f180fac587d7e",
+    351225, // real block 351226
+    RpcChain::MainNet
+)]
 // DeployAccount for different account providers (as of October 2023):
 // All of them were deployed on testnet using starkli
 // OpenZeppelin (v0.7.0)

src/transaction/l1_handler.rs

@@ -200,11 +200,7 @@ impl L1Handler {
     }
 
     /// Creates a L1Handler for simulation purposes.
-    pub(crate) fn create_for_simulation(
-        &self,
-        skip_validate: bool,
-        skip_execute: bool,
-    ) -> Transaction {
+    pub fn create_for_simulation(&self, skip_validate: bool, skip_execute: bool) -> Transaction {
         let tx = L1Handler {
             skip_validate,
             skip_execute,
@@ -213,6 +209,27 @@ impl L1Handler {
 
         Transaction::L1Handler(tx)
     }
+
+    /// Creates a `L1Handler` from a starknet api `L1HandlerTransaction`.
+    pub fn from_sn_api_tx(
+        tx: starknet_api::transaction::L1HandlerTransaction,
+        tx_hash: Felt252,
+        paid_fee_on_l1: Option<Felt252>,
+    ) -> Result<Self, TransactionError> {
+        L1Handler::new_with_tx_hash(
+            Address(Felt252::from_bytes_be(tx.contract_address.0.key().bytes())),
+            Felt252::from_bytes_be(tx.entry_point_selector.0.bytes()),
+            tx.calldata
+                .0
+                .as_ref()
+                .iter()
+                .map(|f| Felt252::from_bytes_be(f.bytes()))
+                .collect(),
+            Felt252::from_bytes_be(tx.nonce.0.bytes()),
+            paid_fee_on_l1,
+            tx_hash,
+        )
+    }
 }
 
 #[cfg(test)]