refactor(katana): decouple katana-primitives from any executor impls (

#1637)

Cargo.toml

@@ -99,7 +99,6 @@ anyhow = "1.0.75"
 assert_matches = "1.5.0"
 async-trait = "0.1.68"
 base64 = "0.21.2"
-blockifier = { git = "https://github.com/starkware-libs/blockifier", tag = "v0.4.0-rc9.2" }
 cairo-lang-compiler = "=2.5.4"
 cairo-lang-debug = "=2.5.4"
 cairo-lang-defs = "=2.5.4"
@@ -186,9 +185,6 @@ wasm-prost = { version = "0.11.9", package = "prost" }
 wasm-tonic = { version = "0.9.2", default-features = false, features = [ "codegen", "gzip", "prost" ], package = "tonic" }
 wasm-tonic-build = { version = "0.9.2", default-features = false, features = [ "prost" ], package = "tonic-build" }
 
-[patch."https://github.com/starkware-libs/blockifier"]
-blockifier = { git = "https://github.com/dojoengine/blockifier", rev = "d38b979" }
-
 [patch.crates-io]
 cairo-felt = { git = "https://github.com/dojoengine/cairo-rs.git", rev = "1031381" }
 cairo-vm = { git = "https://github.com/dojoengine/cairo-rs.git", rev = "1031381" }

crates/katana/core/Cargo.toml

@@ -15,7 +15,6 @@ katana-tasks.workspace = true
 
 anyhow.workspace = true
 async-trait.workspace = true
-blockifier.workspace = true
 cairo-lang-casm = "2.3.1"
 cairo-lang-starknet = "2.3.1"
 cairo-vm.workspace = true

crates/katana/core/src/sequencer_error.rs

@@ -1,5 +1,3 @@
-use blockifier::execution::errors::EntryPointExecutionError;
-use blockifier::transaction::errors::TransactionExecutionError;
 use katana_primitives::block::BlockIdOrTag;
 use katana_primitives::contract::ContractAddress;
 use katana_primitives::event::ContinuationTokenError;
@@ -13,10 +11,6 @@ pub enum SequencerError {
     ContractNotFound(ContractAddress),
     #[error("State for block {0:?} not found.")]
     StateNotFound(BlockIdOrTag),
-    #[error(transparent)]
-    TransactionExecution(#[from] TransactionExecutionError),
-    #[error(transparent)]
-    EntryPointExecution(#[from] EntryPointExecutionError),
     #[error("Wait for pending transactions.")]
     PendingTransactions,
     #[error(transparent)]

crates/katana/executor/Cargo.toml

@@ -20,7 +20,8 @@ thiserror.workspace = true
 tracing.workspace = true
 
 # blockifier deps
-blockifier = { workspace = true, optional = true }
+blockifier = { git = "https://github.com/dojoengine/blockifier", rev = "d38b979", optional = true }
+cairo-vm = { workspace = true, optional = true }
 
 # starknet_in_rust deps
 cairo-lang-sierra = { workspace = true, optional = true }
@@ -40,6 +41,6 @@ tokio.workspace = true
 [features]
 default = [ "blockifier", "sir" ]
 
-blockifier = [ "dep:blockifier", "katana-primitives/blockifier" ]
+blockifier = [ "dep:blockifier", "dep:cairo-vm" ]
 native = [ "sir", "sir/cairo-native" ]
 sir = [ "dep:sir", "dep:starknet-types-core" ]

crates/katana/executor/src/implementation/blockifier/mod.rs

@@ -88,7 +88,8 @@ impl<'a> StarknetVMProcessor<'a> {
         self.block_context.block_info.block_timestamp = timestamp;
         self.block_context.block_info.gas_prices.eth_l1_gas_price = eth_l1_gas_price;
         self.block_context.block_info.gas_prices.strk_l1_gas_price = strk_l1_gas_price;
-        self.block_context.block_info.sequencer_address = header.sequencer_address.into();
+        self.block_context.block_info.sequencer_address =
+            utils::to_blk_address(header.sequencer_address);
     }
 }
 
@@ -179,7 +180,7 @@ impl<'a> abstraction::BlockExecutor<'a> for StarknetVMProcessor<'a> {
         BlockEnv {
             number: self.block_context.block_info.block_number.0,
             timestamp: self.block_context.block_info.block_timestamp.0,
-            sequencer_address: self.block_context.block_info.sequencer_address.into(),
+            sequencer_address: utils::to_address(self.block_context.block_info.sequencer_address),
             l1_gas_prices: GasPrices {
                 eth: self.block_context.block_info.gas_prices.eth_l1_gas_price,
                 strk: self.block_context.block_info.gas_prices.strk_l1_gas_price,

crates/katana/executor/src/implementation/blockifier/output.rs

@@ -10,6 +10,7 @@ use katana_primitives::receipt::{
 use katana_primitives::transaction::Tx;
 use katana_primitives::FieldElement;
 
+use super::utils;
 use crate::TransactionExecutionOutput;
 
 #[derive(Debug, Default)]
@@ -83,7 +84,7 @@ fn events_from_exec_info(info: &TransactionExecutionInfo) -> Vec<Event> {
         let mut events: Vec<Event> = vec![];
 
         events.extend(call_info.execution.events.iter().map(|e| Event {
-            from_address: call_info.call.storage_address.into(),
+            from_address: utils::to_address(call_info.call.storage_address),
             data: e.event.data.0.iter().map(|d| (*d).into()).collect(),
             keys: e.event.keys.iter().map(|k| k.0.into()).collect(),
         }));

crates/katana/executor/src/implementation/blockifier/state.rs

@@ -5,7 +5,7 @@ use blockifier::state::cached_state::{self, GlobalContractCache};
 use blockifier::state::errors::StateError;
 use blockifier::state::state_api::{StateReader, StateResult};
 use katana_primitives::class::{CompiledClass, FlattenedSierraClass};
-use katana_primitives::{conversion, FieldElement};
+use katana_primitives::FieldElement;
 use katana_provider::traits::contract::ContractClassProvider;
 use katana_provider::traits::state::StateProvider;
 use katana_provider::ProviderResult;
@@ -15,6 +15,7 @@ use starknet_api::hash::StarkHash;
 use starknet_api::patricia_key;
 use starknet_api::state::StorageKey;
 
+use super::utils::{self};
 use crate::StateProviderDb;
 
 /// A helper trait to enforce that a type must implement both [StateProvider] and [StateReader].
@@ -28,7 +29,7 @@ impl<'a> StateReader for StateProviderDb<'a> {
         contract_address: starknet_api::core::ContractAddress,
     ) -> StateResult<starknet_api::core::ClassHash> {
         self.0
-            .class_hash_of_contract(contract_address.into())
+            .class_hash_of_contract(utils::to_address(contract_address))
             .map(|v| ClassHash(v.unwrap_or_default().into()))
             .map_err(|e| StateError::StateReadError(e.to_string()))
     }
@@ -57,8 +58,8 @@ impl<'a> StateReader for StateProviderDb<'a> {
             .class(class_hash.0.into())
             .map_err(|e| StateError::StateReadError(e.to_string()))?
         {
-            let class = conversion::blockifier::to_class(class)
-                .map_err(|e| StateError::StateReadError(e.to_string()))?;
+            let class =
+                utils::to_class(class).map_err(|e| StateError::StateReadError(e.to_string()))?;
 
             Ok(class)
         } else {
@@ -71,7 +72,7 @@ impl<'a> StateReader for StateProviderDb<'a> {
         contract_address: starknet_api::core::ContractAddress,
     ) -> StateResult<starknet_api::core::Nonce> {
         self.0
-            .nonce(contract_address.into())
+            .nonce(utils::to_address(contract_address))
             .map(|n| Nonce(n.unwrap_or_default().into()))
             .map_err(|e| StateError::StateReadError(e.to_string()))
     }
@@ -82,7 +83,7 @@ impl<'a> StateReader for StateProviderDb<'a> {
         key: starknet_api::state::StorageKey,
     ) -> StateResult<starknet_api::hash::StarkFelt> {
         self.0
-            .storage(contract_address.into(), (*key.0.key()).into())
+            .storage(utils::to_address(contract_address), (*key.0.key()).into())
             .map(|v| v.unwrap_or_default().into())
             .map_err(|e| StateError::StateReadError(e.to_string()))
     }
@@ -162,7 +163,7 @@ impl<S: StateDb> StateProvider for CachedState<S> {
         &self,
         address: katana_primitives::contract::ContractAddress,
     ) -> ProviderResult<Option<katana_primitives::class::ClassHash>> {
-        let Ok(hash) = self.write().inner.get_class_hash_at(address.into()) else {
+        let Ok(hash) = self.write().inner.get_class_hash_at(utils::to_blk_address(address)) else {
             return Ok(None);
         };
 
@@ -174,7 +175,7 @@ impl<S: StateDb> StateProvider for CachedState<S> {
         &self,
         address: katana_primitives::contract::ContractAddress,
     ) -> ProviderResult<Option<katana_primitives::contract::Nonce>> {
-        let Ok(nonce) = self.write().inner.get_nonce_at(address.into()) else {
+        let Ok(nonce) = self.write().inner.get_nonce_at(utils::to_blk_address(address)) else {
             return Ok(None);
         };
         Ok(Some(nonce.0.into()))
@@ -185,7 +186,7 @@ impl<S: StateDb> StateProvider for CachedState<S> {
         address: katana_primitives::contract::ContractAddress,
         storage_key: katana_primitives::contract::StorageKey,
     ) -> ProviderResult<Option<katana_primitives::contract::StorageValue>> {
-        let address = address.into();
+        let address = utils::to_blk_address(address);
         let key = StorageKey(patricia_key!(storage_key));
 
         if let Ok(value) = self.write().inner.get_storage_at(address, key) {