sync the code

CHANGELOG.md

@@ -3,6 +3,13 @@
 ## Next release
 
 - dev: make HasherT methods accept iterator rather than &[Felt] as argument
+
+## v0.8.0
+
+- feat: add `TransactionFilter<TxType>` to pallet-starknet `Config`
+- chore: remove `ignore` from
+  `storage_changes_should_revert_on_transaction_revert` test
+- dev: Implement tests for new rpc method starknet_getTransactionStatus
 - feat: actual estimate_fee added, brought back l1 messages and refactored
   simulate tx
 - dev: impl get_state_updates using get_transaction_re_execution_state_diff

Cargo.toml

@@ -77,7 +77,7 @@ incremental = true
 authors = ["Abdelhamid Bakhta <@abdelhamidbakhta>"]
 edition = "2021"
 repository = "https://github.com/keep-starknet-strange/madara/"
-version = "0.7.0"
+version = "0.8.0"
 
 [workspace.dependencies]
 # Substrate frame dependencies

crates/client/storage/src/lib.rs

@@ -1,6 +1,6 @@
 //! Storage overrides readers
 //!
-//! In order for the client to access on pallets chain data data it has to read from the storage.
+//! In order for the client to access on pallets chain data it has to read from the storage.
 //! This can be achieve either through the pallet runtime API or by indexing the storage directly.
 //! The `OverrideHandle` make it possible to use the later, more efficient way, while keeping the
 //! first one as a fallback.

crates/pallets/starknet/src/lib.rs

@@ -79,10 +79,10 @@ use mp_block::{Block as StarknetBlock, Header as StarknetHeader};
 use mp_chain_id::MADARA_CHAIN_ID;
 use mp_digest_log::MADARA_ENGINE_ID;
 use mp_felt::Felt252Wrapper;
-use mp_starknet_inherent::{InherentError, InherentType, STARKNET_INHERENT_IDENTIFIER};
+use mp_starknet_inherent::{InherentError, InherentType, L1GasPrices, STARKNET_INHERENT_IDENTIFIER};
 use mp_storage::{StarknetStorageSchemaVersion, PALLET_STARKNET_SCHEMA};
 use mp_transactions::execution::{
-    execute_l1_handler_transaction, run_non_revertible_transaction, run_revertible_transaction,
+    execute_l1_handler_transaction, run_non_revertible_transaction, run_revertible_transaction, TransactionFilter,
 };
 use mp_transactions::{get_transaction_nonce, get_transaction_sender_address};
 use sp_runtime::traits::UniqueSaturatedInto;
@@ -118,7 +118,6 @@ macro_rules! log {
 
 #[frame_support::pallet]
 pub mod pallet {
-    use mp_starknet_inherent::L1GasPrices;
 
     use super::*;
 
@@ -132,6 +131,12 @@ pub mod pallet {
     pub trait Config: frame_system::Config {
         /// The block time
         type TimestampProvider: Time;
+        /// Custom transaction filter for Invoke txs
+        type InvokeTransactionFilter: TransactionFilter<InvokeTransaction>;
+        /// Custom transaction filter for Declare txs
+        type DeclareTransactionFilter: TransactionFilter<DeclareTransaction>;
+        /// Custom transaction filter for DeployAccount txs
+        type DeployAccountTransactionFilter: TransactionFilter<DeployAccountTransaction>;
         /// A configuration for base priority of unsigned transactions.
         ///
         /// This is exposed so that it can be tuned for particular runtime, when
@@ -519,10 +524,20 @@ pub mod pallet {
 
             // Execute
             let tx_execution_infos = match transaction.tx.version() {
-                TransactionVersion::ZERO => {
-                    run_non_revertible_transaction(&transaction, &mut state, &block_context, true, charge_fee)
-                }
-                _ => run_revertible_transaction(&transaction, &mut state, &block_context, true, charge_fee),
+                TransactionVersion::ZERO => run_non_revertible_transaction::<_, _, T::InvokeTransactionFilter>(
+                    &transaction,
+                    &mut state,
+                    &block_context,
+                    true,
+                    charge_fee,
+                ),
+                _ => run_revertible_transaction::<_, _, T::InvokeTransactionFilter>(
+                    &transaction,
+                    &mut state,
+                    &block_context,
+                    true,
+                    charge_fee,
+                ),
             }
             .map_err(|e| {
                 log!(error, "Invoke transaction execution failed: {:?}", e);
@@ -576,12 +591,14 @@ pub mod pallet {
             let charge_fee = !<T as Config>::DisableTransactionFee::get();
 
             // Execute
-            let tx_execution_infos =
-                run_non_revertible_transaction(&transaction, &mut state, &Self::get_block_context(), true, charge_fee)
-                    .map_err(|e| {
-                        log!(error, "Declare transaction execution failed: {:?}", e);
-                        Error::<T>::TransactionExecutionFailed
-                    })?;
+            let tx_execution_infos = run_non_revertible_transaction::<_, _, T::DeclareTransactionFilter>(
+                &transaction,
+                &mut state,
+                &Self::get_block_context(),
+                true,
+                charge_fee,
+            )
+            .map_err(|_| Error::<T>::TransactionExecutionFailed)?;
 
             Self::emit_and_store_tx_and_fees_events(
                 transaction.tx_hash(),
@@ -626,12 +643,14 @@ pub mod pallet {
             let charge_fee = !<T as Config>::DisableTransactionFee::get();
 
             // Execute
-            let tx_execution_infos =
-                run_non_revertible_transaction(&transaction, &mut state, &Self::get_block_context(), true, charge_fee)
-                    .map_err(|e| {
-                        log!(error, "Deploy account transaction execution failed: {:?}", e);
-                        Error::<T>::TransactionExecutionFailed
-                    })?;
+            let tx_execution_infos = run_non_revertible_transaction::<_, _, T::DeployAccountTransactionFilter>(
+                &transaction,
+                &mut state,
+                &Self::get_block_context(),
+                true,
+                charge_fee,
+            )
+            .map_err(|_| Error::<T>::TransactionExecutionFailed)?;
 
             Self::emit_and_store_tx_and_fees_events(
                 transaction.tx_hash,
@@ -782,7 +801,7 @@ pub mod pallet {
                                 )),
                             ));
                         }
-                        // Happy path, were the the nonce is the current one,
+                        // Happy path, were the nonce is the current one,
                         // we validate the tx
                         _ => {
                             Self::validate_unsigned_tx(&transaction)?;

crates/pallets/starknet/src/simulations.rs

@@ -351,30 +351,32 @@ impl<T: Config> Pallet<T> {
         simulation_flags: &SimulationFlags,
     ) -> Result<TransactionExecutionInfo, TransactionExecutionError> {
         match transaction {
-            AccountTransaction::Declare(tx) => run_non_revertible_transaction(
-                tx,
-                state,
-                block_context,
-                simulation_flags.validate,
-                simulation_flags.charge_fee,
-            ),
-            AccountTransaction::DeployAccount(tx) => run_non_revertible_transaction(
+            AccountTransaction::Declare(tx) => run_non_revertible_transaction::<_, _, T::DeclareTransactionFilter>(
                 tx,
                 state,
                 block_context,
                 simulation_flags.validate,
                 simulation_flags.charge_fee,
             ),
+            AccountTransaction::DeployAccount(tx) => {
+                run_non_revertible_transaction::<_, _, T::DeployAccountTransactionFilter>(
+                    tx,
+                    state,
+                    block_context,
+                    simulation_flags.validate,
+                    simulation_flags.charge_fee,
+                )
+            }
             AccountTransaction::Invoke(tx) if tx.tx.version() == TransactionVersion::ZERO => {
-                run_non_revertible_transaction(
+                run_non_revertible_transaction::<_, _, T::InvokeTransactionFilter>(
                     tx,
                     state,
                     block_context,
                     simulation_flags.validate,
                     simulation_flags.charge_fee,
                 )
             }
-            AccountTransaction::Invoke(tx) => run_revertible_transaction(
+            AccountTransaction::Invoke(tx) => run_revertible_transaction::<_, _, T::InvokeTransactionFilter>(
                 tx,
                 state,
                 block_context,