Merge branch 'main' into refactor/provider

Author: kariy

Cargo.lock

@@ -484,7 +484,9 @@ impl StarknetCommands {
                             .collect::<Result<Vec<_>>>()?,
                     )
                 } else {
-                    None
+                    // temp: pathfinder expects an empty vector instead of an explicit null even
+                    // though the spec allows it
+                    Some(Vec::new())
                 };
 
                 // Parse contract_addresses if provided
@@ -502,15 +504,19 @@ impl StarknetCommands {
                             .collect::<Result<Vec<_>>>()?,
                     )
                 } else {
-                    None
+                    // temp: pathfinder expects an empty vector instead of an explicit null even
+                    // though the spec allows it
+                    Some(Vec::new())
                 };
 
                 // Parse contracts_storage_keys if provided
                 let contracts_storage_keys: Option<Vec<ContractStorageKeys>> =
                     if !args.storages.is_empty() {
                         Some(parse_contract_storage_keys(&args.storages)?)
                     } else {
-                        None
+                        // temp: pathfinder expects an empty vector instead of an explicit null even
+                        // though the spec allows it
+                        Some(Vec::new())
                     };
 
                 let result = client

bin/katana/src/cli/rpc/starknet.rs

@@ -285,38 +285,38 @@ mod impls {
         ProofLimitExceededData, TransactionExecutionErrorData, UnexpectedErrorData,
     };
 
-    impl From<ErrorObjectOwned> for StarknetApiError {
-        fn from(err: ErrorObjectOwned) -> Self {
+    impl StarknetApiError {
+        pub fn from_error_object(err: &ErrorObjectOwned) -> Option<Self> {
             match err.code() {
-                1 => Self::FailedToReceiveTxn,
-                20 => Self::ContractNotFound,
-                21 => Self::EntrypointNotFound,
-                22 => Self::InvalidCallData,
-                24 => Self::BlockNotFound,
-                27 => Self::InvalidTxnIndex,
-                28 => Self::ClassHashNotFound,
-                29 => Self::TxnHashNotFound,
+                1 => Some(Self::FailedToReceiveTxn),
+                20 => Some(Self::ContractNotFound),
+                21 => Some(Self::EntrypointNotFound),
+                22 => Some(Self::InvalidCallData),
+                24 => Some(Self::BlockNotFound),
+                27 => Some(Self::InvalidTxnIndex),
+                28 => Some(Self::ClassHashNotFound),
+                29 => Some(Self::TxnHashNotFound),
                 31 => {
                     if let Some(data) = err.data() {
                         if let Ok(data) = serde_json::from_str::<PageSizeTooBigData>(data.get()) {
-                            return Self::PageSizeTooBig(data);
+                            return Some(Self::PageSizeTooBig(data));
                         }
                     }
 
-                    Self::PageSizeTooBig(Default::default())
+                    Some(Self::PageSizeTooBig(Default::default()))
                 }
-                32 => Self::NoBlocks,
-                33 => Self::InvalidContinuationToken,
-                34 => Self::TooManyKeysInFilter,
-                38 => Self::FailedToFetchPendingTransactions,
+                32 => Some(Self::NoBlocks),
+                33 => Some(Self::InvalidContinuationToken),
+                34 => Some(Self::TooManyKeysInFilter),
+                38 => Some(Self::FailedToFetchPendingTransactions),
                 40 => {
                     let data = if let Some(data) = err.data() {
                         serde_json::from_str::<ContractErrorData>(data.get()).unwrap_or_default()
                     } else {
                         ContractErrorData::default()
                     };
 
-                    Self::ContractError(data)
+                    Some(Self::ContractError(data))
                 }
                 41 => {
                     let data = if let Some(data) = err.data() {
@@ -326,21 +326,21 @@ mod impls {
                         TransactionExecutionErrorData::default()
                     };
 
-                    Self::TransactionExecutionError(data)
+                    Some(Self::TransactionExecutionError(data))
                 }
                 42 => {
                     if let Some(data) = err.data() {
                         if let Ok(data) =
                             serde_json::from_str::<StorageProofNotSupportedData>(data.get())
                         {
-                            return Self::StorageProofNotSupported(data);
+                            return Some(Self::StorageProofNotSupported(data));
                         }
                     }
 
-                    Self::StorageProofNotSupported(StorageProofNotSupportedData::default())
+                    Some(Self::StorageProofNotSupported(StorageProofNotSupportedData::default()))
                 }
-                50 => Self::InvalidContractClass,
-                51 => Self::ClassAlreadyDeclared,
+                50 => Some(Self::InvalidContractClass),
+                51 => Some(Self::ClassAlreadyDeclared),
                 52 => {
                     let data = if let Some(value) = err.data() {
                         serde_json::from_str::<InvalidTransactionNonceData>(value.get())
@@ -349,10 +349,10 @@ mod impls {
                         InvalidTransactionNonceData::default()
                     };
 
-                    Self::InvalidTransactionNonce(data)
+                    Some(Self::InvalidTransactionNonce(data))
                 }
-                53 => Self::InsufficientResourcesForValidate,
-                54 => Self::InsufficientAccountBalance,
+                53 => Some(Self::InsufficientResourcesForValidate),
+                54 => Some(Self::InsufficientAccountBalance),
                 55 => {
                     let data = if let Some(data) = err.data() {
                         serde_json::from_str::<ValidationFailureData>(data.get())
@@ -361,36 +361,36 @@ mod impls {
                         ValidationFailureData::default()
                     };
 
-                    Self::ValidationFailure(data)
+                    Some(Self::ValidationFailure(data))
                 }
-                57 => Self::ContractClassSizeIsTooLarge,
-                58 => Self::NonAccount,
-                59 => Self::DuplicateTransaction,
-                60 => Self::CompiledClassHashMismatch,
-                61 => Self::UnsupportedTransactionVersion,
-                62 => Self::UnsupportedContractClassVersion,
+                57 => Some(Self::ContractClassSizeIsTooLarge),
+                58 => Some(Self::NonAccount),
+                59 => Some(Self::DuplicateTransaction),
+                60 => Some(Self::CompiledClassHashMismatch),
+                61 => Some(Self::UnsupportedTransactionVersion),
+                62 => Some(Self::UnsupportedContractClassVersion),
                 63 => {
                     let data = if let Some(data) = err.data() {
                         serde_json::from_str::<UnexpectedErrorData>(data.get()).unwrap_or_default()
                     } else {
                         UnexpectedErrorData::default()
                     };
 
-                    Self::UnexpectedError(data)
+                    Some(Self::UnexpectedError(data))
                 }
-                64 => Self::ReplacementTransactionUnderpriced,
-                65 => Self::FeeBelowMinimum,
-                66 => Self::InvalidSubscriptionId,
-                67 => Self::TooManyAddressesInFilter,
-                68 => Self::TooManyBlocksBack,
+                64 => Some(Self::ReplacementTransactionUnderpriced),
+                65 => Some(Self::FeeBelowMinimum),
+                66 => Some(Self::InvalidSubscriptionId),
+                67 => Some(Self::TooManyAddressesInFilter),
+                68 => Some(Self::TooManyBlocksBack),
                 100 => {
                     let data = if let Some(data) = err.data() {
                         serde_json::from_str::<CompilationErrorData>(data.get()).unwrap_or_default()
                     } else {
                         CompilationErrorData::default()
                     };
 
-                    Self::CompilationError(data)
+                    Some(Self::CompilationError(data))
                 }
                 1000 => {
                     let data = if let Some(data) = err.data() {
@@ -400,10 +400,10 @@ mod impls {
                         ProofLimitExceededData::default()
                     };
 
-                    Self::ProofLimitExceeded(data)
+                    Some(Self::ProofLimitExceeded(data))
                 }
 
-                _ => Self::unexpected(err),
+                _ => None,
             }
         }
     }

crates/rpc/rpc-api/src/error/starknet.rs

@@ -237,8 +237,15 @@ impl Client {
         contract_addresses: Option<Vec<ContractAddress>>,
         contracts_storage_keys: Option<Vec<ContractStorageKeys>>,
     ) -> Result<GetStorageProofResponse> {
+        // temp: pathfinder expects an empty vector instead of an explicit null even
+        // though the spec allows it
         self.client
-            .get_storage_proof(block_id, class_hashes, contract_addresses, contracts_storage_keys)
+            .get_storage_proof(
+                block_id,
+                Some(class_hashes.unwrap_or_default()),
+                Some(contract_addresses.unwrap_or_default()),
+                Some(contracts_storage_keys.unwrap_or_default()),
+            )
             .await
             .map_err(Into::into)
     }
@@ -319,7 +326,13 @@ pub enum Error {
 impl From<jsonrpsee::core::client::Error> for Error {
     fn from(err: jsonrpsee::core::client::Error) -> Self {
         match err {
-            jsonrpsee::core::client::Error::Call(err_obj) => Error::Starknet(err_obj.into()),
+            jsonrpsee::core::client::Error::Call(ref err_obj) => {
+                if let Some(sn_err) = StarknetApiError::from_error_object(err_obj) {
+                    Error::Starknet(sn_err)
+                } else {
+                    Error::Client(err)
+                }
+            }
             _ => Error::Client(err),
         }
     }

crates/rpc/rpc-client/src/starknet.rs

@@ -43,6 +43,7 @@ katana-chain-spec.workspace = true
 katana-contracts.workspace = true
 katana-runner.workspace = true
 
+similar-asserts.workspace = true
 alloy-primitives.workspace = true
 lazy_static.workspace = true
 rand.workspace = true

crates/storage/provider/provider/Cargo.toml

@@ -215,7 +215,7 @@ impl<Tx1: DbTx, Tx2: DbTxMut> StateProofProvider for LatestStateProvider<Tx1, Tx
             let result = self.fork_provider.backend.get_contracts_proofs(addresses, fork_point)?;
             let proofs = result.expect("proofs should exist for block");
 
-            Ok(proofs.classes_proof.nodes.into())
+            Ok(proofs.contracts_proof.nodes.into())
         } else {
             Err(ProviderError::StateProofNotSupported)
         }
@@ -476,7 +476,7 @@ impl<Tx1: DbTx, Tx2: DbTxMut> StateProofProvider for HistoricalStateProvider<Tx1
             .get_contracts_proofs(addresses, self.local_provider.block())?;
         let proofs = result.expect("block should exist");
 
-        Ok(proofs.classes_proof.nodes.into())
+        Ok(proofs.contracts_proof.nodes.into())
     }
 
     fn storage_multiproof(

crates/storage/provider/provider/src/providers/fork/state.rs

@@ -13,7 +13,7 @@ use katana_provider::api::transaction::{ReceiptProvider, TransactionProvider};
 use katana_provider::providers::fork::ForkedProvider;
 use katana_provider::ProviderError;
 use katana_rpc_client::starknet::Client as StarknetClient;
-use katana_rpc_types::Nodes;
+use katana_rpc_types::MerkleNode;
 
 const SEPOLIA_RPC_URL: &str = "https://api.cartridge.gg/x/starknet/sepolia";
 const FORK_BLOCK_NUMBER: u64 = 2888618;
@@ -298,14 +298,16 @@ async fn historical_fork_state() {
     assert!(result2.is_some());
 }
 
-#[ignore]
 #[tokio::test(flavor = "multi_thread")]
 async fn pre_fork_state_proof() {
     let starknet_client = StarknetClient::new(SEPOLIA_RPC_URL.try_into().unwrap());
 
     // always use the latest block number of the forked chain because most nodes may not support
     // proofs for too old blocks
-    let latest_block_number = starknet_client.block_number().await.unwrap().block_number;
+    //
+    // we take the previous block because there were some instances where the latest block was not
+    // available or supported by the node.
+    let latest_block_number = starknet_client.block_number().await.unwrap().block_number - 1;
     let provider = ForkedProvider::new_ephemeral(latest_block_number, starknet_client.clone());
 
     let state = provider.latest().unwrap();
@@ -318,18 +320,32 @@ async fn pre_fork_state_proof() {
         .await
         .unwrap();
 
-    assert_eq!(Nodes::from(proofs), expected_proofs.classes_proof.nodes);
+    // TODO: assert the nodes ordering - ensure they are in the same order. currently, pathfinder
+    // doesn't return the nodes in the same order as katana.
+    assert_eq!(proofs.0.len(), expected_proofs.classes_proof.nodes.len());
+    for expected_node in expected_proofs.classes_proof.nodes.0.into_iter() {
+        let node_hash = expected_node.node_hash;
+        let actual_node = proofs.0.get(&node_hash).cloned().map(MerkleNode::from);
+        assert_eq!(Some(expected_node.node), actual_node)
+    }
 
     let contracts =
-        vec![address!("0x0164b86b8fC5C0c84d3c53Bc95760F290420Ea2a32ed49A44fd046683a1CaAc2")];
+        vec![address!("0x04f4e29add19afa12c868ba1f4439099f225403ff9a71fe667eebb50e13518d3")];
     let proofs = state.contract_multiproof(contracts.clone()).unwrap();
 
     let expected_proofs = starknet_client
         .get_storage_proof(latest_block_number.into(), None, Some(contracts), None)
         .await
         .unwrap();
 
-    assert_eq!(Nodes::from(proofs), expected_proofs.classes_proof.nodes);
+    // TODO: assert the nodes ordering - ensure they are in the same order. currently, pathfinder
+    // doesn't return the nodes in the same order as katana.
+    assert_eq!(proofs.0.len(), expected_proofs.contracts_proof.nodes.len());
+    for expected_node in expected_proofs.contracts_proof.nodes.0.into_iter() {
+        let node_hash = expected_node.node_hash;
+        let actual_node = proofs.0.get(&node_hash).cloned().map(MerkleNode::from);
+        assert_eq!(Some(expected_node.node), actual_node)
+    }
 }
 
 #[tokio::test]