Update JSON-RPC to v0.8.0

Cargo.toml

@@ -29,7 +29,7 @@ keywords = ["starknet", "cairo", "testnet", "local", "server"]
 [workspace.dependencies]
 
 # axum
-axum = { version = "0.7" }
+axum = { version = "0.7", features = ["ws"] }
 http-body-util = { version = "0.1" }
 tower-http = { version = "0.5", features = ["full"] }
 
@@ -107,6 +107,7 @@ unsafe-libyaml = "0.2.10"
 h2 = "0.4"
 
 ethers = { version = "2.0.11" }
+cargo-platform = "=0.1.8"        # 0.1.9 is incompatible with rustc 1.76.0
 
 openssl = { version = "0.10", features = ["vendored"] }
 
@@ -116,6 +117,7 @@ parking_lot = "0.12.3"
 serial_test = "3.1.1"
 hex = "0.4.3"
 lazy_static = { version = "1.4.0" }
+tokio-tungstenite = { version = "0.21.0" }
 listeners = "0.2.1"
 
 # https://github.com/paritytech/parity-scale-codec/issues/656

contracts/test_artifacts/cairo1/panicking_contract/compilation_info.txt

@@ -1 +1 @@
-Compiled using cairo 2.2.0
+Compiled using cairo 2.8.0

contracts/test_artifacts/cairo1/panicking_contract/panicking_contract.cairo

@@ -1,17 +1,30 @@
+use core::starknet::ContractAddress;
+
 #[starknet::interface]
 trait IPanickingContract<TContractState> {
    fn create_panic(self: @TContractState, panic_reason: felt252);
+   fn create_panic_in_another_contract(self: @TContractState, address: ContractAddress, panic_reason: felt252);
 }
 
 #[starknet::contract]
 mod PanickingContract {
+   use core::starknet::{ContractAddress, call_contract_syscall};
+
    #[storage]
    struct Storage {}
 
-   #[external(v0)]
+   #[abi(embed_v0)]
    impl PanickingContract of super::IPanickingContract<ContractState> {
       fn create_panic(self: @ContractState, panic_reason: felt252) {
          panic_with_felt252(panic_reason);
       }
+
+      fn create_panic_in_another_contract(self: @ContractState, address: ContractAddress, panic_reason: felt252) {
+         call_contract_syscall(
+            address,
+            selector!("create_panic"),
+            array![panic_reason].span()
+         ).unwrap();
+      }
    }
 }

crates/starknet-devnet-core/Cargo.toml

@@ -11,6 +11,7 @@ description = "Starknet core logic for devnet"
 [dependencies]
 blockifier = { workspace = true, features = ["testing"] }
 cairo-lang-starknet-classes = { workspace = true }
+cairo-vm = { workspace = true }
 clap = { workspace = true }
 ethers = { workspace = true }
 starknet_api = { workspace = true, features = ["testing"] }
@@ -28,7 +29,6 @@ tracing = { workspace = true }
 indexmap = { workspace = true }
 url = { workspace = true }
 nonzero_ext = { workspace = true }
-usc = { workspace = true }
 parking_lot = { workspace = true }
 
 # necessary for installing reqwest in Docker

crates/starknet-devnet-core/src/blocks/mod.rs

@@ -267,6 +267,14 @@ impl StarknetBlock {
         }
     }
 
+    pub fn create_empty_accepted() -> Self {
+        Self {
+            header: BlockHeader::default(),
+            transaction_hashes: vec![],
+            status: BlockStatus::AcceptedOnL2,
+        }
+    }
+
     pub(crate) fn set_block_number(&mut self, block_number: u64) {
         self.header.block_number = BlockNumber(block_number)
     }

crates/starknet-devnet-core/src/error.rs

@@ -8,6 +8,8 @@ use starknet_types::contract_address::ContractAddress;
 use starknet_types::contract_storage_key::ContractStorageKey;
 use thiserror::Error;
 
+use crate::stack_trace::{gen_tx_execution_error_trace, ErrorStack};
+
 #[derive(Error, Debug)]
 pub enum Error {
     #[error(transparent)]
@@ -16,12 +18,10 @@ pub enum Error {
     StateError(#[from] StateError),
     #[error(transparent)]
     BlockifierStateError(#[from] blockifier::state::errors::StateError),
-    #[error(transparent)]
-    BlockifierTransactionError(TransactionExecutionError),
-    #[error(transparent)]
-    BlockifierExecutionError(#[from] blockifier::execution::errors::EntryPointExecutionError),
-    #[error("{execution_error}")]
-    ExecutionError { execution_error: String, index: usize },
+    #[error("{0:?}")]
+    ContractExecutionError(ErrorStack),
+    #[error("Execution error in simulating transaction no. {failure_index}: {error_stack:?}")]
+    ContractExecutionErrorInSimulation { failure_index: usize, error_stack: ErrorStack },
     #[error("Types error: {0}")]
     TypesError(#[from] starknet_types::error::Error),
     #[error("I/O error: {0}")]
@@ -96,8 +96,8 @@ pub enum StateError {
 
 #[derive(Debug, Error)]
 pub enum TransactionValidationError {
-    #[error("Provided max fee is not enough to cover the transaction cost.")]
-    InsufficientMaxFee,
+    #[error("The transaction's resources don't cover validation or the minimal transaction fee.")]
+    InsufficientResourcesForValidate,
     #[error("Account transaction nonce is invalid.")]
     InvalidTransactionNonce,
     #[error("Account balance is not enough to cover the transaction cost.")]
@@ -123,7 +123,7 @@ impl From<TransactionExecutionError> for Error {
             err @ TransactionExecutionError::DeclareTransactionError { .. } => {
                 Error::ClassAlreadyDeclared { msg: err.to_string() }
             }
-            other => Self::BlockifierTransactionError(other),
+            other => Self::ContractExecutionError(gen_tx_execution_error_trace(&other)),
         }
     }
 }
@@ -132,7 +132,7 @@ impl From<FeeCheckError> for Error {
     fn from(value: FeeCheckError) -> Self {
         match value {
             FeeCheckError::MaxL1GasAmountExceeded { .. } | FeeCheckError::MaxFeeExceeded { .. } => {
-                TransactionValidationError::InsufficientMaxFee.into()
+                TransactionValidationError::InsufficientResourcesForValidate.into()
             }
             FeeCheckError::InsufficientFeeTokenBalance { .. } => {
                 TransactionValidationError::InsufficientAccountBalance.into()
@@ -148,7 +148,7 @@ impl From<TransactionFeeError> for Error {
             | TransactionFeeError::MaxFeeTooLow { .. }
             | TransactionFeeError::MaxL1GasPriceTooLow { .. }
             | TransactionFeeError::MaxL1GasAmountTooLow { .. } => {
-                TransactionValidationError::InsufficientMaxFee.into()
+                TransactionValidationError::InsufficientResourcesForValidate.into()
             }
             TransactionFeeError::MaxFeeExceedsBalance { .. }
             | TransactionFeeError::L1GasBoundsExceedBalance { .. } => {

crates/starknet-devnet-core/src/lib.rs

@@ -6,6 +6,7 @@ pub mod error;
 pub mod messaging;
 mod predeployed_accounts;
 pub mod raw_execution;
+pub mod stack_trace;
 pub mod starknet;
 mod state;
 mod system_contract;
@@ -18,3 +19,4 @@ mod utils;
 pub mod utils;
 
 pub use blocks::StarknetBlock;
+pub use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;

crates/starknet-devnet-core/src/messaging/ethereum.rs

@@ -7,7 +7,7 @@ use ethers::prelude::*;
 use ethers::providers::{Http, Provider, ProviderError};
 use ethers::types::{Address, BlockNumber, Log};
 use k256::ecdsa::SigningKey;
-use starknet_rs_core::types::Felt;
+use starknet_rs_core::types::{Felt, Hash256};
 use starknet_types::felt::felt_from_prefixed_hex;
 use starknet_types::rpc::contract_address::ContractAddress;
 use starknet_types::rpc::messaging::{MessageToL1, MessageToL2};
@@ -302,6 +302,7 @@ impl EthereumMessaging {
 ///
 /// * `log` - The log to be converted.
 pub fn message_to_l2_from_log(log: Log) -> DevnetResult<MessageToL2> {
+    let l1_transaction_hash = log.transaction_hash.map(|h| Hash256::from_bytes(h.to_fixed_bytes()));
     let parsed_log = <LogMessageToL2 as EthLogDecode>::decode_log(&log.into()).map_err(|e| {
         Error::MessagingError(MessagingError::EthersError(format!("Log parsing failed {}", e)))
     })?;
@@ -318,6 +319,7 @@ pub fn message_to_l2_from_log(log: Log) -> DevnetResult<MessageToL2> {
     }
 
     Ok(MessageToL2 {
+        l1_transaction_hash,
         l2_contract_address: contract_address,
         entry_point_selector,
         l1_contract_address: ContractAddress::new(from_address)?,
@@ -405,6 +407,7 @@ mod tests {
         };
 
         let expected_message = MessageToL2 {
+            l1_transaction_hash: None,
             l1_contract_address: ContractAddress::new(
                 felt_from_prefixed_hex(from_address).unwrap(),
             )

crates/starknet-devnet-core/src/messaging/mod.rs

@@ -32,7 +32,8 @@
 //! contract (`mockSendMessageFromL2` entrypoint).
 use std::collections::HashMap;
 
-use starknet_rs_core::types::{BlockId, ExecutionResult, Hash256};
+use ethers::types::H256;
+use starknet_rs_core::types::{BlockId, ExecutionResult, Felt, Hash256};
 use starknet_types::rpc::messaging::{MessageToL1, MessageToL2};
 
 use crate::error::{DevnetResult, Error, MessagingError};
@@ -54,13 +55,11 @@ pub struct MessagingBroker {
     /// For each time a message is supposed to be sent to L1, it is stored in this
     /// queue. The user may consume those messages using `consume_message_from_l2`
     /// to actually test `MessageToL1` emitted without running L1 node.
-    ///
-    /// Note:
-    /// `Hash256` is not directly supported as a HashMap key due to missing trait.
-    /// Using `String` instead.
-    pub l2_to_l1_messages_hashes: HashMap<String, u64>,
+    pub l2_to_l1_messages_hashes: HashMap<H256, u64>,
     /// This list of messages that will be sent to L1 node at the next `postman/flush`.
     pub l2_to_l1_messages_to_flush: Vec<MessageToL1>,
+    /// Mapping of L1 transaction hash to a chronological sequence of generated L2 transactions.
+    pub l1_to_l2_tx_hashes: HashMap<H256, Vec<Felt>>,
 }
 
 impl MessagingBroker {
@@ -142,7 +141,7 @@ impl Starknet {
                 }
 
                 for message in &messages {
-                    let hash = format!("{}", message.hash());
+                    let hash = H256(*message.hash().as_bytes());
                     let count = self.messaging.l2_to_l1_messages_hashes.entry(hash).or_insert(0);
                     *count += 1;
                 }
@@ -188,14 +187,14 @@ impl Starknet {
         // Ensure latest messages are collected before consuming the message.
         self.collect_messages_to_l1().await?;
 
-        let hash = format!("{}", message.hash());
-        let count = self.messaging.l2_to_l1_messages_hashes.entry(hash.clone()).or_insert(0);
+        let hash = H256(*message.hash().as_bytes());
+        let count = self.messaging.l2_to_l1_messages_hashes.entry(hash).or_insert(0);
 
         if *count > 0 {
             *count -= 1;
             Ok(message.hash())
         } else {
-            Err(Error::MessagingError(MessagingError::MessageToL1NotPresent(hash)))
+            Err(Error::MessagingError(MessagingError::MessageToL1NotPresent(hash.to_string())))
         }
     }