fix: traceBlockTransactions shouldn't fail because of wrong class cache (#2644)

Author: infrmtcs

vm/rust/src/juno_state_reader.rs

@@ -22,6 +22,9 @@ use starknet_api::contract_class::{
 use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress, Nonce};
 use starknet_api::state::StorageKey;
 use starknet_types_core::felt::Felt;
+
+use crate::BlockInfo;
+
 type StarkFelt = Felt;
 
 extern "C" {
@@ -55,13 +58,35 @@ struct CachedRunnableCompiledClass {
 static CLASS_CACHE: Lazy<Mutex<SizedCache<ClassHash, CachedRunnableCompiledClass>>> =
     Lazy::new(|| Mutex::new(SizedCache::with_size(128)));
 
+pub enum BlockHeight {
+    Height(u64),
+    Pending,
+}
+
+impl BlockHeight {
+    pub fn is_after(&self, target: u64) -> bool {
+        match self {
+            BlockHeight::Height(height) => *height > target,
+            BlockHeight::Pending => true,
+        }
+    }
+
+    pub fn from_block_info(block_info: &BlockInfo) -> Self {
+        if block_info.is_pending == 1 {
+            Self::Pending
+        } else {
+            Self::Height(block_info.block_number)
+        }
+    }
+}
+
 pub struct JunoStateReader {
     pub handle: usize, // uintptr_t equivalent
-    pub height: u64,
+    pub height: BlockHeight,
 }
 
 impl JunoStateReader {
-    pub fn new(handle: usize, height: u64) -> Self {
+    pub fn new(handle: usize, height: BlockHeight) -> Self {
         Self { handle, height }
     }
 }
@@ -145,7 +170,7 @@ impl StateReader for JunoStateReader {
             // with the same block number but with the state at the end of that block. That is why, we cannot use classes from cache
             // if they are cached on the same height that we are executing on. Because they might be cached using a state instance that
             // is in the future compared to the state that we are currently executing on, even tho they have the same height.
-            if cached_class.cached_on_height < self.height {
+            if self.height.is_after(cached_class.cached_on_height) {
                 return Ok(cached_class.definition.clone());
             }
         }
@@ -164,15 +189,17 @@ impl StateReader for JunoStateReader {
                 Ok(class) => {
                     let runnable_compiled_class =
                         RunnableCompiledClass::try_from(class.contract_class).unwrap();
-                    CLASS_CACHE.lock().unwrap().cache_set(
-                        class_hash,
-                        CachedRunnableCompiledClass {
-                            // This clone is cheap, it is just a reference copy in the underlying
-                            // RunnableCompiledClass implementation
-                            definition: runnable_compiled_class.clone(),
-                            cached_on_height: self.height,
-                        },
-                    );
+                    if let BlockHeight::Height(height) = self.height {
+                        CLASS_CACHE.lock().unwrap().cache_set(
+                            class_hash,
+                            CachedRunnableCompiledClass {
+                                // This clone is cheap, it is just a reference copy in the underlying
+                                // RunnableCompiledClass implementation
+                                definition: runnable_compiled_class.clone(),
+                                cached_on_height: height,
+                            },
+                        );
+                    }
                     Ok(runnable_compiled_class)
                 }
                 Err(e) => Err(StateError::StateReadError(format!(

vm/rust/src/lib.rs

@@ -4,7 +4,7 @@ pub mod execution;
 pub mod jsonrpc;
 mod juno_state_reader;
 
-use crate::juno_state_reader::{ptr_to_felt, JunoStateReader};
+use crate::juno_state_reader::{ptr_to_felt, BlockHeight, JunoStateReader};
 use error::{CallError, ExecutionError};
 use error_stack::{ErrorStack, Frame};
 use execution::process_transaction;
@@ -99,6 +99,7 @@ pub struct CallInfo {
 pub struct BlockInfo {
     pub block_number: c_ulonglong,
     pub block_timestamp: c_ulonglong,
+    pub is_pending: c_uchar,
     pub sequencer_address: [c_uchar; 32],
     pub l1_gas_price_wei: [c_uchar; 32],
     pub l1_gas_price_fri: [c_uchar; 32],
@@ -126,7 +127,10 @@ pub extern "C" fn cairoVMCall(
     let block_info = unsafe { *block_info_ptr };
     let call_info = unsafe { *call_info_ptr };
 
-    let reader = JunoStateReader::new(reader_handle, block_info.block_number);
+    let reader = JunoStateReader::new(
+        reader_handle,
+        BlockHeight::from_block_info(&block_info),
+    );
     let contract_addr_felt = StarkFelt::from_bytes_be(&call_info.contract_address);
     let class_hash = if call_info.class_hash == [0; 32] {
         None
@@ -247,7 +251,10 @@ pub extern "C" fn cairoVMExecute(
     err_stack: c_uchar,
 ) {
     let block_info = unsafe { *block_info_ptr };
-    let reader = JunoStateReader::new(reader_handle, block_info.block_number);
+    let reader = JunoStateReader::new(
+        reader_handle,
+        BlockHeight::from_block_info(&block_info),
+    );
     let chain_id_str = unsafe { CStr::from_ptr(chain_id) }.to_str().unwrap();
     let txn_json_str = unsafe { CStr::from_ptr(txns_json) }.to_str().unwrap();
     let txns_and_query_bits: Result<Vec<TxnAndQueryBit>, serde_json::Error> =

vm/vm.go

@@ -195,6 +195,7 @@ func makeCBlockInfo(blockInfo *BlockInfo) C.BlockInfo {
 
 	cBlockInfo.block_number = C.ulonglong(blockInfo.Header.Number)
 	cBlockInfo.block_timestamp = C.ulonglong(blockInfo.Header.Timestamp)
+	cBlockInfo.is_pending = toUchar(blockInfo.Header.Hash == nil)
 	copyFeltIntoCArray(blockInfo.Header.SequencerAddress, &cBlockInfo.sequencer_address[0])
 	copyFeltIntoCArray(blockInfo.Header.L1GasPriceETH, &cBlockInfo.l1_gas_price_wei[0])
 	copyFeltIntoCArray(blockInfo.Header.L1GasPriceSTRK, &cBlockInfo.l1_gas_price_fri[0])
@@ -223,16 +224,6 @@ func (v *vm) Call(callInfo *CallInfo, blockInfo *BlockInfo, state core.StateRead
 	handle := cgo.NewHandle(context)
 	defer handle.Delete()
 
-	var concurrencyModeByte byte
-	if v.concurrencyMode {
-		concurrencyModeByte = 1
-	}
-	var structuredErrStackByte byte
-	if structuredErrStack {
-		structuredErrStackByte = 1
-	}
-	C.setVersionedConstants(C.CString("my_json"))
-
 	cCallInfo, callInfoPinner := makeCCallInfo(callInfo)
 	cBlockInfo := makeCBlockInfo(blockInfo)
 	chainID := C.CString(network.L2ChainID)
@@ -243,9 +234,9 @@ func (v *vm) Call(callInfo *CallInfo, blockInfo *BlockInfo, state core.StateRead
 		C.uintptr_t(handle),
 		chainID,
 		C.ulonglong(maxSteps),
-		C.uchar(concurrencyModeByte),
+		toUchar(v.concurrencyMode),
 		cSierraVersion,
-		C.uchar(structuredErrStackByte), //nolint:gocritic // don't know why the linter is annoyed
+		toUchar(structuredErrStack), //nolint:gocritic // See https://github.com/go-critic/go-critic/issues/897
 	)
 	callInfoPinner.Unpin()
 	C.free(unsafe.Pointer(chainID))
@@ -284,31 +275,6 @@ func (v *vm) Execute(txns []core.Transaction, declaredClasses []core.Class, paid
 	txnsJSONCstr := cstring(txnsJSON)
 	classesJSONCStr := cstring(classesJSON)
 
-	var skipChargeFeeByte byte
-	if skipChargeFee {
-		skipChargeFeeByte = 1
-	}
-
-	var skipValidateByte byte
-	if skipValidate {
-		skipValidateByte = 1
-	}
-
-	var errOnRevertByte byte
-	if errOnRevert {
-		errOnRevertByte = 1
-	}
-
-	var errorStackByte byte
-	if errorStack {
-		errorStackByte = 1
-	}
-
-	var concurrencyModeByte byte
-	if v.concurrencyMode {
-		concurrencyModeByte = 1
-	}
-
 	cBlockInfo := makeCBlockInfo(blockInfo)
 	chainID := C.CString(network.L2ChainID)
 	C.cairoVMExecute(txnsJSONCstr,
@@ -317,11 +283,11 @@ func (v *vm) Execute(txns []core.Transaction, declaredClasses []core.Class, paid
 		&cBlockInfo,
 		C.uintptr_t(handle),
 		chainID,
-		C.uchar(skipChargeFeeByte),
-		C.uchar(skipValidateByte),
-		C.uchar(errOnRevertByte),     //nolint:gocritic
-		C.uchar(concurrencyModeByte), //nolint:gocritic
-		C.uchar(errorStackByte),      //nolint:gocritic
+		toUchar(skipChargeFee),
+		toUchar(skipValidate),
+		toUchar(errOnRevert),
+		toUchar(v.concurrencyMode),
+		toUchar(errorStack), //nolint:gocritic // See https://github.com/go-critic/go-critic/issues/897
 	)
 
 	C.free(unsafe.Pointer(classesJSONCStr))
@@ -412,3 +378,10 @@ func SetVersionedConstants(filename string) error {
 
 	return err
 }
+
+func toUchar(b bool) C.uchar {
+	if b {
+		return 1
+	}
+	return 0
+}

vm/vm_ffi.h

@@ -18,6 +18,7 @@ typedef struct CallInfo {
 typedef struct BlockInfo {
 	unsigned long long block_number;
 	unsigned long long block_timestamp;
+	unsigned char is_pending;
 	unsigned char sequencer_address[FELT_SIZE];
 	unsigned char l1_gas_price_wei[FELT_SIZE];
 	unsigned char l1_gas_price_fri[FELT_SIZE];