Update blockifier to 0.8.0

Dockerfile

@@ -1,26 +1,26 @@
 # Stage 1: Build golang dependencies and binaries
-FROM ubuntu:24.04 AS build
+FROM ubuntu:24.10 AS build
 
 ARG VM_DEBUG
 
-# Install Alpine Dependencies
-# removal is temp. to fix https://github.com/orgs/community/discussions/120966
-RUN apt-get update && \
-    apt-get install build-essential cargo git golang upx-ucl libjemalloc-dev libjemalloc2 -y
+
+RUN apt-get -qq update && \
+    apt-get -qq install curl build-essential git golang upx-ucl libjemalloc-dev libjemalloc2 -y
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -q -y
 
 WORKDIR /app
 
 # Copy source code
 COPY . .
 
 # Build the project
-RUN VM_DEBUG=${VM_DEBUG} make juno
+RUN bash -c 'source ~/.cargo/env && VM_DEBUG=${VM_DEBUG} make juno'
 
 # Compress the executable with UPX
 RUN upx-ucl /app/build/juno
 
 # Stage 2: Build Docker image
-FROM ubuntu:23.10 AS runtime
+FROM ubuntu:24.10 AS runtime
 
 RUN apt-get update && apt-get install -y ca-certificates curl gawk grep libjemalloc-dev libjemalloc2
 

node/node.go

@@ -172,7 +172,7 @@ func New(cfg *Config, version string) (*Node, error) { //nolint:gocyclo,funlen
 		services = append(services, synchronizer)
 	}
 
-	throttledVM := NewThrottledVM(vm.New(log), cfg.MaxVMs, int32(cfg.MaxVMQueue))
+	throttledVM := NewThrottledVM(vm.New(false, log), cfg.MaxVMs, int32(cfg.MaxVMQueue))
 
 	var syncReader sync.Reader = &sync.NoopSynchronizer{}
 	if synchronizer != nil {

node/throttled_vm.go

@@ -31,7 +31,8 @@ func (tvm *ThrottledVM) Call(callInfo *vm.CallInfo, blockInfo *vm.BlockInfo, sta
 }
 
 func (tvm *ThrottledVM) Execute(txns []core.Transaction, declaredClasses []core.Class, paidFeesOnL1 []*felt.Felt,
-	blockInfo *vm.BlockInfo, state core.StateReader, network *utils.Network, skipChargeFee, skipValidate, errOnRevert, useBlobData bool,
+	blockInfo *vm.BlockInfo, state core.StateReader, network *utils.Network, skipChargeFee, skipValidate, errOnRevert,
+	useBlobData bool,
 ) ([]*felt.Felt, []*felt.Felt, []vm.TransactionTrace, error) {
 	var ret []*felt.Felt
 	var traces []vm.TransactionTrace

rpc/trace_test.go

@@ -245,7 +245,8 @@ func TestTraceTransaction(t *testing.T) {
 		consumedGas := []*felt.Felt{new(felt.Felt).SetUint64(1)}
 		overallFee := []*felt.Felt{new(felt.Felt).SetUint64(1)}
 		mockVM.EXPECT().Execute([]core.Transaction{tx}, []core.Class{declaredClass.Class}, []*felt.Felt{},
-			&vm.BlockInfo{Header: header}, gomock.Any(), &utils.Mainnet, false, false, false, true).Return(overallFee, consumedGas, []vm.TransactionTrace{*vmTrace}, nil)
+			&vm.BlockInfo{Header: header}, gomock.Any(), &utils.Mainnet, false, false, false, true).
+			Return(overallFee, consumedGas, []vm.TransactionTrace{*vmTrace}, nil)
 
 		trace, err := handler.TraceTransaction(context.Background(), *hash)
 		require.Nil(t, err)
@@ -324,7 +325,8 @@ func TestTraceTransactionV0_6(t *testing.T) {
 		vmTrace := new(vm.TransactionTrace)
 		require.NoError(t, json.Unmarshal(vmTraceJSON, vmTrace))
 		mockVM.EXPECT().Execute([]core.Transaction{tx}, []core.Class{declaredClass.Class}, []*felt.Felt{},
-			&vm.BlockInfo{Header: header}, gomock.Any(), &utils.Mainnet, false, false, false, false).Return(nil, nil, []vm.TransactionTrace{*vmTrace}, nil)
+			&vm.BlockInfo{Header: header}, gomock.Any(), &utils.Mainnet, false, false, false, false).
+			Return(nil, nil, []vm.TransactionTrace{*vmTrace}, nil)
 
 		trace, err := handler.TraceTransactionV0_6(context.Background(), *hash)
 		require.Nil(t, err)
@@ -379,7 +381,8 @@ func TestTraceTransactionV0_6(t *testing.T) {
 		vmTrace := new(vm.TransactionTrace)
 		require.NoError(t, json.Unmarshal(vmTraceJSON, vmTrace))
 		mockVM.EXPECT().Execute([]core.Transaction{tx}, []core.Class{declaredClass.Class}, []*felt.Felt{},
-			&vm.BlockInfo{Header: header}, gomock.Any(), &utils.Mainnet, false, false, false, false).Return(nil, nil, []vm.TransactionTrace{*vmTrace}, nil)
+			&vm.BlockInfo{Header: header}, gomock.Any(), &utils.Mainnet, false, false, false, false).
+			Return(nil, nil, []vm.TransactionTrace{*vmTrace}, nil)
 
 		trace, err := handler.TraceTransactionV0_6(context.Background(), *hash)
 		require.Nil(t, err)
@@ -470,7 +473,8 @@ func TestTraceBlockTransactions(t *testing.T) {
 		vmTrace := vm.TransactionTrace{}
 		require.NoError(t, json.Unmarshal(vmTraceJSON, &vmTrace))
 		mockVM.EXPECT().Execute(block.Transactions, []core.Class{declaredClass.Class}, paidL1Fees, &vm.BlockInfo{Header: header},
-			gomock.Any(), n, false, false, false, false).Return(nil, []vm.TransactionTrace{vmTrace, vmTrace}, nil)
+			gomock.Any(), n, false, false, false, false).
+			Return(nil, []vm.TransactionTrace{vmTrace, vmTrace}, nil)
 
 		result, err := handler.TraceBlockTransactions(context.Background(), rpc.BlockID{Hash: blockHash})
 		require.Nil(t, err)
@@ -536,7 +540,8 @@ func TestTraceBlockTransactions(t *testing.T) {
 		vmTrace := vm.TransactionTrace{}
 		require.NoError(t, json.Unmarshal(vmTraceJSON, &vmTrace))
 		mockVM.EXPECT().Execute([]core.Transaction{tx}, []core.Class{declaredClass.Class}, []*felt.Felt{}, &vm.BlockInfo{Header: header},
-			gomock.Any(), n, false, false, false, false).Return(nil, []vm.TransactionTrace{vmTrace}, nil)
+			gomock.Any(), n, false, false, false, false).
+			Return(nil, []vm.TransactionTrace{vmTrace}, nil)
 
 		expectedResult := []rpc.TracedBlockTransaction{
 			{

starknet/rust/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 [dependencies]
 serde = "1.0.171"
 serde_json = { version = "1.0.96", features = ["raw_value"] }
-cairo-lang-starknet-classes = "=2.6.0"
+cairo-lang-starknet-classes = "=2.7.0-rc.3"
 
 [lib]
 crate-type = ["staticlib"]

vm/rust/Cargo.toml

@@ -8,9 +8,10 @@ edition = "2021"
 [dependencies]
 serde = "1.0.171"
 serde_json = { version = "1.0.96", features = ["raw_value"] }
-blockifier = "=0.6.0-rc.2"
-starknet_api = "=0.10.0"
-cairo-vm = "=0.9.2"
+blockifier = "=0.8.0-rc.1"
+starknet_api = "=0.13.0-rc.0"
+cairo-vm = "=1.0.0-rc5"
+starknet-types-core = { version = "0.1.5", features = ["hash", "prime-bigint"] }
 indexmap = "2.1.0"
 cached = "0.46.1"
 once_cell = "1.18.0"

vm/rust/src/jsonrpc.rs

@@ -1,28 +1,28 @@
 use blockifier;
-use blockifier::execution::entry_point::CallType;
 use blockifier::execution::call_info::OrderedL2ToL1Message;
-use cairo_vm::vm::runners::builtin_runner::{
-    BITWISE_BUILTIN_NAME, EC_OP_BUILTIN_NAME, HASH_BUILTIN_NAME,
-    POSEIDON_BUILTIN_NAME, RANGE_CHECK_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME, KECCAK_BUILTIN_NAME,
-    SEGMENT_ARENA_BUILTIN_NAME,
-};
-use blockifier::state::cached_state::TransactionalState;
+use blockifier::execution::entry_point::CallType;
+use blockifier::state::cached_state::CachedState;
+use blockifier::state::cached_state::{CommitmentStateDiff, TransactionalState};
 use blockifier::state::errors::StateError;
-use blockifier::state::state_api::{State, StateReader};
+use blockifier::state::state_api::StateReader;
+use cairo_vm::types::builtin_name::BuiltinName;
 use serde::Serialize;
-use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector, PatriciaKey, EthAddress};
+use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector, EthAddress, PatriciaKey};
 use starknet_api::deprecated_contract_class::EntryPointType;
-use starknet_api::hash::StarkFelt;
 use starknet_api::transaction::{Calldata, EventContent, L2ToL1Payload};
 use starknet_api::transaction::{DeclareTransaction, Transaction as StarknetApiTransaction};
+use starknet_types_core::felt::Felt;
+
+type StarkFelt = Felt;
 
 use crate::juno_state_reader::JunoStateReader;
 
 #[derive(Serialize, Default)]
 #[serde(rename_all = "UPPERCASE")]
 pub enum TransactionType {
     // dummy type for implementing Default trait
-    #[default] Unknown,
+    #[default]
+    Unknown,
     Invoke,
     Declare,
     #[serde(rename = "DEPLOY_ACCOUNT")]
@@ -104,10 +104,10 @@ type BlockifierTxInfo = blockifier::transaction::objects::TransactionExecutionIn
 pub fn new_transaction_trace(
     tx: &StarknetApiTransaction,
     info: BlockifierTxInfo,
-    state: &mut TransactionalState<JunoStateReader>,
+    state: &mut TransactionalState<CachedState<JunoStateReader>>,
 ) -> Result<TransactionTrace, StateError> {
     let mut trace = TransactionTrace::default();
-    let mut deprecated_declared_class: Option<ClassHash> = None;
+    let mut deprecated_declared_class_hash: Option<ClassHash> = None;
     match tx {
         StarknetApiTransaction::L1Handler(_) => {
             trace.function_invocation = info.execute_call_info.map(|v| v.into());
@@ -134,7 +134,7 @@ pub fn new_transaction_trace(
             trace.validate_invocation = info.validate_call_info.map(|v| v.into());
             trace.fee_transfer_invocation = info.fee_transfer_call_info.map(|v| v.into());
             trace.r#type = TransactionType::Declare;
-            deprecated_declared_class = if info.revert_error.is_none() {
+            deprecated_declared_class_hash = if info.revert_error.is_none() {
                 match declare_txn {
                     DeclareTransaction::V0(_) => Some(declare_txn.class_hash()),
                     DeclareTransaction::V1(_) => Some(declare_txn.class_hash()),
@@ -150,7 +150,7 @@ pub fn new_transaction_trace(
         }
     };
 
-    trace.state_diff = make_state_diff(state, deprecated_declared_class)?;
+    trace.state_diff = make_state_diff(state, deprecated_declared_class_hash)?;
     Ok(trace)
 }
 
@@ -205,14 +205,38 @@ impl From<VmExecutionResources> for ExecutionResources {
             } else {
                 None
             },
-            range_check_builtin_applications: val.builtin_instance_counter.get(RANGE_CHECK_BUILTIN_NAME).cloned(),
-            pedersen_builtin_applications: val.builtin_instance_counter.get(HASH_BUILTIN_NAME).cloned(),
-            poseidon_builtin_applications: val.builtin_instance_counter.get(POSEIDON_BUILTIN_NAME).cloned(),
-            ec_op_builtin_applications: val.builtin_instance_counter.get(EC_OP_BUILTIN_NAME).cloned(),
-            ecdsa_builtin_applications: val.builtin_instance_counter.get(SIGNATURE_BUILTIN_NAME).cloned(),
-            bitwise_builtin_applications: val.builtin_instance_counter.get(BITWISE_BUILTIN_NAME).cloned(),
-            keccak_builtin_applications: val.builtin_instance_counter.get(KECCAK_BUILTIN_NAME).cloned(),
-            segment_arena_builtin: val.builtin_instance_counter.get(SEGMENT_ARENA_BUILTIN_NAME).cloned(),
+            range_check_builtin_applications: val
+                .builtin_instance_counter
+                .get(&BuiltinName::range_check)
+                .cloned(),
+            pedersen_builtin_applications: val
+                .builtin_instance_counter
+                .get(&BuiltinName::pedersen)
+                .cloned(),
+            poseidon_builtin_applications: val
+                .builtin_instance_counter
+                .get(&BuiltinName::poseidon)
+                .cloned(),
+            ec_op_builtin_applications: val
+                .builtin_instance_counter
+                .get(&BuiltinName::ec_op)
+                .cloned(),
+            ecdsa_builtin_applications: val
+                .builtin_instance_counter
+                .get(&BuiltinName::ecdsa)
+                .cloned(),
+            bitwise_builtin_applications: val
+                .builtin_instance_counter
+                .get(&BuiltinName::bitwise)
+                .cloned(),
+            keccak_builtin_applications: val
+                .builtin_instance_counter
+                .get(&BuiltinName::keccak)
+                .cloned(),
+            segment_arena_builtin: val
+                .builtin_instance_counter
+                .get(&BuiltinName::segment_arena)
+                .cloned(),
         }
     }
 }
@@ -298,33 +322,35 @@ impl From<OrderedL2ToL1Message> for OrderedMessage {
 pub struct Retdata(pub Vec<StarkFelt>);
 
 fn make_state_diff(
-    state: &mut TransactionalState<JunoStateReader>,
-    deprecated_declared_class: Option<ClassHash>,
+    state: &mut TransactionalState<CachedState<JunoStateReader>>,
+    deprecated_declared_class_hash: Option<ClassHash>,
 ) -> Result<StateDiff, StateError> {
-    let diff = state.to_state_diff();
+    let diff: CommitmentStateDiff = state.to_state_diff()?.into();
     let mut deployed_contracts = Vec::new();
     let mut replaced_classes = Vec::new();
 
-    for pair in diff.address_to_class_hash {
-        let existing_class_hash = state.state.get_class_hash_at(pair.0)?;
+    for (addr, class_hash) in diff.address_to_class_hash {
+        let existing_class_hash = state.state.get_class_hash_at(addr)?;
+        let addr: StarkFelt = addr.into();
+
         if existing_class_hash == ClassHash::default() {
             #[rustfmt::skip]
             deployed_contracts.push(DeployedContract {
-                address: *pair.0.0.key(),
-                class_hash: pair.1.0,
+                address: addr,
+                class_hash: class_hash.0,
             });
         } else {
             #[rustfmt::skip]
             replaced_classes.push(ReplacedClass {
-                contract_address: *pair.0.0.key(),
-                class_hash: pair.1.0,
+                contract_address: addr,
+                class_hash: class_hash.0,
             });
         }
     }
 
-    let mut deprecated_declared_classes = Vec::default();
-    if let Some(v) = deprecated_declared_class {
-        deprecated_declared_classes.push(v.0)
+    let mut deprecated_declared_class_hashes = Vec::default();
+    if let Some(v) = deprecated_declared_class_hash {
+        deprecated_declared_class_hashes.push(v.0)
     }
     Ok(StateDiff {
         deployed_contracts,
@@ -341,7 +367,7 @@ fn make_state_diff(
             class_hash: v.0.0,
             compiled_class_hash: v.1.0,
         }).collect(),
-        deprecated_declared_classes,
+        deprecated_declared_class_hashes,
         #[rustfmt::skip]
         nonces: diff.address_to_nonce.into_iter().map(| v | Nonce {
           contract_address: *v.0.0.key(),