Align with spec for RPC v0.10.0 (#890)

* Align with spec for emitted events

* Migrate starknet-rs crates

* Fix spec

* Bump blockifier

* starknet-rust 0.18 bump

Author: 3alpha

Cargo.lock

@@ -78,14 +78,16 @@ bigdecimal = { version = "0.4.9" }
 enum-helper-macros = "0.0.1"
 
 # Starknet dependencies
-starknet-types-core = "=0.2.3"
-starknet_api = { version = "0.16.0-rc.1", features = ["testing"] }
-blockifier = { version = "0.16.0-rc.1" }
-starknet-rs-signers = { version = "0.14.0", package = "starknet-signers" }
-starknet-rs-core = { version = "0.16.0", package = "starknet-core" }
-starknet-rs-providers = { version = "0.16.0", package = "starknet-providers" }
-starknet-rs-accounts = { version = "0.16.0", package = "starknet-accounts" }
-starknet-rs-contract = { version = "0.16.0", package = "starknet-contract" }
+starknet-types-core = "=0.2.4"
+starknet_api = { version = "0.16.0-rc.2", features = ["testing"] }
+blockifier = { version = "0.16.0-rc.2" }
+
+starknet-rs-signers = { version = "0.15.0", package = "starknet-rust-signers" }
+starknet-rs-core = { version = "0.17.0", package = "starknet-rust-core" }
+starknet-rs-providers = { version = "0.17.0", package = "starknet-rust-providers" }
+starknet-rs-accounts = { version = "0.17.0", package = "starknet-rust-accounts" }
+starknet-rs-contract = { version = "0.17.0", package = "starknet-rust-contract" }
+
 cairo-vm = "=2.5.0"
 
 # Cairo-lang dependencies

Cargo.toml

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use indexmap::IndexMap;
 use starknet_api::block::{BlockHeader, BlockHeaderWithoutHash, BlockNumber, BlockTimestamp};
+use starknet_api::block_hash::block_hash_calculator::BlockHeaderCommitments;
 use starknet_api::data_availability::L1DataAvailabilityMode;
 use starknet_api::felt;
 use starknet_rs_core::types::Felt;
@@ -329,6 +330,13 @@ impl From<&StarknetBlock> for starknet_types::rpc::block::BlockHeader {
                     .0
                     .into(),
             },
+            n_transactions: value.header.n_transactions as u64,
+            n_events: value.header.n_events as u64,
+            state_diff_length: value.header.state_diff_length.unwrap_or(0) as u64,
+            state_diff_commitment: value.header.state_diff_commitment.unwrap_or_default(),
+            transaction_commitment: value.header.transaction_commitment.unwrap_or_default(),
+            event_commitment: value.header.event_commitment.unwrap_or_default(),
+            receipt_commitment: value.header.receipt_commitment.unwrap_or_default(),
         }
     }
 }
@@ -403,6 +411,24 @@ impl StarknetBlock {
     pub(crate) fn set_timestamp(&mut self, timestamp: BlockTimestamp) {
         self.header.block_header_without_hash.timestamp = timestamp;
     }
+
+    pub(crate) fn set_counts(
+        &mut self,
+        n_transactions: usize,
+        n_events: usize,
+        state_diff_length: usize,
+    ) {
+        self.header.n_transactions = n_transactions;
+        self.header.n_events = n_events;
+        self.header.state_diff_length = Some(state_diff_length);
+    }
+
+    pub(crate) fn set_commitments(&mut self, commitments: BlockHeaderCommitments) {
+        self.header.transaction_commitment = Some(commitments.transaction_commitment);
+        self.header.event_commitment = Some(commitments.event_commitment);
+        self.header.receipt_commitment = Some(commitments.receipt_commitment);
+        self.header.state_diff_commitment = Some(commitments.state_diff_commitment);
+    }
 }
 
 impl HashProducer for StarknetBlock {

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

@@ -80,8 +80,8 @@ pub(crate) fn get_events(
 
                 let emitted_event = EmittedEvent {
                     transaction_hash: *transaction_hash,
-                    transaction_index: Some(transaction_index as u64),
-                    event_index: Some(event_index as u64),
+                    transaction_index: transaction_index as u64,
+                    event_index: event_index as u64,
                     block_hash,
                     block_number,
                     keys: transaction_event.keys,

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

@@ -16,8 +16,10 @@ use starknet_api::block::{
     BlockInfo, BlockNumber, BlockTimestamp, FeeType, GasPrice, GasPricePerToken, GasPriceVector,
     GasPrices,
 };
+use starknet_api::block_hash::block_hash_calculator::calculate_block_commitments;
 use starknet_api::core::SequencerContractAddress;
 use starknet_api::data_availability::DataAvailabilityMode;
+use starknet_api::state::ThinStateDiff as ThinStateDiffImported;
 use starknet_api::transaction::fields::{GasVectorComputationMode, Tip};
 use starknet_api::transaction::{TransactionHasher, TransactionVersion};
 use starknet_rs_core::types::{Felt, Hash256, MsgFromL1};
@@ -372,6 +374,9 @@ impl Starknet {
         // Update gas prices in the block header
         let header = &mut new_block.header.block_header_without_hash;
 
+        let starknet_version = header.starknet_version;
+        let l1_da_mode = header.l1_da_mode;
+
         // Set L1 gas prices
         header.l1_gas_price = GasPricePerToken {
             price_in_fri: GasPrice(self.next_block_gas.gas_price_fri.get()),
@@ -417,6 +422,33 @@ impl Starknet {
             }
         });
 
+        let transaction_data: Vec<
+            starknet_api::block_hash::block_hash_calculator::TransactionHashingData,
+        > = new_block
+            .get_transactions()
+            .iter()
+            // filter map is used here, although in normal conditions unwrap should be safe. Every transaction hash that has been added to preconfirmed block should be present in transactions collection
+            // changes should be done later so this is not even possible
+            .filter_map(|tx_hash| self.transactions.get_by_hash(*tx_hash))
+            .map(|tx| tx.into())
+            .collect();
+
+        let thin_state_diff: ThinStateDiffImported = self.pre_confirmed_state_diff.clone().into();
+
+        let commitments = calculate_block_commitments(
+            &transaction_data,
+            &thin_state_diff,
+            l1_da_mode,
+            &starknet_version,
+        );
+
+        new_block.set_counts(
+            transaction_data.len(),
+            transaction_data.iter().map(|tx| tx.transaction_output.events.len()).sum(),
+            thin_state_diff.len(),
+        );
+        new_block.set_commitments(commitments);
+
         // insert pre_confirmed block in the blocks collection and connect it to the state diff
         self.blocks.insert(new_block, self.pre_confirmed_state_diff.clone());
         self.pre_confirmed_state_diff = StateDiff::default();
@@ -1992,29 +2024,6 @@ mod tests {
         assert_eq!(block_number2.0, added_block2.header.block_header_without_hash.block_number.0);
     }
 
-    #[test]
-    fn gets_block_txs_count() {
-        let config = StarknetConfig::default();
-        let mut starknet = Starknet::new(&config).unwrap();
-
-        starknet.generate_new_block_and_state().unwrap();
-
-        let num_no_transactions = starknet.get_block_txs_count(&CustomBlockId::Number(1));
-
-        assert_eq!(num_no_transactions.unwrap(), 0);
-
-        let tx = dummy_declare_tx_v3_with_hash();
-
-        // add transaction hash to pre_confirmed block
-        starknet.blocks.pre_confirmed_block.add_transaction(*tx.get_transaction_hash());
-
-        starknet.generate_new_block_and_state().unwrap();
-
-        let num_one_transaction = starknet.get_block_txs_count(&CustomBlockId::Number(2));
-
-        assert_eq!(num_one_transaction.unwrap(), 1);
-    }
-
     #[test]
     fn returns_chain_id() {
         let config = StarknetConfig::default();

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

@@ -176,6 +176,63 @@ impl From<StateDiff> for ThinStateDiff {
         }
     }
 }
+
+impl From<StateDiff> for starknet_api::state::ThinStateDiff {
+    fn from(value: StateDiff) -> Self {
+        let deployed_contracts: Vec<(ContractAddress, Felt)> =
+            value.address_to_class_hash.into_iter().collect();
+        let nonces: Vec<(ContractAddress, Felt)> = value.address_to_nonce.into_iter().collect();
+
+        starknet_api::state::ThinStateDiff {
+            deployed_contracts: deployed_contracts
+                .into_iter()
+                .map(|(address, class_hash)| {
+                    (
+                        starknet_api::core::ContractAddress::from(address),
+                        starknet_api::core::ClassHash(class_hash),
+                    )
+                })
+                .collect(),
+            storage_diffs: value
+                .storage_updates
+                .into_iter()
+                .map(|(contract_address, updates)| {
+                    (
+                        starknet_api::core::ContractAddress::from(contract_address),
+                        updates
+                            .into_iter()
+                            .map(|(key, value)| (starknet_api::state::StorageKey::from(key), value))
+                            .collect(),
+                    )
+                })
+                .collect(),
+            class_hash_to_compiled_class_hash: value
+                .class_hash_to_compiled_class_hash
+                .into_iter()
+                .map(|(class_hash, compiled_class_hash)| {
+                    (
+                        starknet_api::core::ClassHash(class_hash),
+                        starknet_api::core::CompiledClassHash(compiled_class_hash),
+                    )
+                })
+                .collect(),
+            deprecated_declared_classes: value
+                .cairo_0_declared_contracts
+                .iter()
+                .map(|f| starknet_api::core::ClassHash(*f))
+                .collect(),
+            nonces: nonces
+                .into_iter()
+                .map(|(address, nonce)| {
+                    (
+                        starknet_api::core::ContractAddress::from(address),
+                        starknet_api::core::Nonce(nonce),
+                    )
+                })
+                .collect(),
+        }
+    }
+}
 #[cfg(test)]
 mod tests {
     use std::collections::HashMap;

crates/starknet-devnet-core/src/state/state_diff.rs

@@ -240,13 +240,81 @@ impl StarknetTransaction {
     }
 }
 
+impl From<&StarknetTransaction>
+    for starknet_api::block_hash::block_hash_calculator::TransactionHashingData
+{
+    fn from(tx: &StarknetTransaction) -> Self {
+        Self {
+            transaction_signature: starknet_api::transaction::fields::TransactionSignature(
+                tx.inner.get_signature().into(),
+            ),
+            transaction_hash: starknet_api::transaction::TransactionHash(
+                *tx.inner.get_transaction_hash(),
+            ),
+            transaction_output:
+                starknet_api::block_hash::block_hash_calculator::TransactionOutputForHash {
+                    actual_fee: tx.execution_info.receipt.fee,
+                    events: tx
+                        .get_events()
+                        .iter()
+                        .map(|f| starknet_api::transaction::Event {
+                            from_address: f.from_address.into(),
+                            content: starknet_api::transaction::EventContent {
+                                keys: f
+                                    .keys
+                                    .iter()
+                                    .map(|k| starknet_api::transaction::EventKey(*k))
+                                    .collect(),
+                                data: starknet_api::transaction::EventData(f.data.to_vec()),
+                            },
+                        })
+                        .collect(),
+                    execution_status: match &tx.execution_result {
+                        starknet_rs_core::types::ExecutionResult::Succeeded => {
+                            starknet_api::transaction::TransactionExecutionStatus::Succeeded
+                        }
+                        starknet_rs_core::types::ExecutionResult::Reverted { reason } => {
+                            starknet_api::transaction::TransactionExecutionStatus::Reverted(
+                                starknet_api::transaction::RevertedTransactionExecutionStatus {
+                                    revert_reason: reason.to_string(),
+                                },
+                            )
+                        }
+                    },
+                    gas_consumed: tx.execution_info.receipt.gas,
+                    messages_sent: tx
+                        .get_l2_to_l1_messages()
+                        .into_iter()
+                        .map(|msg| {
+                            let to_address_felt: starknet_rs_core::types::Felt =
+                                msg.to_address.into();
+                            starknet_api::transaction::MessageToL1 {
+                                to_address: starknet_api::core::EthAddress::try_from(
+                                    to_address_felt,
+                                )
+                                .unwrap_or_default(), /* Default should never happen, felt is
+                                                       * used just as a helper for type
+                                                       * conversions */
+                                payload: starknet_api::transaction::L2ToL1Payload(
+                                    msg.payload.to_vec(),
+                                ),
+                                from_address: msg.from_address.into(),
+                            }
+                        })
+                        .collect(),
+                },
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use blockifier::blockifier_versioned_constants::VersionedConstants;
     use blockifier::state::cached_state::CachedState;
     use blockifier::transaction::objects::TransactionExecutionInfo;
     use starknet_api::block::BlockNumber;
     use starknet_api::transaction::fields::GasVectorComputationMode;
+    use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
     use starknet_rs_core::types::TransactionExecutionStatus;
     use starknet_types::rpc::transactions::{
         TransactionFinalityStatus, TransactionTrace, TransactionWithHash,

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

@@ -2,6 +2,7 @@ use blockifier::blockifier_versioned_constants::VersionedConstants;
 use blockifier::bouncer::{BouncerConfig, BouncerWeights, BuiltinWeights};
 use blockifier::transaction::objects::TransactionExecutionInfo;
 use starknet_api::block::StarknetVersion;
+use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
 use starknet_rs_core::types::Felt;
 use starknet_types::patricia_key::{PatriciaKey, StorageKey};
 

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

@@ -10,7 +10,11 @@ use starknet_types::felt::TransactionHash;
 use starknet_types::rpc::block::{BlockHeader, BlockId, BlockStatus, BlockTag};
 use starknet_types::rpc::transactions::TransactionFinalityStatus;
 use starknet_types::starknet_api::block::{BlockNumber, BlockTimestamp};
+use starknet_types::starknet_api::core::{
+    EventCommitment, ReceiptCommitment, StateDiffCommitment, TransactionCommitment,
+};
 use starknet_types::starknet_api::data_availability::L1DataAvailabilityMode;
+use starknet_types::starknet_api::hash::PoseidonHash;
 
 use super::JsonRpcHandler;
 use super::error::ApiError;
@@ -87,6 +91,17 @@ impl JsonRpcHandler {
                         }
                         ImportedL1DataAvailabilityMode::Blob => L1DataAvailabilityMode::Blob,
                     },
+                    n_transactions: origin_block.transaction_count,
+                    n_events: origin_block.event_count,
+                    state_diff_length: origin_block.state_diff_length,
+                    state_diff_commitment: StateDiffCommitment(PoseidonHash(
+                        origin_block.state_diff_commitment,
+                    )),
+                    transaction_commitment: TransactionCommitment(
+                        origin_block.transaction_commitment,
+                    ),
+                    event_commitment: EventCommitment(origin_block.event_commitment),
+                    receipt_commitment: ReceiptCommitment(origin_block.receipt_commitment),
                 };
                 Ok(origin_header)
             }

crates/starknet-devnet-server/src/api/endpoints_ws.rs

@@ -43,7 +43,10 @@ pub async fn serve_http_json_rpc(
     };
 
     routes = routes
-        .layer(TimeoutLayer::new(Duration::from_secs(server_config.timeout.into())))
+        .layer(TimeoutLayer::with_status_code(
+            StatusCode::REQUEST_TIMEOUT,
+            Duration::from_secs(server_config.timeout.into()),
+        ))
         .layer(DefaultBodyLimit::disable())
         .layer(
             // More details: https://docs.rs/tower-http/latest/tower_http/cors/index.html