Update spec reader tests

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

@@ -123,6 +123,8 @@ impl StarknetBlocks {
         // used IndexMap to keep elements in the order of the keys
         let mut filtered_blocks: IndexMap<Felt, &StarknetBlock> = IndexMap::new();
 
+        let pending_block_number = self.pending_block.block_number();
+
         let starting_block = if let Some(block_id) = from {
             // If the value for block number provided is not correct it will return None
             // So we have to return an error
@@ -141,23 +143,49 @@ impl StarknetBlocks {
             None
         };
 
+        fn does_block_number_matches_criteria(
+            current_block_number: BlockNumber,
+            starting_block: Option<BlockNumber>,
+            ending_block: Option<BlockNumber>,
+        ) -> bool {
+            match (starting_block, ending_block) {
+                (None, None) => true,
+                (Some(start), None) => current_block_number >= start,
+                (None, Some(end)) => current_block_number <= end,
+                (Some(start), Some(end)) => {
+                    current_block_number >= start && current_block_number <= end
+                }
+            }
+        }
+
+        let mut insert_pending_block_in_final_result = true;
         // iterate over the blocks and apply the filter
         // then insert the filtered blocks into the index map
         self.num_to_hash
             .iter()
-            .filter(|(current_block_number, _)| match (starting_block, ending_block) {
-                (None, None) => true,
-                (Some(start), None) => **current_block_number >= start,
-                (None, Some(end)) => **current_block_number <= end,
-                (Some(start), Some(end)) => {
-                    **current_block_number >= start && **current_block_number <= end
-                }
+            .filter(|(current_block_number, _)| {
+                does_block_number_matches_criteria(
+                    **current_block_number,
+                    starting_block,
+                    ending_block,
+                )
             })
-            .for_each(|(_, block_hash)| {
+            .for_each(|(block_number, block_hash)| {
+                if *block_number == pending_block_number {
+                    insert_pending_block_in_final_result = false;
+                }
                 filtered_blocks.insert(*block_hash, &self.hash_to_block[block_hash]);
             });
 
-        Ok(filtered_blocks.into_values().collect())
+        let mut result: Vec<&StarknetBlock> = filtered_blocks.into_values().collect();
+
+        if does_block_number_matches_criteria(pending_block_number, starting_block, ending_block)
+            && insert_pending_block_in_final_result
+        {
+            result.push(&self.pending_block);
+        }
+
+        Ok(result)
     }
 
     pub fn next_block_number(&self) -> BlockNumber {
@@ -187,6 +215,7 @@ impl From<&StarknetBlock> for TypesPendingBlockHeader {
                 price_in_fri: value.header.l1_data_gas_price.price_in_fri.0.into(),
                 price_in_wei: value.header.l1_data_gas_price.price_in_wei.0.into(),
             },
+            l2_gas_price: ResourcePrice { price_in_fri: Felt::ZERO, price_in_wei: Felt::ZERO },
             l1_da_mode: value.header.l1_da_mode,
         }
     }
@@ -210,6 +239,7 @@ impl From<&StarknetBlock> for TypesBlockHeader {
                 price_in_fri: value.header.l1_data_gas_price.price_in_fri.0.into(),
                 price_in_wei: value.header.l1_data_gas_price.price_in_wei.0.into(),
             },
+            l2_gas_price: ResourcePrice { price_in_fri: Felt::ZERO, price_in_wei: Felt::ZERO },
             l1_da_mode: value.header.l1_da_mode,
         }
     }
@@ -327,30 +357,37 @@ mod tests {
             block_to_insert.header.block_hash =
                 starknet_api::block::BlockHash(Felt::from(block_number as u128));
             blocks.insert(block_to_insert, StateDiff::default());
+            blocks.pending_block.header.block_number = BlockNumber(block_number).unchecked_next();
         }
 
-        let expected_block_numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        let expected_block_numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
 
-        for _ in 0..10 {
-            let block_numbers: Vec<u64> = blocks
-                .get_blocks(None, None)
-                .unwrap()
-                .iter()
-                .map(|block| block.block_number().0)
-                .collect();
-            assert_eq!(expected_block_numbers, block_numbers);
-        }
+        let block_numbers: Vec<u64> = blocks
+            .get_blocks(None, None)
+            .unwrap()
+            .iter()
+            .map(|block| block.block_number().0)
+            .collect();
+        assert_eq!(expected_block_numbers, block_numbers);
+
+        let expected_block_numbers = vec![7, 8, 9, 10, 11];
+
+        let block_numbers: Vec<u64> = blocks
+            .get_blocks(Some(BlockId::Number(7)), None)
+            .unwrap()
+            .iter()
+            .map(|block| block.block_number().0)
+            .collect();
+        assert_eq!(expected_block_numbers, block_numbers);
 
         let expected_block_numbers = vec![7, 8, 9, 10];
-        for _ in 0..10 {
-            let block_numbers: Vec<u64> = blocks
-                .get_blocks(Some(BlockId::Number(7)), None)
-                .unwrap()
-                .iter()
-                .map(|block| block.block_number().0)
-                .collect();
-            assert_eq!(expected_block_numbers, block_numbers);
-        }
+        let block_numbers: Vec<u64> = blocks
+            .get_blocks(Some(BlockId::Number(7)), Some(BlockId::Tag(BlockTag::Latest)))
+            .unwrap()
+            .iter()
+            .map(|block| block.block_number().0)
+            .collect();
+        assert_eq!(expected_block_numbers, block_numbers);
     }
 
     #[test]

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

@@ -155,11 +155,14 @@ fn estimate_transaction_fee<S: StateReader>(
         ),
     };
 
+    // TODO: change l2 fields logic
     Ok(FeeEstimateWrapper {
-        gas_consumed: Felt::from(gas_vector.l1_gas),
-        data_gas_consumed: Felt::from(gas_vector.l1_data_gas),
-        gas_price: Felt::from(gas_price),
-        data_gas_price: Felt::from(data_gas_price),
+        l1_gas_consumed: Felt::from(gas_vector.l1_gas),
+        l1_data_gas_consumed: Felt::from(gas_vector.l1_data_gas),
+        l1_gas_price: Felt::from(gas_price),
+        l1_data_gas_price: Felt::from(data_gas_price),
+        l2_gas_consumed: Felt::ZERO,
+        l2_gas_price: Felt::ZERO,
         overall_fee: Felt::from(total_fee.0),
         unit,
     })

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

@@ -1,3 +1,4 @@
+use starknet_api::block::BlockStatus;
 use starknet_rs_core::types::{BlockId, Felt};
 use starknet_types::contract_address::ContractAddress;
 use starknet_types::emitted_event::{EmittedEvent, Event};
@@ -61,11 +62,16 @@ pub(crate) fn get_events(
                         return Ok((events, true));
                     }
                 }
+                let (block_hash, block_number) = if block.status() == &BlockStatus::Pending {
+                    (None, None)
+                } else {
+                    (Some(block.block_hash()), Some(block.block_number()))
+                };
 
                 let emitted_event = EmittedEvent {
                     transaction_hash: *transaction_hash,
-                    block_hash: block.block_hash(),
-                    block_number: block.block_number(),
+                    block_hash,
+                    block_number,
                     keys: transaction_event.keys,
                     from_address: transaction_event.from_address,
                     data: transaction_event.data,
@@ -405,7 +411,14 @@ mod tests {
             starknet.handle_accepted_transaction(transaction.clone(), txn_info).unwrap();
         }
 
-        assert_eq!(starknet.blocks.get_blocks(None, None).unwrap().len(), 6);
+        assert_eq!(
+            starknet
+                .blocks
+                .get_blocks(None, Some(BlockId::Tag(starknet_rs_core::types::BlockTag::Latest)))
+                .unwrap()
+                .len(),
+            6
+        );
         for idx in 0..5 {
             starknet.transactions.get_by_hash(Felt::from(idx as u128 + 100)).unwrap();
         }

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

@@ -57,10 +57,13 @@ pub fn get_class_at_impl(
 
 pub fn get_compiled_casm_impl(
     starknet: &Starknet,
-    block_id: &BlockId,
     class_hash: ClassHash,
 ) -> DevnetResult<CasmContractClass> {
-    let contract_class = get_class_impl(starknet, block_id, class_hash)?;
+    let contract_class = get_class_impl(
+        starknet,
+        &BlockId::Tag(starknet_rs_core::types::BlockTag::Latest),
+        class_hash,
+    )?;
     match contract_class {
         ContractClass::Cairo1(sierra_contract_class) => {
             Ok(compile_sierra_contract(&sierra_contract_class)?)

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

@@ -399,6 +399,7 @@ impl Starknet {
             transaction.get_type(),
             &tx_info,
             state_diff.clone().into(),
+            self.block_context.versioned_constants(),
         )?;
         let transaction_to_add = StarknetTransaction::create_accepted(&transaction, tx_info, trace);
 
@@ -600,12 +601,8 @@ impl Starknet {
         get_class_impls::get_class_at_impl(self, block_id, contract_address)
     }
 
-    pub fn get_compiled_casm(
-        &self,
-        block_id: &BlockId,
-        class_hash: ClassHash,
-    ) -> DevnetResult<CasmContractClass> {
-        get_class_impls::get_compiled_casm_impl(self, block_id, class_hash)
+    pub fn get_compiled_casm(&self, class_hash: ClassHash) -> DevnetResult<CasmContractClass> {
+        get_class_impls::get_compiled_casm_impl(self, class_hash)
     }
 
     pub fn call(
@@ -1190,6 +1187,7 @@ impl Starknet {
                 transaction_type,
                 &tx_execution_info,
                 state_diff,
+                block_context.versioned_constants(),
             )?;
             transactions_traces.push(trace);
         }

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

@@ -2,6 +2,7 @@ use blockifier::execution::call_info::CallInfo;
 use blockifier::state::cached_state::CachedState;
 use blockifier::state::state_api::StateReader;
 use blockifier::transaction::objects::TransactionExecutionInfo;
+use blockifier::versioned_constants::VersionedConstants;
 use starknet_types::rpc::state::ThinStateDiff;
 use starknet_types::rpc::transaction_receipt::ExecutionResources;
 use starknet_types::rpc::transactions::{
@@ -15,11 +16,14 @@ use crate::error::{DevnetResult, Error};
 fn get_execute_call_info<S: StateReader>(
     state: &mut CachedState<S>,
     execution_info: &TransactionExecutionInfo,
+    versioned_constants: &VersionedConstants,
 ) -> DevnetResult<ExecutionInvocation> {
     Ok(match &execution_info.execute_call_info {
         Some(call_info) => match call_info.execution.failed {
             false => ExecutionInvocation::Succeeded(FunctionInvocation::try_from_call_info(
-                call_info, state,
+                call_info,
+                state,
+                versioned_constants,
             )?),
             true => ExecutionInvocation::Reverted(starknet_types::rpc::transactions::Reversion {
                 revert_reason: execution_info
@@ -46,9 +50,10 @@ fn get_execute_call_info<S: StateReader>(
 fn get_call_info_invocation<S: StateReader>(
     state: &mut CachedState<S>,
     call_info_invocation: &Option<CallInfo>,
+    versioned_constants: &VersionedConstants,
 ) -> DevnetResult<Option<FunctionInvocation>> {
     Ok(if let Some(call_info) = call_info_invocation {
-        Some(FunctionInvocation::try_from_call_info(call_info, state)?)
+        Some(FunctionInvocation::try_from_call_info(call_info, state, versioned_constants)?)
     } else {
         None
     })
@@ -59,13 +64,18 @@ pub(crate) fn create_trace<S: StateReader>(
     tx_type: TransactionType,
     execution_info: &TransactionExecutionInfo,
     state_diff: ThinStateDiff,
+    versioned_constants: &VersionedConstants,
 ) -> DevnetResult<TransactionTrace> {
     let state_diff = Some(state_diff);
-    let validate_invocation = get_call_info_invocation(state, &execution_info.validate_call_info)?;
+    let validate_invocation =
+        get_call_info_invocation(state, &execution_info.validate_call_info, versioned_constants)?;
     let execution_resources = ExecutionResources::from(execution_info);
 
-    let fee_transfer_invocation =
-        get_call_info_invocation(state, &execution_info.fee_transfer_call_info)?;
+    let fee_transfer_invocation = get_call_info_invocation(
+        state,
+        &execution_info.fee_transfer_call_info,
+        versioned_constants,
+    )?;
 
     match tx_type {
         TransactionType::Declare => Ok(TransactionTrace::Declare(DeclareTransactionTrace {
@@ -80,6 +90,7 @@ pub(crate) fn create_trace<S: StateReader>(
                 constructor_invocation: get_call_info_invocation(
                     state,
                     &execution_info.execute_call_info,
+                    versioned_constants,
                 )?,
                 fee_transfer_invocation,
                 state_diff,
@@ -88,13 +99,17 @@ pub(crate) fn create_trace<S: StateReader>(
         }
         TransactionType::Invoke => Ok(TransactionTrace::Invoke(InvokeTransactionTrace {
             validate_invocation,
-            execute_invocation: get_execute_call_info(state, execution_info)?,
+            execute_invocation: get_execute_call_info(state, execution_info, versioned_constants)?,
             fee_transfer_invocation,
             state_diff,
             execution_resources,
         })),
         TransactionType::L1Handler => {
-            match get_call_info_invocation(state, &execution_info.execute_call_info)? {
+            match get_call_info_invocation(
+                state,
+                &execution_info.execute_call_info,
+                versioned_constants,
+            )? {
                 Some(function_invocation) => {
                     Ok(TransactionTrace::L1Handler(L1HandlerTransactionTrace {
                         function_invocation,

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

@@ -288,6 +288,7 @@ impl StarknetTransaction {
 #[cfg(test)]
 mod tests {
     use blockifier::transaction::objects::TransactionExecutionInfo;
+    use blockifier::versioned_constants;
     use starknet_rs_core::types::{TransactionExecutionStatus, TransactionFinalityStatus};
     use starknet_types::rpc::transactions::{TransactionTrace, TransactionWithHash};
 
@@ -302,6 +303,7 @@ mod tests {
             tx.get_type(),
             &Default::default(),
             Default::default(),
+            versioned_constants::VersionedConstants::latest_constants(),
         )
         .unwrap()
     }

crates/starknet-devnet-server/src/api/json_rpc/endpoints.rs

@@ -217,15 +217,12 @@ impl JsonRpcHandler {
         }
     }
 
-    pub async fn get_compiled_casm(
-        &self,
-        block_id: BlockId,
-        class_hash: ClassHash,
-    ) -> StrictRpcResult {
+    /// starknet_getCompiledCasm
+    pub async fn get_compiled_casm(&self, class_hash: ClassHash) -> StrictRpcResult {
         // starknet_getCompiledCasm compiles sierra to casm the same way it is done in
         // starknet_addDeclareTransaction, so if during starknet_addDeclareTransaction compilation
         // does not fail, so it will not fail during this endpoint execution
-        match self.api.starknet.lock().await.get_compiled_casm(block_id.as_ref(), class_hash) {
+        match self.api.starknet.lock().await.get_compiled_casm(class_hash) {
             Ok(compiled_casm) => Ok(StarknetResponse::CompiledCasm(compiled_casm).into()),
             Err(e) => Err(match e {
                 Error::NoBlock => ApiError::BlockNotFound,