diff --git a/.github/workflows/build-binaries.yml b/.github/workflows/build-binaries.yml
index f7b0c7179f..2d38773d26 100644
--- a/.github/workflows/build-binaries.yml
+++ b/.github/workflows/build-binaries.yml
@@ -15,7 +15,7 @@ jobs:
         include:
           - os: ubuntu-latest
             arch: amd64
-          - os: macos-15-intel
+          - os: macos-13
             arch: amd64
           - os: ubuntu-arm64-4-core
             arch: arm64
diff --git a/.github/workflows/find-smallest-rust.yml b/.github/workflows/find-smallest-rust.yml
index e0e1676c1d..91d54611d4 100644
--- a/.github/workflows/find-smallest-rust.yml
+++ b/.github/workflows/find-smallest-rust.yml
@@ -5,7 +5,6 @@ on:
     branches:
       - main
     paths:
-      - docs/docs/running-juno.md
       - .github/workflows/find-smallest-rust.yml
       - core/rust/*
       - vm/rust/*
@@ -36,7 +35,7 @@ jobs:
         with:
           script: |
             const msrv = '${{ steps.rust-version.outputs.highest-msrv }}'
-            const previous_msrv = '1.87.0'
+            const previous_msrv = '1.86.0'
 
             if (msrv != previous_msrv) {
               github.rest.issues.createComment({
@@ -50,7 +49,7 @@ jobs:
       - name: "Check README and Makefile"
         run: |
           set -euxo pipefail
-          echo "Checking if version is set in docs/docs/running-juno.md"
-          cat docs/docs/running-juno.md | grep "\[Rust\]" | grep "${{ steps.rust-version.outputs.highest-msrv }}"
+          echo "Checking if version is set in README"
+          cat README.md | grep "\[Rust\]" | grep "${{ steps.rust-version.outputs.highest-msrv }}"
           echo "Checking makefile"
           cat Makefile | grep "MINIMUM_RUST_VERSION = ${{ steps.rust-version.outputs.highest-msrv }}"
diff --git a/Dockerfile b/Dockerfile
index 4c659a7025..222fe80bec 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -3,7 +3,7 @@
 # --- Builder stage ---
 FROM golang:1.25-bookworm AS builder
 
-ARG RUST_VERSION=1.87.0
+ARG RUST_VERSION=1.86.0
 
 # Install system dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
diff --git a/Makefile b/Makefile
index d7ca4f6557..28a62cee06 100644
--- a/Makefile
+++ b/Makefile
@@ -44,7 +44,7 @@ juno-cached: ## Cached Juno compilation
 	@go build $(GO_TAGS) -ldflags="-X main.Version=$(shell git describe --tags)" -o build/juno ./cmd/juno/
 
 
-MINIMUM_RUST_VERSION = 1.87.0
+MINIMUM_RUST_VERSION = 1.86.0
 CURR_RUST_VERSION = $(shell rustc --version | grep -o '[0-9.]\+' | head -n1)
 check-rust: ## Ensure rust version is greater than minimum
 	@echo "Checking if current rust version >= $(MINIMUM_RUST_VERSION)"
diff --git a/adapters/core2sn/class.go b/adapters/core2sn/class.go
index e975b4c909..7ce9e046c3 100644
--- a/adapters/core2sn/class.go
+++ b/adapters/core2sn/class.go
@@ -28,12 +28,9 @@ func AdaptCasmClass(coreCasmClass *core.CasmClass) starknet.CasmClass {
 	feederCompiledClass.CompilerVersion = coreCasmClass.CompilerVersion
 	feederCompiledClass.Hints = coreCasmClass.Hints
 	feederCompiledClass.Prime = utils.ToHex(coreCasmClass.Prime)
-
-	if coreCasmClass.BytecodeSegmentLengths.Length != 0 ||
-		len(coreCasmClass.BytecodeSegmentLengths.Children) != 0 {
-		segmentLengths := AdaptSegmentLengths(coreCasmClass.BytecodeSegmentLengths)
-		feederCompiledClass.BytecodeSegmentLengths = &segmentLengths
-	}
+	feederCompiledClass.BytecodeSegmentLengths = AdaptSegmentLengths(
+		coreCasmClass.BytecodeSegmentLengths,
+	)
 
 	feederCompiledClass.EntryPoints.External = make(
 		[]starknet.CompiledEntryPoint,
diff --git a/adapters/sn2core/sn2core.go b/adapters/sn2core/sn2core.go
index dd0cee4988..2a6fb5c363 100644
--- a/adapters/sn2core/sn2core.go
+++ b/adapters/sn2core/sn2core.go
@@ -348,9 +348,7 @@ func AdaptCompiledClass(compiledClass *starknet.CasmClass) (*core.CasmClass, err
 	casm.PythonicHints = compiledClass.PythonicHints
 	casm.CompilerVersion = compiledClass.CompilerVersion
 	casm.Hints = compiledClass.Hints
-	if compiledClass.BytecodeSegmentLengths != nil {
-		casm.BytecodeSegmentLengths = AdaptSegmentLengths(*compiledClass.BytecodeSegmentLengths)
-	}
+	casm.BytecodeSegmentLengths = AdaptSegmentLengths(compiledClass.BytecodeSegmentLengths)
 
 	var ok bool
 	casm.Prime, ok = new(big.Int).SetString(compiledClass.Prime, 0)
diff --git a/blockchain/blockchain.go b/blockchain/blockchain.go
index 04d0473400..f04c070b52 100644
--- a/blockchain/blockchain.go
+++ b/blockchain/blockchain.go
@@ -8,6 +8,7 @@ import (
 	"github.com/NethermindEth/juno/core/felt"
 	"github.com/NethermindEth/juno/core/state"
 	"github.com/NethermindEth/juno/core/state/statefactory"
+
 	"github.com/NethermindEth/juno/core/trie2/triedb"
 	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/feed"
@@ -251,11 +252,8 @@ func (b *Blockchain) SetL1Head(update *core.L1Head) error {
 }
 
 // Store takes a block and state update and performs sanity checks before putting in the database.
-func (b *Blockchain) Store(
-	block *core.Block,
-	blockCommitments *core.BlockCommitments,
-	stateUpdate *core.StateUpdate,
-	newClasses map[felt.Felt]core.ClassDefinition,
+func (b *Blockchain) Store(block *core.Block, blockCommitments *core.BlockCommitments,
+	stateUpdate *core.StateUpdate, newClasses map[felt.Felt]core.ClassDefinition,
 ) error {
 	// old state
 	// TODO(maksymmalick): remove this once we have a new state implementation
@@ -304,11 +302,6 @@ func (b *Blockchain) deprecatedStore(
 			return err
 		}
 
-		err := storeCasmClassHashesV2ForBlock(txn, block.ProtocolVersion, newClasses, stateUpdate)
-		if err != nil {
-			return err
-		}
-
 		return core.WriteChainHeight(txn, block.Number)
 	})
 	if err != nil {
@@ -371,63 +364,6 @@ func (b *Blockchain) store(
 	return b.runningFilter.Insert(block.EventsBloom, block.Number)
 }
 
-// storeCasmClassHashesV2ForBlock stores CASM class hashes V2 based on the block version.
-// For versions < 0.14.1, it computes hashes from class definitions.
-// For versions >= 0.14.1, it uses pre-computed hashes from the state update.
-func storeCasmClassHashesV2ForBlock(
-	txn db.KeyValueWriter,
-	protocolVersion string,
-	newClasses map[felt.Felt]core.ClassDefinition,
-	stateUpdate *core.StateUpdate,
-) error {
-	ver, err := core.ParseBlockVersion(protocolVersion)
-	if err != nil {
-		return err
-	}
-	if ver.LessThan(core.Ver0_14_1) {
-		// Pre-compute blake2s CASM class hashes of declared classes in this block and
-		// store them in order to avoid computing them during simulation.
-		return computeAndStoreCasmClassHashesV2(txn, newClasses)
-	}
-	return storeCasmClassHashesV2(txn, stateUpdate.StateDiff.DeclaredV1Classes)
-}
-
-// computeAndStoreCasmClassHashesV2 computes and stores CASM class hashes V2 from class definitions.
-func computeAndStoreCasmClassHashesV2(
-	txn db.KeyValueWriter,
-	declaredClasses map[felt.Felt]core.ClassDefinition,
-) error {
-	for classHash, classDefinition := range declaredClasses {
-		sierraClass, ok := classDefinition.(*core.SierraClass)
-		if !ok {
-			// We don't have CASM classes for deprecated Cairo class
-			continue
-		}
-
-		casmHashV2 := felt.CasmClassHash(sierraClass.Compiled.Hash(core.HashVersionV2))
-		sierraClassHash := felt.SierraClassHash(classHash)
-		if err := core.WriteCasmClassHashV2(txn, &sierraClassHash, &casmHashV2); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// storeCasmClassHashesV2 stores pre-computed CASM class hashes V2 from the state update.
-func storeCasmClassHashesV2(
-	txn db.KeyValueWriter,
-	declaredV1Classes map[felt.Felt]*felt.Felt,
-) error {
-	for classHash, casmClassHashV2 := range declaredV1Classes {
-		casmHashV2 := felt.CasmClassHash(*casmClassHashV2)
-		sierraClassHash := felt.SierraClassHash(classHash)
-		if err := core.WriteCasmClassHashV2(txn, &sierraClassHash, &casmHashV2); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 // VerifyBlock assumes the block has already been sanity-checked.
 func (b *Blockchain) VerifyBlock(block *core.Block) error {
 	return verifyBlock(b.database, block)
@@ -850,10 +786,6 @@ func (b *Blockchain) Finalise(
 			if err := b.storeBlockData(txn, block, stateUpdate, commitments); err != nil {
 				return err
 			}
-			err = storeCasmClassHashesV2ForBlock(txn, block.ProtocolVersion, newClasses, stateUpdate)
-			if err != nil {
-				return err
-			}
 			return core.WriteChainHeight(txn, block.Number)
 		})
 		if err != nil {
@@ -876,10 +808,6 @@ func (b *Blockchain) Finalise(
 		if err := b.storeBlockData(batch, block, stateUpdate, commitments); err != nil {
 			return err
 		}
-		err = storeCasmClassHashesV2ForBlock(batch, block.ProtocolVersion, newClasses, stateUpdate)
-		if err != nil {
-			return err
-		}
 		if err := core.WriteChainHeight(batch, block.Number); err != nil {
 			return err
 		}
diff --git a/builder/builder.go b/builder/builder.go
index 720fef1bd6..7f7f799fcc 100644
--- a/builder/builder.go
+++ b/builder/builder.go
@@ -7,6 +7,7 @@ import (
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/mempool"
 	"github.com/NethermindEth/juno/utils"
 	"github.com/consensys/gnark-crypto/ecc/stark-curve/ecdsa"
diff --git a/consensus/consensus_test.go b/consensus/consensus_test.go
index 3d4dd22398..2550b29adb 100644
--- a/consensus/consensus_test.go
+++ b/consensus/consensus_test.go
@@ -61,6 +61,7 @@ func getBlockchain(
 	t.Helper()
 	testDB := memory.New()
 	network := &utils.Mainnet
+
 	bc := blockchain.New(testDB, network, statetestutils.UseNewState())
 	require.NoError(t, bc.StoreGenesis(&genesisDiff, genesisClasses))
 	return bc
diff --git a/core/accessors.go b/core/accessors.go
index 9e6c476cba..ae51769b79 100644
--- a/core/accessors.go
+++ b/core/accessors.go
@@ -557,30 +557,3 @@ func WriteRunningEventFilter(w db.KeyValueWriter, filter *RunningEventFilter) er
 
 	return w.Put(db.RunningEventFilter.Key(), enc)
 }
-
-func GetCasmClassHashV2(
-	r db.KeyValueReader,
-	classHash *felt.SierraClassHash,
-) (felt.CasmClassHash, error) {
-	var casmClassHash felt.CasmClassHash
-	err := r.Get(db.ClassHashToCasmHashV2Key(classHash), func(data []byte) error {
-		casmClassHash.Unmarshal(data)
-		return nil
-	})
-	return casmClassHash, err
-}
-
-func WriteCasmClassHashV2(
-	w db.KeyValueWriter,
-	classHash *felt.SierraClassHash,
-	casmClassHash *felt.CasmClassHash,
-) error {
-	return w.Put(db.ClassHashToCasmHashV2Key(classHash), casmClassHash.Marshal())
-}
-
-func DeleteCasmClassHashV2(
-	w db.KeyValueWriter,
-	classHash *felt.SierraClassHash,
-) error {
-	return w.Delete(db.ClassHashToCasmHashV2Key(classHash))
-}
diff --git a/core/common_state.go b/core/common_state.go
index 91a2f5c008..e30351b725 100644
--- a/core/common_state.go
+++ b/core/common_state.go
@@ -4,7 +4,7 @@ import (
 	"github.com/NethermindEth/juno/core/felt"
 )
 
-//go:generate mockgen -destination=../mocks/mock_common_state.go -package=mocks github.com/NethermindEth/juno/core CommonState
+//go:generate mockgen -destination=../../mocks/mock_commonstate_reader.go -package=mocks github.com/NethermindEth/juno/core CommonStateReader
 type CommonState interface {
 	CommonStateReader
 
@@ -32,6 +32,4 @@ type CommonStateReader interface {
 	ClassTrie() (CommonTrie, error)
 	ContractTrie() (CommonTrie, error)
 	ContractStorageTrie(addr *felt.Felt) (CommonTrie, error)
-	CompiledClassHash(classHash *felt.SierraClassHash) (felt.CasmClassHash, error)
-	CompiledClassHashV2(classHash *felt.SierraClassHash) (felt.CasmClassHash, error)
 }
diff --git a/core/felt/hash.go b/core/felt/hash.go
index f890d2c61e..167a3b39e7 100644
--- a/core/felt/hash.go
+++ b/core/felt/hash.go
@@ -18,14 +18,6 @@ func (h *Hash) MarshalJSON() ([]byte, error) {
 	return (*Felt)(h).MarshalJSON()
 }
 
-func (h *Hash) Marshal() []byte {
-	return (*Felt)(h).Marshal()
-}
-
-func (h *Hash) Unmarshal(e []byte) {
-	(*Felt)(h).Unmarshal(e)
-}
-
 type ClassHash Hash
 
 func (h *ClassHash) String() string {
@@ -40,14 +32,6 @@ func (h *ClassHash) MarshalJSON() ([]byte, error) {
 	return (*Hash)(h).MarshalJSON()
 }
 
-func (h *ClassHash) Marshal() []byte {
-	return (*Hash)(h).Marshal()
-}
-
-func (h *ClassHash) Unmarshal(e []byte) {
-	(*Hash)(h).Unmarshal(e)
-}
-
 type SierraClassHash ClassHash
 
 func (h *SierraClassHash) String() string {
@@ -62,14 +46,6 @@ func (h *SierraClassHash) MarshalJSON() ([]byte, error) {
 	return (*ClassHash)(h).MarshalJSON()
 }
 
-func (h *SierraClassHash) Marshal() []byte {
-	return (*ClassHash)(h).Marshal()
-}
-
-func (h *SierraClassHash) Unmarshal(e []byte) {
-	(*ClassHash)(h).Unmarshal(e)
-}
-
 type CasmClassHash ClassHash
 
 func (h *CasmClassHash) String() string {
@@ -84,14 +60,6 @@ func (h *CasmClassHash) MarshalJSON() ([]byte, error) {
 	return (*ClassHash)(h).MarshalJSON()
 }
 
-func (h *CasmClassHash) Marshal() []byte {
-	return (*ClassHash)(h).Marshal()
-}
-
-func (h *CasmClassHash) Unmarshal(e []byte) {
-	(*ClassHash)(h).Unmarshal(e)
-}
-
 type TransactionHash Hash
 
 func (h *TransactionHash) String() string {
diff --git a/core/mocks/mock_commonstate_reader.go b/core/mocks/mock_commonstate_reader.go
new file mode 100644
index 0000000000..f28dd351e5
--- /dev/null
+++ b/core/mocks/mock_commonstate_reader.go
@@ -0,0 +1,147 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/NethermindEth/juno/core/state/commonstate (interfaces: StateReader)
+//
+// Generated by this command:
+//
+//	mockgen -destination=../../mocks/mock_commonstate_reader.go -package=mocks github.com/NethermindEth/juno/core/state/commonstate StateReader
+//
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+	reflect "reflect"
+
+	core "github.com/NethermindEth/juno/core"
+	felt "github.com/NethermindEth/juno/core/felt"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockStateReader is a mock of StateReader interface.
+type MockStateReader struct {
+	ctrl     *gomock.Controller
+	recorder *MockStateReaderMockRecorder
+	isgomock struct{}
+}
+
+// MockStateReaderMockRecorder is the mock recorder for MockStateReader.
+type MockStateReaderMockRecorder struct {
+	mock *MockStateReader
+}
+
+// NewMockStateReader creates a new mock instance.
+func NewMockStateReader(ctrl *gomock.Controller) *MockStateReader {
+	mock := &MockStateReader{ctrl: ctrl}
+	mock.recorder = &MockStateReaderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockStateReader) EXPECT() *MockStateReaderMockRecorder {
+	return m.recorder
+}
+
+// Class mocks base method.
+func (m *MockStateReader) Class(classHash *felt.Felt) (*core.DeclaredClassDefinition, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Class", classHash)
+	ret0, _ := ret[0].(*core.DeclaredClassDefinition)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Class indicates an expected call of Class.
+func (mr *MockStateReaderMockRecorder) Class(classHash any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Class", reflect.TypeOf((*MockStateReader)(nil).Class), classHash)
+}
+
+// ClassTrie mocks base method.
+func (m *MockStateReader) ClassTrie() (core.CommonTrie, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ClassTrie")
+	ret0, _ := ret[0].(core.CommonTrie)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ClassTrie indicates an expected call of ClassTrie.
+func (mr *MockStateReaderMockRecorder) ClassTrie() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClassTrie", reflect.TypeOf((*MockStateReader)(nil).ClassTrie))
+}
+
+// ContractClassHash mocks base method.
+func (m *MockStateReader) ContractClassHash(addr *felt.Felt) (felt.Felt, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContractClassHash", addr)
+	ret0, _ := ret[0].(felt.Felt)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ContractClassHash indicates an expected call of ContractClassHash.
+func (mr *MockStateReaderMockRecorder) ContractClassHash(addr any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractClassHash", reflect.TypeOf((*MockStateReader)(nil).ContractClassHash), addr)
+}
+
+// ContractNonce mocks base method.
+func (m *MockStateReader) ContractNonce(addr *felt.Felt) (felt.Felt, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContractNonce", addr)
+	ret0, _ := ret[0].(felt.Felt)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ContractNonce indicates an expected call of ContractNonce.
+func (mr *MockStateReaderMockRecorder) ContractNonce(addr any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractNonce", reflect.TypeOf((*MockStateReader)(nil).ContractNonce), addr)
+}
+
+// ContractStorage mocks base method.
+func (m *MockStateReader) ContractStorage(addr, key *felt.Felt) (felt.Felt, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContractStorage", addr, key)
+	ret0, _ := ret[0].(felt.Felt)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ContractStorage indicates an expected call of ContractStorage.
+func (mr *MockStateReaderMockRecorder) ContractStorage(addr, key any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractStorage", reflect.TypeOf((*MockStateReader)(nil).ContractStorage), addr, key)
+}
+
+// ContractStorageTrie mocks base method.
+func (m *MockStateReader) ContractStorageTrie(addr *felt.Felt) (core.CommonTrie, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContractStorageTrie", addr)
+	ret0, _ := ret[0].(core.CommonTrie)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ContractStorageTrie indicates an expected call of ContractStorageTrie.
+func (mr *MockStateReaderMockRecorder) ContractStorageTrie(addr any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractStorageTrie", reflect.TypeOf((*MockStateReader)(nil).ContractStorageTrie), addr)
+}
+
+// ContractTrie mocks base method.
+func (m *MockStateReader) ContractTrie() (core.CommonTrie, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContractTrie")
+	ret0, _ := ret[0].(core.CommonTrie)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ContractTrie indicates an expected call of ContractTrie.
+func (mr *MockStateReaderMockRecorder) ContractTrie() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractTrie", reflect.TypeOf((*MockStateReader)(nil).ContractTrie))
+}
diff --git a/core/pending.go b/core/pending.go
index 8f0c620edf..86a92a140d 100644
--- a/core/pending.go
+++ b/core/pending.go
@@ -136,10 +136,7 @@ func (p *Pending) ReceiptByHash(
 	return nil, nil, 0, ErrTransactionReceiptNotFound
 }
 
-func (p *Pending) PendingStateBeforeIndex(
-	baseState CommonStateReader,
-	index uint,
-) (CommonStateReader, error) {
+func (p *Pending) PendingStateBeforeIndex(baseState CommonStateReader, index uint) (CommonStateReader, error) {
 	return nil, ErrPendingStateBeforeIndexNotSupported
 }
 
diff --git a/core/pending_state.go b/core/pending_state.go
index 4c6b23d4b0..7252f0dd4c 100644
--- a/core/pending_state.go
+++ b/core/pending_state.go
@@ -76,25 +76,6 @@ func (p *PendingState) Class(classHash *felt.Felt) (*DeclaredClassDefinition, er
 	return p.head.Class(classHash)
 }
 
-func (p *PendingState) CompiledClassHash(
-	classHash *felt.SierraClassHash,
-) (felt.CasmClassHash, error) {
-	classHashFelt := felt.Felt(*classHash)
-	if casmHash, found := p.stateDiff.DeclaredV1Classes[classHashFelt]; found {
-		return felt.CasmClassHash(*casmHash), nil
-	}
-	return p.head.CompiledClassHash(classHash)
-}
-
-func (p *PendingState) CompiledClassHashV2(
-	classHash *felt.SierraClassHash,
-) (felt.CasmClassHash, error) {
-	if casmHash, found := p.stateDiff.MigratedClasses[*classHash]; found {
-		return casmHash, nil
-	}
-	return p.head.CompiledClassHashV2(classHash)
-}
-
 func (p *PendingState) ClassTrie() (CommonTrie, error) {
 	return nil, ErrHistoricalTrieNotSupported
 }
diff --git a/core/pending_state_test.go b/core/pending_state_test.go
index 8f92289edb..f91c5adcb0 100644
--- a/core/pending_state_test.go
+++ b/core/pending_state_test.go
@@ -15,7 +15,7 @@ func TestPendingState(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	t.Cleanup(mockCtrl.Finish)
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	deployedAddr := felt.NewRandom[felt.Felt]()
 	deployedAddr2 := felt.NewRandom[felt.Felt]()
diff --git a/core/state.go b/core/state.go
index 26291be81d..996aa4940b 100644
--- a/core/state.go
+++ b/core/state.go
@@ -43,8 +43,7 @@ type StateReader interface {
 	ContractNonce(addr *felt.Felt) (felt.Felt, error)
 	ContractStorage(addr, key *felt.Felt) (felt.Felt, error)
 	Class(classHash *felt.Felt) (*DeclaredClassDefinition, error)
-	CompiledClassHash(classHash *felt.SierraClassHash) (felt.CasmClassHash, error)
-	CompiledClassHashV2(classHash *felt.SierraClassHash) (felt.CasmClassHash, error)
+
 	ClassTrie() (CommonTrie, error)
 	ContractTrie() (CommonTrie, error)
 	ContractStorageTrie(addr *felt.Felt) (CommonTrie, error)
@@ -369,37 +368,6 @@ func (s *State) Class(classHash *felt.Felt) (*DeclaredClassDefinition, error) {
 	return class, err
 }
 
-func (s *State) CompiledClassHash(
-	classHash *felt.SierraClassHash,
-) (felt.CasmClassHash, error) {
-	classTrie, closer, err := s.classesTrie()
-	if err != nil {
-		return felt.CasmClassHash{}, err
-	}
-	defer func() {
-		if closeErr := closer(); closeErr != nil {
-			_ = closeErr
-		}
-	}()
-
-	casmHash, err := classTrie.Get((*felt.Felt)(classHash))
-	if err != nil {
-		return felt.CasmClassHash{}, err
-	}
-
-	if casmHash.IsZero() {
-		return felt.CasmClassHash{}, errors.New("casm hash not found")
-	}
-
-	return felt.CasmClassHash(casmHash), nil
-}
-
-func (s *State) CompiledClassHashV2(
-	classHash *felt.SierraClassHash,
-) (felt.CasmClassHash, error) {
-	return GetCasmClassHashV2(s.txn, classHash)
-}
-
 func (s *State) updateStorageBuffered(contractAddr *felt.Felt, updateDiff map[felt.Felt]*felt.Felt, blockNumber uint64, logChanges bool) (
 	*db.BufferBatch, error,
 ) {
@@ -738,11 +706,6 @@ func (s *State) removeDeclaredClasses(
 			if _, err = classesTrie.Put(cHash, &felt.Zero); err != nil {
 				return err
 			}
-
-			sierraClassHash := felt.SierraClassHash(*cHash)
-			if err = DeleteCasmClassHashV2(s.txn, &sierraClassHash); err != nil {
-				return fmt.Errorf("delete CASM class hash V2 for class %s: %v", cHash, err)
-			}
 		}
 	}
 	return classesCloser()
diff --git a/core/state/history.go b/core/state/history.go
index 25a9f9e990..a128dff1bd 100644
--- a/core/state/history.go
+++ b/core/state/history.go
@@ -109,15 +109,3 @@ func (s *StateHistory) ContractTrie() (core.CommonTrie, error) {
 func (s *StateHistory) ContractStorageTrie(addr *felt.Felt) (core.CommonTrie, error) {
 	return nil, ErrHistoricalTrieNotSupported
 }
-
-func (s *StateHistory) CompiledClassHash(
-	classHash *felt.SierraClassHash,
-) (felt.CasmClassHash, error) {
-	return s.state.CompiledClassHash(classHash)
-}
-
-func (s *StateHistory) CompiledClassHashV2(
-	classHash *felt.SierraClassHash,
-) (felt.CasmClassHash, error) {
-	return s.state.CompiledClassHashV2(classHash)
-}
diff --git a/core/state/history_test.go b/core/state/history_test.go
index a79f505f2d..7b12aad4ac 100644
--- a/core/state/history_test.go
+++ b/core/state/history_test.go
@@ -19,14 +19,6 @@ func TestNewStateHistory(t *testing.T) {
 		assert.Equal(t, uint64(0), history.blockNum)
 		assert.NotNil(t, history.state)
 	})
-
-	t.Run("bigger state root", func(t *testing.T) {
-		invalidRoot := felt.NewUnsafeFromString[felt.Felt]("0x999")
-		_, err := NewStateHistory(1, invalidRoot, stateDB)
-		// error is returned only for the triedb
-		// in path scheme
-		assert.NoError(t, err)
-	})
 }
 
 func TestStateHistoryContractOperations(t *testing.T) {
diff --git a/core/state/object.go b/core/state/object.go
index 1cfb2b5ddd..2afc6b9c1e 100644
--- a/core/state/object.go
+++ b/core/state/object.go
@@ -49,6 +49,7 @@ func (s *stateObject) getStorage(key *felt.Felt) (felt.Felt, error) {
 		return felt.Zero, err
 	}
 
+	// TODO(maksym): test if this works instead of reading from disk
 	path := tr.FeltToPath(key)
 	reader, err := s.state.db.triedb.NodeReader(
 		trieutils.NewContractStorageTrieID(s.state.initRoot, s.addr),
diff --git a/core/state/state.go b/core/state/state.go
index 6a018802c8..7791203880 100644
--- a/core/state/state.go
+++ b/core/state/state.go
@@ -73,7 +73,7 @@ func New(stateRoot *felt.Felt, db *StateDB) (*State, error) {
 	if err != nil {
 		return nil, err
 	}
-
+	fmt.Println("contractTrie", contractTrie, err)
 	classTrie, err := db.ClassTrie(stateRoot)
 	if err != nil {
 		return nil, err
@@ -158,27 +158,6 @@ func (s *State) ContractStorageTrie(addr *felt.Felt) (core.CommonTrie, error) {
 	return s.db.ContractStorageTrie(&s.initRoot, addr)
 }
 
-func (s *State) CompiledClassHash(
-	classHash *felt.SierraClassHash,
-) (felt.CasmClassHash, error) {
-	casmHash, err := s.classTrie.Get((*felt.Felt)(classHash))
-	if err != nil {
-		return felt.CasmClassHash{}, err
-	}
-
-	if casmHash.IsZero() {
-		return felt.CasmClassHash{}, errors.New("casm hash not found")
-	}
-
-	return felt.CasmClassHash(casmHash), nil
-}
-
-func (s *State) CompiledClassHashV2(
-	classHash *felt.SierraClassHash,
-) (felt.CasmClassHash, error) {
-	return core.GetCasmClassHashV2(s.db.disk, classHash)
-}
-
 // Returns the state commitment
 func (s *State) Commitment() (felt.Felt, error) {
 	contractRoot, err := s.contractTrie.Hash()
@@ -430,6 +409,7 @@ func (s *State) commit() (felt.Felt, stateUpdate, error) {
 
 	for i, addr := range keys {
 		obj := s.stateObjects[addr]
+		idx := i
 		p.Go(func() error {
 			// Object is marked as delete
 			if obj == nil {
@@ -445,7 +425,7 @@ func (s *State) commit() (felt.Felt, stateUpdate, error) {
 				return err
 			}
 
-			comms[i] = obj.commitment()
+			comms[idx] = obj.commitment()
 			return nil
 		})
 	}
@@ -523,64 +503,61 @@ func (s *State) flush(
 	classes map[felt.Felt]core.ClassDefinition,
 	storeHistory bool,
 ) error {
-	p := pool.New().WithMaxGoroutines(runtime.GOMAXPROCS(0)).WithErrors()
-
-	p.Go(func() error {
-		return s.db.triedb.Update(&update.curComm, &update.prevComm, blockNum, update.classNodes, update.contractNodes)
-	})
-
 	batch := s.db.disk.NewBatch()
-	p.Go(func() error {
-		for addr, obj := range s.stateObjects {
-			if obj == nil { // marked as deleted
-				if err := DeleteContract(batch, &addr); err != nil {
-					return err
-				}
-
-				// TODO(weiihann): handle hash-based, and there should be better ways of doing this
-				if err := trieutils.DeleteStorageNodesByPath(batch, addr); err != nil {
-					return err
-				}
-			} else { // updated
-				if err := WriteContract(batch, &addr, obj.contract); err != nil {
-					return err
-				}
+	if err := s.db.triedb.Update(
+		&update.curComm,
+		&update.prevComm,
+		blockNum,
+		update.classNodes,
+		update.contractNodes,
+		batch,
+	); err != nil {
+		return err
+	}
 
-				if storeHistory {
-					for key, val := range obj.dirtyStorage {
-						if err := WriteStorageHistory(batch, &addr, &key, blockNum, val); err != nil {
-							return err
-						}
-					}
+	for addr, obj := range s.stateObjects {
+		if obj == nil { // marked as deleted
+			if err := DeleteContract(batch, &addr); err != nil {
+				return err
+			}
 
-					if err := WriteNonceHistory(batch, &addr, blockNum, &obj.contract.Nonce); err != nil {
-						return err
-					}
+			// TODO(weiihann): handle hash-based, and there should be better ways of doing this
+			if err := trieutils.DeleteStorageNodesByPath(batch, addr); err != nil {
+				return err
+			}
+		} else { // updated
+			if err := WriteContract(batch, &addr, obj.contract); err != nil {
+				return err
+			}
 
-					if err := WriteClassHashHistory(batch, &addr, blockNum, &obj.contract.ClassHash); err != nil {
+			if storeHistory {
+				for key, val := range obj.dirtyStorage {
+					if err := WriteStorageHistory(batch, &addr, &key, blockNum, val); err != nil {
 						return err
 					}
 				}
-			}
-		}
 
-		for classHash, class := range classes {
-			if class == nil { // mark as deleted
-				if err := DeleteClass(batch, &classHash); err != nil {
+				if err := WriteNonceHistory(batch, &addr, blockNum, &obj.contract.Nonce); err != nil {
 					return err
 				}
-			} else {
-				if err := WriteClass(batch, &classHash, class, blockNum); err != nil {
+
+				if err := WriteClassHashHistory(batch, &addr, blockNum, &obj.contract.ClassHash); err != nil {
 					return err
 				}
 			}
 		}
+	}
 
-		return nil
-	})
-
-	if err := p.Wait(); err != nil {
-		return err
+	for classHash, class := range classes {
+		if class == nil { // mark as deleted
+			if err := DeleteClass(batch, &classHash); err != nil {
+				return err
+			}
+		} else {
+			if err := WriteClass(batch, &classHash, class, blockNum); err != nil {
+				return err
+			}
+		}
 	}
 
 	return batch.Write()
@@ -609,7 +586,6 @@ func (s *State) verifyComm(comm *felt.Felt) error {
 	if err != nil {
 		return err
 	}
-
 	if !curComm.Equal(comm) {
 		return fmt.Errorf("state commitment mismatch: %v (expected) != %v (actual)", comm, &curComm)
 	}
diff --git a/core/state/statefactory/state_factory.go b/core/state/statefactory/state_factory.go
index f9a9b8add2..9193bdb1ee 100644
--- a/core/state/statefactory/state_factory.go
+++ b/core/state/statefactory/state_factory.go
@@ -31,10 +31,7 @@ func NewStateFactory(
 	}, nil
 }
 
-func (sf *StateFactory) NewState(
-	stateRoot *felt.Felt,
-	txn db.IndexedBatch,
-) (core.CommonState, error) {
+func (sf *StateFactory) NewState(stateRoot *felt.Felt, txn db.IndexedBatch) (core.CommonState, error) {
 	if !sf.UseNewState {
 		deprecatedState := core.NewState(txn)
 		return deprecatedState, nil
diff --git a/core/state_snapshot.go b/core/state_snapshot.go
index 9b976fe25b..cf9b04f70c 100644
--- a/core/state_snapshot.go
+++ b/core/state_snapshot.go
@@ -94,18 +94,6 @@ func (s *stateSnapshot) Class(classHash *felt.Felt) (*DeclaredClassDefinition, e
 	return declaredClass, nil
 }
 
-func (s *stateSnapshot) CompiledClassHash(
-	classHash *felt.SierraClassHash,
-) (felt.CasmClassHash, error) {
-	return s.state.CompiledClassHash(classHash)
-}
-
-func (s *stateSnapshot) CompiledClassHashV2(
-	classHash *felt.SierraClassHash,
-) (felt.CasmClassHash, error) {
-	return s.state.CompiledClassHashV2(classHash)
-}
-
 func (s *stateSnapshot) ClassTrie() (CommonTrie, error) {
 	return nil, ErrHistoricalTrieNotSupported
 }
diff --git a/core/trie2/trie.go b/core/trie2/trie.go
index aa67aa2624..cc58adf368 100644
--- a/core/trie2/trie.go
+++ b/core/trie2/trie.go
@@ -76,6 +76,7 @@ func New(
 	}
 
 	root, err := tr.resolveNode(nil, Path{})
+	fmt.Println("root", root, err)
 	if err != nil && !errors.Is(err, db.ErrKeyNotFound) {
 		return nil, err
 	}
diff --git a/core/trie2/triedb/database.go b/core/trie2/triedb/database.go
index 414037a8d0..d2020c30e1 100644
--- a/core/trie2/triedb/database.go
+++ b/core/trie2/triedb/database.go
@@ -33,9 +33,9 @@ type Database struct {
 func New(disk db.KeyValueStore, config *Config) (*Database, error) {
 	var triedb database.TrieDB
 	var err error
-	// Default to raw config if not provided
+	// Default to path config if not provided
 	if config == nil {
-		triedb = rawdb.New(disk)
+		triedb = rawdb.New(disk, nil)
 	} else if config.PathConfig != nil {
 		triedb, err = pathdb.New(disk, config.PathConfig)
 		if err != nil {
@@ -43,8 +43,6 @@ func New(disk db.KeyValueStore, config *Config) (*Database, error) {
 		}
 	} else if config.HashConfig != nil {
 		triedb = hashdb.New(disk, config.HashConfig)
-	} else if config.RawConfig != nil {
-		triedb = rawdb.New(disk)
 	}
 
 	return &Database{
@@ -59,6 +57,7 @@ func (d *Database) Update(
 	blockNum uint64,
 	mergeClassNodes,
 	mergeContractNodes *trienode.MergeNodeSet,
+	w db.KeyValueWriter,
 ) error {
 	switch td := d.triedb.(type) {
 	case *pathdb.Database:
@@ -66,7 +65,7 @@ func (d *Database) Update(
 	case *hashdb.Database:
 		return td.Update(root, parent, blockNum, mergeClassNodes, mergeContractNodes)
 	case *rawdb.Database:
-		return td.Update(root, parent, blockNum, mergeClassNodes, mergeContractNodes)
+		return td.Update(root, parent, blockNum, mergeClassNodes, mergeContractNodes, w)
 	default:
 		return fmt.Errorf("unsupported trie db type: %T", td)
 	}
@@ -85,12 +84,8 @@ func (d *Database) Scheme() string {
 		return RawScheme
 	} else if d.config.PathConfig != nil {
 		return PathScheme
-	} else if d.config.HashConfig != nil {
-		return HashScheme
-	} else if d.config.RawConfig != nil {
-		return RawScheme
 	}
-	return RawScheme
+	return HashScheme
 }
 
 func (d *Database) NodeReader(id trieutils.TrieID) (database.NodeReader, error) {
diff --git a/core/trie2/triedb/pathdb/disklayer.go b/core/trie2/triedb/pathdb/disklayer.go
index 029dfc366b..dcfb30b847 100644
--- a/core/trie2/triedb/pathdb/disklayer.go
+++ b/core/trie2/triedb/pathdb/disklayer.go
@@ -86,9 +86,11 @@ func (dl *diskLayer) node(id trieutils.TrieID, owner *felt.Felt, path *trieutils
 	if err != nil {
 		return nil, err
 	}
+	blobCopy := make([]byte, len(blob))
+	copy(blobCopy, blob)
 
-	dl.cleans.putNode(owner, path, isClass, blob)
-	return blob, nil
+	dl.cleans.putNode(owner, path, isClass, blobCopy)
+	return blobCopy, nil
 }
 
 func (dl *diskLayer) update(root *felt.Felt, id, block uint64, nodes *nodeSet) diffLayer {
diff --git a/core/trie2/triedb/pathdb/journal.go b/core/trie2/triedb/pathdb/journal.go
index 99d83d21bd..3a721b69c2 100644
--- a/core/trie2/triedb/pathdb/journal.go
+++ b/core/trie2/triedb/pathdb/journal.go
@@ -272,7 +272,7 @@ func (d *Database) loadLayers(enc []byte) (layer, error) {
 }
 
 func (d *Database) getStateRoot() felt.Felt {
-	encContractRoot, err := trieutils.GetNodeByPath(
+	encContractRootRaw, err := trieutils.GetNodeByPath(
 		d.disk,
 		db.ContractTrieContract,
 		&felt.Zero,
@@ -282,8 +282,10 @@ func (d *Database) getStateRoot() felt.Felt {
 	if err != nil {
 		return felt.Zero
 	}
+	encContractRoot := make([]byte, len(encContractRootRaw))
+	copy(encContractRoot, encContractRootRaw)
 
-	encStorageRoot, err := trieutils.GetNodeByPath(
+	encStorageRootRaw, err := trieutils.GetNodeByPath(
 
 		d.disk,
 		db.ClassTrie,
@@ -294,6 +296,8 @@ func (d *Database) getStateRoot() felt.Felt {
 	if err != nil {
 		return felt.Zero
 	}
+	encStorageRoot := make([]byte, len(encStorageRootRaw))
+	copy(encStorageRoot, encStorageRootRaw)
 
 	contractRootNode, err := trienode.DecodeNode(encContractRoot, &felt.Zero, 0, contractClassTrieHeight)
 	if err != nil {
diff --git a/core/trie2/triedb/rawdb/cache.go b/core/trie2/triedb/rawdb/cache.go
new file mode 100644
index 0000000000..3c165cc6f2
--- /dev/null
+++ b/core/trie2/triedb/rawdb/cache.go
@@ -0,0 +1,60 @@
+package rawdb
+
+import (
+	"math"
+
+	"github.com/NethermindEth/juno/core/felt"
+	"github.com/NethermindEth/juno/core/trie2/trieutils"
+	"github.com/VictoriaMetrics/fastcache"
+)
+
+const nodeCacheSize = ownerSize + trieutils.PathSize + 1
+
+type trieType byte
+
+const (
+	contract trieType = iota
+	class
+)
+
+// Stores committed trie nodes in memory
+type cleanCache struct {
+	cache *fastcache.Cache // map[nodeKey]node
+}
+
+// Creates a new clean cache with the given size.
+// The size is the maximum size of the cache in bytes.
+func newCleanCache(size uint64) cleanCache {
+	if size > uint64(math.MaxInt) {
+		panic("cache size too large: uint64 to int conversion would overflow")
+	}
+	return cleanCache{
+		cache: fastcache.New(int(size)),
+	}
+}
+
+func (c *cleanCache) putNode(owner *felt.Felt, path *trieutils.Path, isClass bool, blob []byte) {
+	c.cache.Set(nodeKey(owner, path, isClass), blob)
+}
+
+func (c *cleanCache) getNode(owner *felt.Felt, path *trieutils.Path, isClass bool) []byte {
+	return c.cache.Get(nil, nodeKey(owner, path, isClass))
+}
+
+func (c *cleanCache) deleteNode(owner *felt.Felt, path *trieutils.Path, isClass bool) {
+	c.cache.Del(nodeKey(owner, path, isClass))
+}
+
+// key = owner (32 bytes) + path (20 bytes) + trie type (1 byte)
+func nodeKey(owner *felt.Felt, path *trieutils.Path, isClass bool) []byte {
+	key := make([]byte, nodeCacheSize)
+	ownerBytes := owner.Bytes()
+	copy(key[:felt.Bytes], ownerBytes[:])
+	copy(key[felt.Bytes:felt.Bytes+trieutils.PathSize], path.EncodedBytes())
+
+	if isClass {
+		key[nodeCacheSize-1] = byte(class)
+	}
+
+	return key
+}
diff --git a/core/trie2/triedb/rawdb/database.go b/core/trie2/triedb/rawdb/database.go
index 7a8faadb26..9141572d0c 100644
--- a/core/trie2/triedb/rawdb/database.go
+++ b/core/trie2/triedb/rawdb/database.go
@@ -10,19 +10,32 @@ import (
 	"github.com/NethermindEth/juno/utils"
 )
 
-type Config struct{}
+type Config struct {
+	CleanCacheSize uint64 // Maximum size (in bytes) for caching clean nodes
+}
 
 type Database struct {
 	disk db.KeyValueStore
 
 	lock sync.RWMutex
 	log  utils.SimpleLogger
+
+	config     Config
+	cleanCache *cleanCache
 }
 
-func New(disk db.KeyValueStore) *Database {
+func New(disk db.KeyValueStore, config *Config) *Database {
+	if config == nil {
+		config = &Config{
+			CleanCacheSize: 16 * utils.Megabyte,
+		}
+	}
+	cleanCache := newCleanCache(config.CleanCacheSize)
 	return &Database{
-		disk: disk,
-		log:  utils.NewNopZapLogger(),
+		disk:       disk,
+		config:     *config,
+		cleanCache: &cleanCache,
+		log:        utils.NewNopZapLogger(),
 	}
 }
 
@@ -34,11 +47,19 @@ func (d *Database) readNode(
 ) ([]byte, error) {
 	d.lock.RLock()
 	defer d.lock.RUnlock()
+
+	isClass := id.Type() == trieutils.Class
+	blob := d.cleanCache.getNode(owner, path, isClass)
+	if blob != nil {
+		return blob, nil
+	}
+
 	blob, err := trieutils.GetNodeByPath(d.disk, id.Bucket(), owner, path, isLeaf)
 	if err != nil {
 		return nil, err
 	}
 
+	d.cleanCache.putNode(owner, path, isClass, blob)
 	return blob, nil
 }
 
@@ -63,11 +84,11 @@ func (d *Database) Update(
 	blockNum uint64,
 	mergedClassNodes *trienode.MergeNodeSet,
 	mergedContractNodes *trienode.MergeNodeSet,
+	batch db.KeyValueWriter,
 ) error {
 	d.lock.Lock()
 	defer d.lock.Unlock()
 
-	batch := d.disk.NewBatch()
 	var classNodes classNodesMap
 	var contractNodes contractNodesMap
 	var contractStorageNodes contractStorageNodesMap
@@ -80,26 +101,26 @@ func (d *Database) Update(
 	}
 
 	for path, n := range classNodes {
-		if err := d.updateNode(batch, db.ClassTrie, &felt.Zero, &path, n); err != nil {
+		if err := d.updateNode(batch, db.ClassTrie, &felt.Zero, &path, n, true); err != nil {
 			return err
 		}
 	}
 
 	for path, n := range contractNodes {
-		if err := d.updateNode(batch, db.ContractTrieContract, &felt.Zero, &path, n); err != nil {
+		if err := d.updateNode(batch, db.ContractTrieContract, &felt.Zero, &path, n, false); err != nil {
 			return err
 		}
 	}
 
 	for owner, nodes := range contractStorageNodes {
 		for path, n := range nodes {
-			if err := d.updateNode(batch, db.ContractTrieStorage, &owner, &path, n); err != nil {
+			if err := d.updateNode(batch, db.ContractTrieStorage, &owner, &path, n, false); err != nil {
 				return err
 			}
 		}
 	}
 
-	return batch.Write()
+	return nil
 }
 
 func (d *Database) updateNode(
@@ -108,11 +129,13 @@ func (d *Database) updateNode(
 	owner *felt.Felt,
 	path *trieutils.Path,
 	n trienode.TrieNode,
+	isClass bool,
 ) error {
 	if _, deleted := n.(*trienode.DeletedNode); deleted {
 		if err := trieutils.DeleteNodeByPath(batch, bucket, owner, path, n.IsLeaf()); err != nil {
 			return err
 		}
+		d.cleanCache.deleteNode(owner, path, isClass)
 	} else {
 		if err := trieutils.WriteNodeByPath(
 			batch,
@@ -124,6 +147,7 @@ func (d *Database) updateNode(
 		); err != nil {
 			return err
 		}
+		d.cleanCache.putNode(owner, path, isClass, n.Blob())
 	}
 	return nil
 }
diff --git a/core/trie2/triedb/rawdb/types.go b/core/trie2/triedb/rawdb/types.go
index 83166bf671..abebc7a3c2 100644
--- a/core/trie2/triedb/rawdb/types.go
+++ b/core/trie2/triedb/rawdb/types.go
@@ -11,3 +11,5 @@ type (
 	contractNodesMap        = map[trieutils.Path]trienode.TrieNode
 	contractStorageNodesMap = map[felt.Felt]map[trieutils.Path]trienode.TrieNode
 )
+
+const ownerSize = felt.Bytes
diff --git a/core/trie2/trieutils/accessors.go b/core/trie2/trieutils/accessors.go
index ed049b81b4..ff04845b23 100644
--- a/core/trie2/trieutils/accessors.go
+++ b/core/trie2/trieutils/accessors.go
@@ -130,7 +130,7 @@ func GetNodeByHash(r db.KeyValueReader, bucket db.Bucket, owner *felt.Felt, path
 	var res []byte
 	if err := r.Get(nodeKeyByHash(bucket, owner, path, hash, isLeaf),
 		func(value []byte) error {
-			res = slices.Clone(value)
+			res = append([]byte(nil), value...)
 			return nil
 		},
 	); err != nil {
diff --git a/core/version.go b/core/version.go
index c43ebdf4bd..28234a21c3 100644
--- a/core/version.go
+++ b/core/version.go
@@ -12,8 +12,7 @@ var (
 	Ver0_13_2 = semver.MustParse("0.13.2")
 	Ver0_13_4 = semver.MustParse("0.13.4")
 	Ver0_14_0 = semver.MustParse("0.14.0")
-	Ver0_14_1 = semver.MustParse("0.14.1")
-	LatestVer = Ver0_14_1
+	LatestVer = Ver0_14_0
 )
 
 // ParseBlockVersion computes the block version, defaulting to "0.0.0" for empty strings
diff --git a/db/buckets.go b/db/buckets.go
index 31e749c9d0..51cf37088c 100644
--- a/db/buckets.go
+++ b/db/buckets.go
@@ -40,7 +40,7 @@ const (
 	MempoolNode
 	ClassTrie              // ClassTrie + nodetype + path + pathlength -> Trie Node
 	ContractTrieContract   // ContractTrieContract + nodetype + path + pathlength -> Trie Node
-	ContractTrieStorage    // ContractTrieStorage + owner + nodetype + path + pathlength -> Trie Node
+	ContractTrieStorage    // ContractTrieStorage + nodetype + owner + path + pathlength -> Trie Node
 	Contract               // Contract + ContractAddr -> Contract
 	StateHashToTrieRoots   // StateHash -> ClassRootHash + ContractRootHash
 	StateID                // StateID + root hash -> state id
@@ -48,7 +48,6 @@ const (
 	TrieJournal            // TrieJournal -> journal
 	AggregatedBloomFilters // maps block range to AggregatedBloomFilter
 	RunningEventFilter     // aggregated filter not full yet
-	ClassHashToCasmHashV2  // blake2s casm class hashes of the all sierra classes
 )
 
 // Key flattens a prefix and series of byte arrays into a single []byte.
diff --git a/db/buckets_enumer.go b/db/buckets_enumer.go
index edd13a2b46..60098cd07d 100644
--- a/db/buckets_enumer.go
+++ b/db/buckets_enumer.go
@@ -7,11 +7,11 @@ import (
 	"strings"
 )
 
-const _BucketName = "StateTriePeerContractClassHashContractStorageClassContractNonceChainHeightBlockHeaderNumbersByHashBlockHeadersByNumberTransactionBlockNumbersAndIndicesByHashTransactionsByBlockNumberAndIndexReceiptsByBlockNumberAndIndexStateUpdatesByBlockNumberClassesTrieContractStorageHistoryContractNonceHistoryContractClassHashHistoryContractDeploymentHeightL1HeightSchemaVersionUnusedBlockCommitmentsTemporarySchemaIntermediateStateL1HandlerTxnHashByMsgHashMempoolHeadMempoolTailMempoolLengthMempoolNodeClassTrieContractTrieContractContractTrieStorageContractStateHashToTrieRootsStateIDPersistedStateIDTrieJournalAggregatedBloomFiltersRunningEventFilterClassHashToCasmHashV2"
+const _BucketName = "StateTriePeerContractClassHashContractStorageClassContractNonceChainHeightBlockHeaderNumbersByHashBlockHeadersByNumberTransactionBlockNumbersAndIndicesByHashTransactionsByBlockNumberAndIndexReceiptsByBlockNumberAndIndexStateUpdatesByBlockNumberClassesTrieContractStorageHistoryContractNonceHistoryContractClassHashHistoryContractDeploymentHeightL1HeightSchemaVersionUnusedBlockCommitmentsTemporarySchemaIntermediateStateL1HandlerTxnHashByMsgHashMempoolHeadMempoolTailMempoolLengthMempoolNodeClassTrieContractTrieContractContractTrieStorageContractStateHashToTrieRootsStateIDPersistedStateIDTrieJournalAggregatedBloomFiltersRunningEventFilter"
 
-var _BucketIndex = [...]uint16{0, 9, 13, 30, 45, 50, 63, 74, 98, 118, 157, 190, 219, 244, 255, 277, 297, 321, 345, 353, 366, 372, 388, 397, 420, 445, 456, 467, 480, 491, 500, 520, 539, 547, 567, 574, 590, 601, 623, 641, 662}
+var _BucketIndex = [...]uint16{0, 9, 13, 30, 45, 50, 63, 74, 98, 118, 157, 190, 219, 244, 255, 277, 297, 321, 345, 353, 366, 372, 388, 397, 420, 445, 456, 467, 480, 491, 500, 520, 539, 547, 567, 574, 590, 601, 623, 641}
 
-const _BucketLowerName = "statetriepeercontractclasshashcontractstorageclasscontractnoncechainheightblockheadernumbersbyhashblockheadersbynumbertransactionblocknumbersandindicesbyhashtransactionsbyblocknumberandindexreceiptsbyblocknumberandindexstateupdatesbyblocknumberclassestriecontractstoragehistorycontractnoncehistorycontractclasshashhistorycontractdeploymentheightl1heightschemaversionunusedblockcommitmentstemporaryschemaintermediatestatel1handlertxnhashbymsghashmempoolheadmempooltailmempoollengthmempoolnodeclasstriecontracttriecontractcontracttriestoragecontractstatehashtotrierootsstateidpersistedstateidtriejournalaggregatedbloomfiltersrunningeventfilterclasshashtocasmhashv2"
+const _BucketLowerName = "statetriepeercontractclasshashcontractstorageclasscontractnoncechainheightblockheadernumbersbyhashblockheadersbynumbertransactionblocknumbersandindicesbyhashtransactionsbyblocknumberandindexreceiptsbyblocknumberandindexstateupdatesbyblocknumberclassestriecontractstoragehistorycontractnoncehistorycontractclasshashhistorycontractdeploymentheightl1heightschemaversionunusedblockcommitmentstemporaryschemaintermediatestatel1handlertxnhashbymsghashmempoolheadmempooltailmempoollengthmempoolnodeclasstriecontracttriecontractcontracttriestoragecontractstatehashtotrierootsstateidpersistedstateidtriejournalaggregatedbloomfiltersrunningeventfilter"
 
 func (i Bucket) String() string {
 	if i >= Bucket(len(_BucketIndex)-1) {
@@ -63,10 +63,9 @@ func _BucketNoOp() {
 	_ = x[TrieJournal-(36)]
 	_ = x[AggregatedBloomFilters-(37)]
 	_ = x[RunningEventFilter-(38)]
-	_ = x[ClassHashToCasmHashV2-(39)]
 }
 
-var _BucketValues = []Bucket{StateTrie, Peer, ContractClassHash, ContractStorage, Class, ContractNonce, ChainHeight, BlockHeaderNumbersByHash, BlockHeadersByNumber, TransactionBlockNumbersAndIndicesByHash, TransactionsByBlockNumberAndIndex, ReceiptsByBlockNumberAndIndex, StateUpdatesByBlockNumber, ClassesTrie, ContractStorageHistory, ContractNonceHistory, ContractClassHashHistory, ContractDeploymentHeight, L1Height, SchemaVersion, Unused, BlockCommitments, Temporary, SchemaIntermediateState, L1HandlerTxnHashByMsgHash, MempoolHead, MempoolTail, MempoolLength, MempoolNode, ClassTrie, ContractTrieContract, ContractTrieStorage, Contract, StateHashToTrieRoots, StateID, PersistedStateID, TrieJournal, AggregatedBloomFilters, RunningEventFilter, ClassHashToCasmHashV2}
+var _BucketValues = []Bucket{StateTrie, Peer, ContractClassHash, ContractStorage, Class, ContractNonce, ChainHeight, BlockHeaderNumbersByHash, BlockHeadersByNumber, TransactionBlockNumbersAndIndicesByHash, TransactionsByBlockNumberAndIndex, ReceiptsByBlockNumberAndIndex, StateUpdatesByBlockNumber, ClassesTrie, ContractStorageHistory, ContractNonceHistory, ContractClassHashHistory, ContractDeploymentHeight, L1Height, SchemaVersion, Unused, BlockCommitments, Temporary, SchemaIntermediateState, L1HandlerTxnHashByMsgHash, MempoolHead, MempoolTail, MempoolLength, MempoolNode, ClassTrie, ContractTrieContract, ContractTrieStorage, Contract, StateHashToTrieRoots, StateID, PersistedStateID, TrieJournal, AggregatedBloomFilters, RunningEventFilter}
 
 var _BucketNameToValueMap = map[string]Bucket{
 	_BucketName[0:9]:          StateTrie,
@@ -147,8 +146,6 @@ var _BucketNameToValueMap = map[string]Bucket{
 	_BucketLowerName[601:623]: AggregatedBloomFilters,
 	_BucketName[623:641]:      RunningEventFilter,
 	_BucketLowerName[623:641]: RunningEventFilter,
-	_BucketName[641:662]:      ClassHashToCasmHashV2,
-	_BucketLowerName[641:662]: ClassHashToCasmHashV2,
 }
 
 var _BucketNames = []string{
@@ -191,7 +188,6 @@ var _BucketNames = []string{
 	_BucketName[590:601],
 	_BucketName[601:623],
 	_BucketName[623:641],
-	_BucketName[641:662],
 }
 
 // BucketString retrieves an enum value from the enum constants string name.
diff --git a/db/schema.go b/db/schema.go
index 3e80b87a55..94975f91c0 100644
--- a/db/schema.go
+++ b/db/schema.go
@@ -175,7 +175,3 @@ func uint64ToBytes(num uint64) [8]byte {
 func StateHashToTrieRootsKey(stateCommitment *felt.Felt) []byte {
 	return StateHashToTrieRoots.Key(stateCommitment.Marshal())
 }
-
-func ClassHashToCasmHashV2Key(classHash *felt.SierraClassHash) []byte {
-	return ClassHashToCasmHashV2.Key(classHash.Marshal())
-}
diff --git a/docs/docs/running-juno.md b/docs/docs/running-juno.md
index 1b5b2bd10f..d5c31bab73 100644
--- a/docs/docs/running-juno.md
+++ b/docs/docs/running-juno.md
@@ -95,7 +95,7 @@ You can build the Juno binary or Docker image from the source code to access the
 ### Prerequisites
 
 - [Golang 1.25](https://go.dev/doc/install) or later
-- [Rust](https://www.rust-lang.org/tools/install) 1.87.0 or higher.
+- [Rust](https://www.rust-lang.org/tools/install) 1.86.0 or higher.
 - C compiler: `gcc` or `clang`
 - [jemalloc](https://github.com/jemalloc/jemalloc)
 
diff --git a/docs/versioned_docs/version-0.15.0/running-juno.md b/docs/versioned_docs/version-0.15.0/running-juno.md
index 1b5b2bd10f..d5c31bab73 100644
--- a/docs/versioned_docs/version-0.15.0/running-juno.md
+++ b/docs/versioned_docs/version-0.15.0/running-juno.md
@@ -95,7 +95,7 @@ You can build the Juno binary or Docker image from the source code to access the
 ### Prerequisites
 
 - [Golang 1.25](https://go.dev/doc/install) or later
-- [Rust](https://www.rust-lang.org/tools/install) 1.87.0 or higher.
+- [Rust](https://www.rust-lang.org/tools/install) 1.86.0 or higher.
 - C compiler: `gcc` or `clang`
 - [jemalloc](https://github.com/jemalloc/jemalloc)
 
diff --git a/genesis/genesis.go b/genesis/genesis.go
index 9bdf7f7ce9..8456d95492 100644
--- a/genesis/genesis.go
+++ b/genesis/genesis.go
@@ -11,6 +11,7 @@ import (
 	"github.com/NethermindEth/juno/core/felt"
 	"github.com/NethermindEth/juno/core/state"
 	"github.com/NethermindEth/juno/core/state/statefactory"
+
 	"github.com/NethermindEth/juno/core/trie2/triedb"
 	"github.com/NethermindEth/juno/db/memory"
 	rpc "github.com/NethermindEth/juno/rpc/v8"
diff --git a/mempool/mempool_test.go b/mempool/mempool_test.go
index e5f9722d14..2f230c09b1 100644
--- a/mempool/mempool_test.go
+++ b/mempool/mempool_test.go
@@ -47,7 +47,7 @@ func TestMempool(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	t.Cleanup(mockCtrl.Finish)
 	chain := mocks.NewMockReader(mockCtrl)
-	state := mocks.NewMockStateHistoryReader(mockCtrl)
+	state := mocks.NewMockStateReader(mockCtrl)
 
 	require.NoError(t, err)
 	defer dbCloser()
@@ -122,7 +122,7 @@ func TestRestoreMempool(t *testing.T) {
 	log := utils.NewNopZapLogger()
 	mockCtrl := gomock.NewController(t)
 	t.Cleanup(mockCtrl.Finish)
-	state := mocks.NewMockStateHistoryReader(mockCtrl)
+	state := mocks.NewMockStateReader(mockCtrl)
 	chain := mocks.NewMockReader(mockCtrl)
 	testDB, dbDeleter, err := setupDatabase("testrestoremempool", true)
 	require.NoError(t, err)
@@ -234,7 +234,7 @@ func TestPopBatch(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	t.Cleanup(mockCtrl.Finish)
 	chain := mocks.NewMockReader(mockCtrl)
-	state := mocks.NewMockStateHistoryReader(mockCtrl)
+	state := mocks.NewMockStateReader(mockCtrl)
 
 	require.NoError(t, err)
 	defer dbCloser()
diff --git a/migration/migration.go b/migration/migration.go
index 1f684b693c..9596a380c7 100644
--- a/migration/migration.go
+++ b/migration/migration.go
@@ -82,7 +82,6 @@ var defaultMigrations = []Migration{
 	MigrationFunc(calculateL1MsgHashes2),
 	MigrationFunc(removePendingBlock),
 	MigrationFunc(reconstructAggregatedBloomFilters),
-	MigrationFunc(calculateCasmClassHashesV2),
 }
 
 var ErrCallWithNewTransaction = errors.New("call with new transaction")
@@ -923,74 +922,3 @@ func startMigrationStatusServer(log utils.SimpleLogger, host string, port uint16
 	}()
 	return srv
 }
-
-func calculateCasmClassHashesV2(txn db.IndexedBatch, network *utils.Network) error {
-	classPrefix := db.Class.Key()
-	it, err := txn.NewIterator(classPrefix, false)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if closeErr := it.Close(); closeErr != nil {
-			_ = closeErr
-		}
-	}()
-
-	maxWorkers := runtime.GOMAXPROCS(0)
-	workerPool := pool.New().WithErrors().WithMaxGoroutines(maxWorkers)
-	var writeMu sync.Mutex
-
-	for it.Seek(classPrefix); it.Valid(); it.Next() {
-		key := it.Key()
-		if !bytes.HasPrefix(key, classPrefix) {
-			break
-		}
-
-		// Extract and validate class hash from key
-		classHashBytes := key[len(classPrefix):]
-		if len(classHashBytes) != felt.Bytes {
-			continue // Skip invalid keys
-		}
-		classHash := felt.FromBytes[felt.Felt](classHashBytes)
-		sierraClassHash := felt.SierraClassHash(classHash)
-
-		value, err := it.Value()
-		if err != nil {
-			_ = workerPool.Wait()
-			return err
-		}
-
-		workerPool.Go(
-			func() error {
-				var declaredClass core.DeclaredClassDefinition
-				if err := encoder.Unmarshal(value, &declaredClass); err != nil {
-					return err
-				}
-
-				sierraClass, ok := declaredClass.Class.(*core.SierraClass)
-				if !ok {
-					return nil // Skip non-Sierra classes
-				}
-
-				if sierraClass.Compiled == nil {
-					return nil // Skip if Compiled field is nil
-				}
-
-				casmHashV2 := felt.CasmClassHash(sierraClass.Compiled.Hash(core.HashVersionV2))
-
-				writeMu.Lock()
-				err := core.WriteCasmClassHashV2(txn, &sierraClassHash, &casmHashV2)
-				writeMu.Unlock()
-				if err != nil {
-					return fmt.Errorf("failed to write CASM hash V2 for class %s: %w",
-						sierraClassHash.String(),
-						err,
-					)
-				}
-
-				return nil
-			})
-	}
-
-	return workerPool.Wait()
-}
diff --git a/mocks/mock_common_state.go b/mocks/mock_common_state.go
deleted file mode 100644
index a5f4e80a5a..0000000000
--- a/mocks/mock_common_state.go
+++ /dev/null
@@ -1,280 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/NethermindEth/juno/core (interfaces: CommonState)
-//
-// Generated by this command:
-//
-//	mockgen -destination=../mocks/mock_common_state.go -package=mocks github.com/NethermindEth/juno/core CommonState
-//
-
-// Package mocks is a generated GoMock package.
-package mocks
-
-import (
-	reflect "reflect"
-
-	core "github.com/NethermindEth/juno/core"
-	felt "github.com/NethermindEth/juno/core/felt"
-	gomock "go.uber.org/mock/gomock"
-)
-
-// MockCommonState is a mock of CommonState interface.
-type MockCommonState struct {
-	ctrl     *gomock.Controller
-	recorder *MockCommonStateMockRecorder
-	isgomock struct{}
-}
-
-// MockCommonStateMockRecorder is the mock recorder for MockCommonState.
-type MockCommonStateMockRecorder struct {
-	mock *MockCommonState
-}
-
-// NewMockCommonState creates a new mock instance.
-func NewMockCommonState(ctrl *gomock.Controller) *MockCommonState {
-	mock := &MockCommonState{ctrl: ctrl}
-	mock.recorder = &MockCommonStateMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockCommonState) EXPECT() *MockCommonStateMockRecorder {
-	return m.recorder
-}
-
-// Class mocks base method.
-func (m *MockCommonState) Class(classHash *felt.Felt) (*core.DeclaredClassDefinition, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Class", classHash)
-	ret0, _ := ret[0].(*core.DeclaredClassDefinition)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// Class indicates an expected call of Class.
-func (mr *MockCommonStateMockRecorder) Class(classHash any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Class", reflect.TypeOf((*MockCommonState)(nil).Class), classHash)
-}
-
-// ClassTrie mocks base method.
-func (m *MockCommonState) ClassTrie() (core.CommonTrie, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClassTrie")
-	ret0, _ := ret[0].(core.CommonTrie)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ClassTrie indicates an expected call of ClassTrie.
-func (mr *MockCommonStateMockRecorder) ClassTrie() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClassTrie", reflect.TypeOf((*MockCommonState)(nil).ClassTrie))
-}
-
-// Commitment mocks base method.
-func (m *MockCommonState) Commitment() (felt.Felt, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Commitment")
-	ret0, _ := ret[0].(felt.Felt)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// Commitment indicates an expected call of Commitment.
-func (mr *MockCommonStateMockRecorder) Commitment() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commitment", reflect.TypeOf((*MockCommonState)(nil).Commitment))
-}
-
-// CompiledClassHash mocks base method.
-func (m *MockCommonState) CompiledClassHash(classHash *felt.SierraClassHash) (felt.CasmClassHash, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CompiledClassHash", classHash)
-	ret0, _ := ret[0].(felt.CasmClassHash)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CompiledClassHash indicates an expected call of CompiledClassHash.
-func (mr *MockCommonStateMockRecorder) CompiledClassHash(classHash any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompiledClassHash", reflect.TypeOf((*MockCommonState)(nil).CompiledClassHash), classHash)
-}
-
-// CompiledClassHashV2 mocks base method.
-func (m *MockCommonState) CompiledClassHashV2(classHash *felt.SierraClassHash) (felt.CasmClassHash, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CompiledClassHashV2", classHash)
-	ret0, _ := ret[0].(felt.CasmClassHash)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CompiledClassHashV2 indicates an expected call of CompiledClassHashV2.
-func (mr *MockCommonStateMockRecorder) CompiledClassHashV2(classHash any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompiledClassHashV2", reflect.TypeOf((*MockCommonState)(nil).CompiledClassHashV2), classHash)
-}
-
-// ContractClassHash mocks base method.
-func (m *MockCommonState) ContractClassHash(addr *felt.Felt) (felt.Felt, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContractClassHash", addr)
-	ret0, _ := ret[0].(felt.Felt)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ContractClassHash indicates an expected call of ContractClassHash.
-func (mr *MockCommonStateMockRecorder) ContractClassHash(addr any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractClassHash", reflect.TypeOf((*MockCommonState)(nil).ContractClassHash), addr)
-}
-
-// ContractClassHashAt mocks base method.
-func (m *MockCommonState) ContractClassHashAt(addr *felt.Felt, blockNumber uint64) (felt.Felt, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContractClassHashAt", addr, blockNumber)
-	ret0, _ := ret[0].(felt.Felt)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ContractClassHashAt indicates an expected call of ContractClassHashAt.
-func (mr *MockCommonStateMockRecorder) ContractClassHashAt(addr, blockNumber any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractClassHashAt", reflect.TypeOf((*MockCommonState)(nil).ContractClassHashAt), addr, blockNumber)
-}
-
-// ContractDeployedAt mocks base method.
-func (m *MockCommonState) ContractDeployedAt(addr *felt.Felt, blockNumber uint64) (bool, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContractDeployedAt", addr, blockNumber)
-	ret0, _ := ret[0].(bool)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ContractDeployedAt indicates an expected call of ContractDeployedAt.
-func (mr *MockCommonStateMockRecorder) ContractDeployedAt(addr, blockNumber any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractDeployedAt", reflect.TypeOf((*MockCommonState)(nil).ContractDeployedAt), addr, blockNumber)
-}
-
-// ContractNonce mocks base method.
-func (m *MockCommonState) ContractNonce(addr *felt.Felt) (felt.Felt, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContractNonce", addr)
-	ret0, _ := ret[0].(felt.Felt)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ContractNonce indicates an expected call of ContractNonce.
-func (mr *MockCommonStateMockRecorder) ContractNonce(addr any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractNonce", reflect.TypeOf((*MockCommonState)(nil).ContractNonce), addr)
-}
-
-// ContractNonceAt mocks base method.
-func (m *MockCommonState) ContractNonceAt(addr *felt.Felt, blockNumber uint64) (felt.Felt, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContractNonceAt", addr, blockNumber)
-	ret0, _ := ret[0].(felt.Felt)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ContractNonceAt indicates an expected call of ContractNonceAt.
-func (mr *MockCommonStateMockRecorder) ContractNonceAt(addr, blockNumber any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractNonceAt", reflect.TypeOf((*MockCommonState)(nil).ContractNonceAt), addr, blockNumber)
-}
-
-// ContractStorage mocks base method.
-func (m *MockCommonState) ContractStorage(addr, key *felt.Felt) (felt.Felt, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContractStorage", addr, key)
-	ret0, _ := ret[0].(felt.Felt)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ContractStorage indicates an expected call of ContractStorage.
-func (mr *MockCommonStateMockRecorder) ContractStorage(addr, key any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractStorage", reflect.TypeOf((*MockCommonState)(nil).ContractStorage), addr, key)
-}
-
-// ContractStorageAt mocks base method.
-func (m *MockCommonState) ContractStorageAt(addr, key *felt.Felt, blockNumber uint64) (felt.Felt, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContractStorageAt", addr, key, blockNumber)
-	ret0, _ := ret[0].(felt.Felt)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ContractStorageAt indicates an expected call of ContractStorageAt.
-func (mr *MockCommonStateMockRecorder) ContractStorageAt(addr, key, blockNumber any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractStorageAt", reflect.TypeOf((*MockCommonState)(nil).ContractStorageAt), addr, key, blockNumber)
-}
-
-// ContractStorageTrie mocks base method.
-func (m *MockCommonState) ContractStorageTrie(addr *felt.Felt) (core.CommonTrie, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContractStorageTrie", addr)
-	ret0, _ := ret[0].(core.CommonTrie)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ContractStorageTrie indicates an expected call of ContractStorageTrie.
-func (mr *MockCommonStateMockRecorder) ContractStorageTrie(addr any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractStorageTrie", reflect.TypeOf((*MockCommonState)(nil).ContractStorageTrie), addr)
-}
-
-// ContractTrie mocks base method.
-func (m *MockCommonState) ContractTrie() (core.CommonTrie, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ContractTrie")
-	ret0, _ := ret[0].(core.CommonTrie)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ContractTrie indicates an expected call of ContractTrie.
-func (mr *MockCommonStateMockRecorder) ContractTrie() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractTrie", reflect.TypeOf((*MockCommonState)(nil).ContractTrie))
-}
-
-// Revert mocks base method.
-func (m *MockCommonState) Revert(blockNum uint64, update *core.StateUpdate) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Revert", blockNum, update)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// Revert indicates an expected call of Revert.
-func (mr *MockCommonStateMockRecorder) Revert(blockNum, update any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Revert", reflect.TypeOf((*MockCommonState)(nil).Revert), blockNum, update)
-}
-
-// Update mocks base method.
-func (m *MockCommonState) Update(blockNum uint64, update *core.StateUpdate, declaredClasses map[felt.Felt]core.ClassDefinition, skipVerifyNewRoot bool) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Update", blockNum, update, declaredClasses, skipVerifyNewRoot)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// Update indicates an expected call of Update.
-func (mr *MockCommonStateMockRecorder) Update(blockNum, update, declaredClasses, skipVerifyNewRoot any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockCommonState)(nil).Update), blockNum, update, declaredClasses, skipVerifyNewRoot)
-}
diff --git a/mocks/mock_commonstate_reader.go b/mocks/mock_commonstate_reader.go
new file mode 100644
index 0000000000..f77bad40dc
--- /dev/null
+++ b/mocks/mock_commonstate_reader.go
@@ -0,0 +1,147 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/NethermindEth/juno/core/state/commonstate (interfaces: StateReader)
+//
+// Generated by this command:
+//
+//	mockgen -destination=mocks/mock_commonstate_reader.go -package=mocks github.com/NethermindEth/juno/core/state/commonstate StateReader
+//
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+	reflect "reflect"
+
+	core "github.com/NethermindEth/juno/core"
+	felt "github.com/NethermindEth/juno/core/felt"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockStateReader is a mock of StateReader interface.
+type MockStateReader struct {
+	ctrl     *gomock.Controller
+	recorder *MockStateReaderMockRecorder
+	isgomock struct{}
+}
+
+// MockStateReaderMockRecorder is the mock recorder for MockStateReader.
+type MockStateReaderMockRecorder struct {
+	mock *MockStateReader
+}
+
+// NewMockStateReader creates a new mock instance.
+func NewMockStateReader(ctrl *gomock.Controller) *MockStateReader {
+	mock := &MockStateReader{ctrl: ctrl}
+	mock.recorder = &MockStateReaderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockStateReader) EXPECT() *MockStateReaderMockRecorder {
+	return m.recorder
+}
+
+// Class mocks base method.
+func (m *MockStateReader) Class(classHash *felt.Felt) (*core.DeclaredClassDefinition, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Class", classHash)
+	ret0, _ := ret[0].(*core.DeclaredClassDefinition)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Class indicates an expected call of Class.
+func (mr *MockStateReaderMockRecorder) Class(classHash any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Class", reflect.TypeOf((*MockStateReader)(nil).Class), classHash)
+}
+
+// ClassTrie mocks base method.
+func (m *MockStateReader) ClassTrie() (core.CommonTrie, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ClassTrie")
+	ret0, _ := ret[0].(core.CommonTrie)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ClassTrie indicates an expected call of ClassTrie.
+func (mr *MockStateReaderMockRecorder) ClassTrie() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClassTrie", reflect.TypeOf((*MockStateReader)(nil).ClassTrie))
+}
+
+// ContractClassHash mocks base method.
+func (m *MockStateReader) ContractClassHash(addr *felt.Felt) (felt.Felt, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContractClassHash", addr)
+	ret0, _ := ret[0].(felt.Felt)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ContractClassHash indicates an expected call of ContractClassHash.
+func (mr *MockStateReaderMockRecorder) ContractClassHash(addr any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractClassHash", reflect.TypeOf((*MockStateReader)(nil).ContractClassHash), addr)
+}
+
+// ContractNonce mocks base method.
+func (m *MockStateReader) ContractNonce(addr *felt.Felt) (felt.Felt, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContractNonce", addr)
+	ret0, _ := ret[0].(felt.Felt)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ContractNonce indicates an expected call of ContractNonce.
+func (mr *MockStateReaderMockRecorder) ContractNonce(addr any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractNonce", reflect.TypeOf((*MockStateReader)(nil).ContractNonce), addr)
+}
+
+// ContractStorage mocks base method.
+func (m *MockStateReader) ContractStorage(addr, key *felt.Felt) (felt.Felt, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContractStorage", addr, key)
+	ret0, _ := ret[0].(felt.Felt)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ContractStorage indicates an expected call of ContractStorage.
+func (mr *MockStateReaderMockRecorder) ContractStorage(addr, key any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractStorage", reflect.TypeOf((*MockStateReader)(nil).ContractStorage), addr, key)
+}
+
+// ContractStorageTrie mocks base method.
+func (m *MockStateReader) ContractStorageTrie(addr *felt.Felt) (core.CommonTrie, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContractStorageTrie", addr)
+	ret0, _ := ret[0].(core.CommonTrie)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ContractStorageTrie indicates an expected call of ContractStorageTrie.
+func (mr *MockStateReaderMockRecorder) ContractStorageTrie(addr any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractStorageTrie", reflect.TypeOf((*MockStateReader)(nil).ContractStorageTrie), addr)
+}
+
+// ContractTrie mocks base method.
+func (m *MockStateReader) ContractTrie() (core.CommonTrie, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContractTrie")
+	ret0, _ := ret[0].(core.CommonTrie)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ContractTrie indicates an expected call of ContractTrie.
+func (mr *MockStateReaderMockRecorder) ContractTrie() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContractTrie", reflect.TypeOf((*MockStateReader)(nil).ContractTrie))
+}
diff --git a/mocks/mock_state.go b/mocks/mock_state.go
index 6740c691c1..3cfe40a490 100644
--- a/mocks/mock_state.go
+++ b/mocks/mock_state.go
@@ -86,36 +86,6 @@ func (mr *MockStateHistoryReaderMockRecorder) ClassTrie() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClassTrie", reflect.TypeOf((*MockStateHistoryReader)(nil).ClassTrie))
 }
 
-// CompiledClassHash mocks base method.
-func (m *MockStateHistoryReader) CompiledClassHash(classHash *felt.SierraClassHash) (felt.CasmClassHash, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CompiledClassHash", classHash)
-	ret0, _ := ret[0].(felt.CasmClassHash)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CompiledClassHash indicates an expected call of CompiledClassHash.
-func (mr *MockStateHistoryReaderMockRecorder) CompiledClassHash(classHash any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompiledClassHash", reflect.TypeOf((*MockStateHistoryReader)(nil).CompiledClassHash), classHash)
-}
-
-// CompiledClassHashV2 mocks base method.
-func (m *MockStateHistoryReader) CompiledClassHashV2(classHash *felt.SierraClassHash) (felt.CasmClassHash, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CompiledClassHashV2", classHash)
-	ret0, _ := ret[0].(felt.CasmClassHash)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CompiledClassHashV2 indicates an expected call of CompiledClassHashV2.
-func (mr *MockStateHistoryReaderMockRecorder) CompiledClassHashV2(classHash any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompiledClassHashV2", reflect.TypeOf((*MockStateHistoryReader)(nil).CompiledClassHashV2), classHash)
-}
-
 // ContractClassHash mocks base method.
 func (m *MockStateHistoryReader) ContractClassHash(addr *felt.Felt) (felt.Felt, error) {
 	m.ctrl.T.Helper()
diff --git a/node/throttled_vm.go b/node/throttled_vm.go
index 533011aad8..a08b51a550 100644
--- a/node/throttled_vm.go
+++ b/node/throttled_vm.go
@@ -3,6 +3,7 @@ package node
 import (
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/utils"
 	"github.com/NethermindEth/juno/vm"
 )
diff --git a/rpc/v10/handlers_test.go b/rpc/v10/handlers_test.go
index 128de983ab..cd194202e8 100644
--- a/rpc/v10/handlers_test.go
+++ b/rpc/v10/handlers_test.go
@@ -35,7 +35,7 @@ func TestThrottledVMError(t *testing.T) {
 
 	throttledVM := node.NewThrottledVM(mockVM, 0, 0)
 	handler := rpcv10.New(mockReader, mockSyncReader, throttledVM, nil)
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateHistoryReader(mockCtrl)
 
 	throttledErr := "VM throughput limit reached"
 
@@ -79,9 +79,9 @@ func TestThrottledVMError(t *testing.T) {
 		}
 
 		mockReader.EXPECT().BlockByHash(blockHash).Return(block, nil)
-		state := mocks.NewMockCommonState(mockCtrl)
+		state := mocks.NewMockStateHistoryReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(state, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateHistoryReader(mockCtrl)
 		headState.EXPECT().Class(declareTx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 
diff --git a/rpc/v10/helpers.go b/rpc/v10/helpers.go
index 5c1b1a5007..df08b6ce13 100644
--- a/rpc/v10/helpers.go
+++ b/rpc/v10/helpers.go
@@ -17,7 +17,7 @@ func (h *Handler) l1Head() (core.L1Head, *jsonrpc.Error) {
 	if err != nil && !errors.Is(err, db.ErrKeyNotFound) {
 		return core.L1Head{}, jsonrpc.Err(jsonrpc.InternalError, err.Error())
 	}
-	// empty l1Head is returned if l1 head doesn't exist
+	// empty L1Head is returned if l1 head doesn't exist
 	return l1Head, nil
 }
 
diff --git a/rpc/v10/pending_data_wrapper_test.go b/rpc/v10/pending_data_wrapper_test.go
index bd1cce3194..d7c0204d2b 100644
--- a/rpc/v10/pending_data_wrapper_test.go
+++ b/rpc/v10/pending_data_wrapper_test.go
@@ -117,7 +117,7 @@ func TestPendingDataWrapper_PendingState(t *testing.T) {
 	mockReader := mocks.NewMockReader(mockCtrl)
 	handler := rpc.New(mockReader, mockSyncReader, nil, nil)
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateHistoryReader(mockCtrl)
 	t.Run("Returns pending state", func(t *testing.T) {
 		stateDiff := core.EmptyStateDiff()
 		pendingData := core.PreConfirmed{
diff --git a/rpc/v10/simulation_test.go b/rpc/v10/simulation_test.go
index 27cc5e0f83..cb67ed674f 100644
--- a/rpc/v10/simulation_test.go
+++ b/rpc/v10/simulation_test.go
@@ -40,7 +40,7 @@ func TestSimulateTransactions(t *testing.T) {
 	defaultMockBehavior := func(
 		mockReader *mocks.MockReader,
 		_ *mocks.MockVM,
-		mockState *mocks.MockCommonState,
+		mockState *mocks.MockStateHistoryReader,
 	) {
 		mockReader.EXPECT().Network().Return(n)
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
@@ -50,7 +50,7 @@ func TestSimulateTransactions(t *testing.T) {
 		name            string
 		stepsUsed       uint64
 		err             *jsonrpc.Error
-		mockBehavior    func(*mocks.MockReader, *mocks.MockVM, *mocks.MockCommonState)
+		mockBehavior    func(*mocks.MockReader, *mocks.MockVM, *mocks.MockStateHistoryReader)
 		simulationFlags []rpcv6.SimulationFlag
 		simulatedTxs    []rpcv10.SimulatedTransaction
 	}{
@@ -60,7 +60,7 @@ func TestSimulateTransactions(t *testing.T) {
 			mockBehavior: func(
 				mockReader *mocks.MockReader,
 				mockVM *mocks.MockVM,
-				mockState *mocks.MockCommonState,
+				mockState *mocks.MockStateHistoryReader,
 			) {
 				defaultMockBehavior(mockReader, mockVM, mockState)
 				mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &vm.BlockInfo{
@@ -83,7 +83,7 @@ func TestSimulateTransactions(t *testing.T) {
 			mockBehavior: func(
 				mockReader *mocks.MockReader,
 				mockVM *mocks.MockVM,
-				mockState *mocks.MockCommonState,
+				mockState *mocks.MockStateHistoryReader,
 			) {
 				defaultMockBehavior(mockReader, mockVM, mockState)
 				mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &vm.BlockInfo{
@@ -105,7 +105,7 @@ func TestSimulateTransactions(t *testing.T) {
 			mockBehavior: func(
 				mockReader *mocks.MockReader,
 				mockVM *mocks.MockVM,
-				mockState *mocks.MockCommonState,
+				mockState *mocks.MockStateHistoryReader,
 			) {
 				defaultMockBehavior(mockReader, mockVM, mockState)
 				mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &vm.BlockInfo{
@@ -127,7 +127,7 @@ func TestSimulateTransactions(t *testing.T) {
 			mockBehavior: func(
 				mockReader *mocks.MockReader,
 				mockVM *mocks.MockVM,
-				mockState *mocks.MockCommonState,
+				mockState *mocks.MockStateHistoryReader,
 			) {
 				defaultMockBehavior(mockReader, mockVM, mockState)
 				mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &vm.BlockInfo{
@@ -156,7 +156,7 @@ func TestSimulateTransactions(t *testing.T) {
 
 			mockReader := mocks.NewMockReader(mockCtrl)
 			mockVM := mocks.NewMockVM(mockCtrl)
-			mockState := mocks.NewMockCommonState(mockCtrl)
+			mockState := mocks.NewMockStateHistoryReader(mockCtrl)
 
 			test.mockBehavior(mockReader, mockVM, mockState)
 			handler := rpcv10.New(mockReader, nil, mockVM, utils.NewNopZapLogger())
@@ -295,7 +295,7 @@ func TestSimulateTransactionsShouldErrorWithoutSenderAddressOrResourceBounds(t *
 
 			mockReader := mocks.NewMockReader(mockCtrl)
 			mockVM := mocks.NewMockVM(mockCtrl)
-			mockState := mocks.NewMockCommonState(mockCtrl)
+			mockState := mocks.NewMockStateHistoryReader(mockCtrl)
 
 			mockReader.EXPECT().Network().Return(n)
 			mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v10/trace_test.go b/rpc/v10/trace_test.go
index fe7441760f..9d1515df85 100644
--- a/rpc/v10/trace_test.go
+++ b/rpc/v10/trace_test.go
@@ -390,7 +390,7 @@ func TestTraceTransaction(t *testing.T) {
 		mockReader.EXPECT().BlockByHash(header.Hash).Return(block, nil)
 
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(nil, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateHistoryReader(mockCtrl)
 		headState.EXPECT().Class(tx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 
@@ -471,7 +471,7 @@ func TestTraceTransaction(t *testing.T) {
 			&pending,
 			nil,
 		).Times(2)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateHistoryReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).
 			Return(headState, nopCloser, nil).Times(2)
 
@@ -548,7 +548,7 @@ func TestTraceTransaction(t *testing.T) {
 			&preConfirmed,
 			nil,
 		)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateHistoryReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockNumber(header.Number-1).
 			Return(headState, nopCloser, nil)
 
@@ -641,7 +641,7 @@ func TestTraceTransaction(t *testing.T) {
 			nil,
 		)
 		mockReader.EXPECT().Receipt(hash).Return(nil, nil, uint64(0), db.ErrKeyNotFound)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateHistoryReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(preLatest.Block.ParentHash).
 			Return(headState, nopCloser, nil)
 
@@ -797,7 +797,7 @@ func TestTraceBlockTransactions(t *testing.T) {
 		mockReader.EXPECT().BlockByHash(blockHash).Return(block, nil)
 
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(nil, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateHistoryReader(mockCtrl)
 		headState.EXPECT().Class(tx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 
diff --git a/rpc/v6/class_test.go b/rpc/v6/class_test.go
index e5b9fd2f43..097cfb8ae2 100644
--- a/rpc/v6/class_test.go
+++ b/rpc/v6/class_test.go
@@ -27,7 +27,7 @@ func TestClass(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	mockState := mocks.NewMockStateHistoryReader(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	mockState.EXPECT().Class(
 		gomock.Any()).DoAndReturn(func(
@@ -86,7 +86,7 @@ func TestClass(t *testing.T) {
 
 	t.Run("class hash not found error", func(t *testing.T) {
 		mockReader := mocks.NewMockReader(mockCtrl)
-		mockState := mocks.NewMockStateHistoryReader(mockCtrl)
+		mockState := mocks.NewMockStateReader(mockCtrl)
 		handler := rpc.New(mockReader, nil, nil, n, utils.NewNopZapLogger())
 
 		mockReader.EXPECT().HeadState().Return(mockState, func() error {
@@ -109,7 +109,7 @@ func TestClassAt(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	mockState := mocks.NewMockStateHistoryReader(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	deprecatedCairoContractAddress := felt.NewRandom[felt.Felt]()
 	deprecatedCairoClassHash := felt.NewUnsafeFromString[felt.Felt](
@@ -202,7 +202,7 @@ func TestClassHashAt(t *testing.T) {
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
 
-	mockState := mocks.NewMockStateHistoryReader(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	t.Run("non-existent contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v6/contract_test.go b/rpc/v6/contract_test.go
index ddcb2d5741..f10850b695 100644
--- a/rpc/v6/contract_test.go
+++ b/rpc/v6/contract_test.go
@@ -60,7 +60,7 @@ func TestNonce(t *testing.T) {
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
 
-	mockState := mocks.NewMockStateHistoryReader(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	t.Run("non-existent contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
@@ -188,7 +188,7 @@ func TestStorageAt(t *testing.T) {
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
 
-	mockState := mocks.NewMockStateHistoryReader(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	t.Run("non-existent contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v6/estimate_fee_test.go b/rpc/v6/estimate_fee_test.go
index 9aae230912..70c14ed170 100644
--- a/rpc/v6/estimate_fee_test.go
+++ b/rpc/v6/estimate_fee_test.go
@@ -6,6 +6,7 @@ import (
 
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/mocks"
 	rpccore "github.com/NethermindEth/juno/rpc/rpccore"
@@ -46,7 +47,7 @@ func TestEstimateMessageFee(t *testing.T) {
 		Timestamp:     456,
 		L1GasPriceETH: new(felt.Felt).SetUint64(42),
 	}
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
 	mockReader.EXPECT().HeadsHeader().Return(latestHeader, nil)
diff --git a/rpc/v6/handlers_test.go b/rpc/v6/handlers_test.go
index daab264abf..718af5ef85 100644
--- a/rpc/v6/handlers_test.go
+++ b/rpc/v6/handlers_test.go
@@ -33,7 +33,7 @@ func TestThrottledVMError(t *testing.T) {
 
 	throttledVM := node.NewThrottledVM(mockVM, 0, 0)
 	handler := rpc.New(mockReader, mockSyncReader, throttledVM, &utils.Mainnet, nil)
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	throttledErr := "VM throughput limit reached"
 	t.Run("call", func(t *testing.T) {
@@ -81,9 +81,9 @@ func TestThrottledVMError(t *testing.T) {
 		}
 
 		mockReader.EXPECT().BlockByHash(blockHash).Return(block, nil)
-		state := mocks.NewMockCommonState(mockCtrl)
+		state := mocks.NewMockStateReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(state, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		headState.EXPECT().Class(declareTx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 		_, rpcErr := handler.TraceBlockTransactions(t.Context(), rpc.BlockID{Hash: blockHash})
diff --git a/rpc/v6/helpers.go b/rpc/v6/helpers.go
index 0269dea13d..edc2342759 100644
--- a/rpc/v6/helpers.go
+++ b/rpc/v6/helpers.go
@@ -9,6 +9,7 @@ import (
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/jsonrpc"
 	rpccore "github.com/NethermindEth/juno/rpc/rpccore"
@@ -19,7 +20,7 @@ func (h *Handler) l1Head() (core.L1Head, *jsonrpc.Error) {
 	if err != nil && !errors.Is(err, db.ErrKeyNotFound) {
 		return core.L1Head{}, jsonrpc.Err(jsonrpc.InternalError, err.Error())
 	}
-	// empty L1Head is returned if l1 head doesn't exist
+	// empty l1Head is returned if l1 head doesn't exist
 	return l1Head, nil
 }
 
diff --git a/rpc/v6/pending_data_wrapper.go b/rpc/v6/pending_data_wrapper.go
index 196a950899..b6bf86418a 100644
--- a/rpc/v6/pending_data_wrapper.go
+++ b/rpc/v6/pending_data_wrapper.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 
 	"github.com/NethermindEth/juno/core"
+
 	"github.com/NethermindEth/juno/sync/pendingdata"
 )
 
diff --git a/rpc/v6/pending_data_wrapper_test.go b/rpc/v6/pending_data_wrapper_test.go
index 669f42a4c1..bab71738dc 100644
--- a/rpc/v6/pending_data_wrapper_test.go
+++ b/rpc/v6/pending_data_wrapper_test.go
@@ -128,7 +128,7 @@ func TestPendingDataWrapper_PendingState(t *testing.T) {
 	mockReader := mocks.NewMockReader(mockCtrl)
 	handler := rpc.New(mockReader, mockSyncReader, nil, &utils.Sepolia, nil)
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 	t.Run("Returns pending state when starknet version < 0.14.0", func(t *testing.T) {
 		stateDiff := core.EmptyStateDiff()
 		pendingData := core.Pending{
diff --git a/rpc/v6/simulation_test.go b/rpc/v6/simulation_test.go
index e679170ff8..1ecf679ed1 100644
--- a/rpc/v6/simulation_test.go
+++ b/rpc/v6/simulation_test.go
@@ -29,7 +29,7 @@ func TestSimulateTransactions(t *testing.T) {
 	mockVM := mocks.NewMockVM(mockCtrl)
 	handler := rpc.New(mockReader, nil, mockVM, n, utils.NewNopZapLogger())
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 	mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil).AnyTimes()
 	headsHeader := &core.Header{
 		SequencerAddress: n.BlockHashMetaInfo.FallBackSequencerAddress,
@@ -234,7 +234,7 @@ func TestSimulateTransactionsShouldErrorWithoutSenderAddressOrResourceBounds(t *
 
 			mockReader := mocks.NewMockReader(mockCtrl)
 			mockVM := mocks.NewMockVM(mockCtrl)
-			mockState := mocks.NewMockCommonState(mockCtrl)
+			mockState := mocks.NewMockStateReader(mockCtrl)
 
 			mockReader.EXPECT().Network().Return(n)
 			mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v6/trace.go b/rpc/v6/trace.go
index 4fcff3b313..ca975514b3 100644
--- a/rpc/v6/trace.go
+++ b/rpc/v6/trace.go
@@ -12,6 +12,7 @@ import (
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/jsonrpc"
 	rpccore "github.com/NethermindEth/juno/rpc/rpccore"
 	"github.com/NethermindEth/juno/utils"
diff --git a/rpc/v6/trace_test.go b/rpc/v6/trace_test.go
index 63f1f7a4d8..9d97fe5b7b 100644
--- a/rpc/v6/trace_test.go
+++ b/rpc/v6/trace_test.go
@@ -275,7 +275,7 @@ func TestTraceTransaction(t *testing.T) {
 		mockReader.EXPECT().BlockByHash(header.Hash).Return(block, nil)
 
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(nil, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		headState.EXPECT().Class(tx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 
@@ -357,7 +357,7 @@ func TestTraceTransaction(t *testing.T) {
 			nil,
 		).Times(2)
 
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).
 			Return(headState, nopCloser, nil).Times(2)
 
@@ -588,7 +588,7 @@ func TestTraceBlockTransactions(t *testing.T) {
 			NewClasses: map[felt.Felt]core.ClassDefinition{*declareTx.ClassHash: declaredClass.Class},
 		}
 
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		mockSyncReader.EXPECT().PendingData().Return(
 			&pending,
 			nil,
@@ -678,7 +678,7 @@ func TestTraceBlockTransactions(t *testing.T) {
 		mockReader.EXPECT().BlockByHash(blockHash).Return(block, nil)
 
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(nil, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		headState.EXPECT().Class(tx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 
@@ -1178,7 +1178,7 @@ func TestCall(t *testing.T) {
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	t.Run("call - unknown contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v7/compiled_casm_test.go b/rpc/v7/compiled_casm_test.go
index 4762567e5e..45fa8f7a56 100644
--- a/rpc/v7/compiled_casm_test.go
+++ b/rpc/v7/compiled_casm_test.go
@@ -36,7 +36,7 @@ func TestCompiledCasm(t *testing.T) {
 	t.Run("class doesn't exist", func(t *testing.T) {
 		classHash := felt.NewUnsafeFromString[felt.Felt]("0x111")
 
-		mockState := mocks.NewMockCommonState(mockCtrl)
+		mockState := mocks.NewMockStateReader(mockCtrl)
 		mockState.EXPECT().Class(classHash).Return(nil, db.ErrKeyNotFound)
 		rd.EXPECT().HeadState().Return(mockState, nopCloser, nil)
 
@@ -65,7 +65,7 @@ func TestCompiledCasm(t *testing.T) {
 		err = json.Unmarshal(program, &deprecatedCairoDefinition)
 		require.NoError(t, err)
 
-		mockState := mocks.NewMockCommonState(mockCtrl)
+		mockState := mocks.NewMockStateReader(mockCtrl)
 		mockState.EXPECT().Class(classHash).Return(&core.DeclaredClassDefinition{Class: class}, nil)
 		rd.EXPECT().HeadState().Return(mockState, nopCloser, nil)
 
diff --git a/rpc/v7/estimate_fee_test.go b/rpc/v7/estimate_fee_test.go
index b9227541c5..35695c99ef 100644
--- a/rpc/v7/estimate_fee_test.go
+++ b/rpc/v7/estimate_fee_test.go
@@ -30,7 +30,7 @@ func TestEstimateFee(t *testing.T) {
 	log := utils.NewNopZapLogger()
 	handler := rpcv7.New(mockReader, nil, mockVM, n, log)
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 	mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil).AnyTimes()
 	mockReader.EXPECT().HeadsHeader().Return(&core.Header{}, nil).AnyTimes()
 
diff --git a/rpc/v7/handlers_test.go b/rpc/v7/handlers_test.go
index f97e3a4898..76960f821b 100644
--- a/rpc/v7/handlers_test.go
+++ b/rpc/v7/handlers_test.go
@@ -34,7 +34,7 @@ func TestThrottledVMError(t *testing.T) {
 
 	throttledVM := node.NewThrottledVM(mockVM, 0, 0)
 	handler := rpcv7.New(mockReader, mockSyncReader, throttledVM, &utils.Mainnet, nil)
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	throttledErr := "VM throughput limit reached"
 	t.Run("call", func(t *testing.T) {
@@ -83,9 +83,9 @@ func TestThrottledVMError(t *testing.T) {
 		}
 
 		mockReader.EXPECT().BlockByHash(blockHash).Return(block, nil)
-		state := mocks.NewMockCommonState(mockCtrl)
+		state := mocks.NewMockStateReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(state, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		headState.EXPECT().Class(declareTx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 		_, httpHeader, rpcErr := handler.TraceBlockTransactions(
diff --git a/rpc/v7/helpers.go b/rpc/v7/helpers.go
index cf07f14318..9992885311 100644
--- a/rpc/v7/helpers.go
+++ b/rpc/v7/helpers.go
@@ -9,6 +9,7 @@ import (
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/jsonrpc"
 	"github.com/NethermindEth/juno/rpc/rpccore"
@@ -22,7 +23,7 @@ func (h *Handler) l1Head() (core.L1Head, *jsonrpc.Error) {
 	if errors.Is(err, db.ErrKeyNotFound) {
 		return core.L1Head{}, nil
 	}
-	// empty L1Head is returned if l1 head doesn't exist
+	// empty l1Head is returned if l1 head doesn't exist
 	return l1Head, nil
 }
 
diff --git a/rpc/v7/pending_data_wrapper.go b/rpc/v7/pending_data_wrapper.go
index eda21537ce..a5221ebae6 100644
--- a/rpc/v7/pending_data_wrapper.go
+++ b/rpc/v7/pending_data_wrapper.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 
 	"github.com/NethermindEth/juno/core"
+
 	"github.com/NethermindEth/juno/sync/pendingdata"
 )
 
diff --git a/rpc/v7/pending_data_wrapper_test.go b/rpc/v7/pending_data_wrapper_test.go
index 99dbb24a92..3424897295 100644
--- a/rpc/v7/pending_data_wrapper_test.go
+++ b/rpc/v7/pending_data_wrapper_test.go
@@ -129,7 +129,7 @@ func TestPendingDataWrapper_PendingState(t *testing.T) {
 	mockReader := mocks.NewMockReader(mockCtrl)
 	handler := rpc.New(mockReader, mockSyncReader, nil, &utils.Sepolia, nil)
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 	t.Run("Returns pending state when starknet version < 0.14.0", func(t *testing.T) {
 		stateDiff := core.EmptyStateDiff()
 		pendingData := core.Pending{
diff --git a/rpc/v7/simulation_test.go b/rpc/v7/simulation_test.go
index 4424621a4b..63dd71dde2 100644
--- a/rpc/v7/simulation_test.go
+++ b/rpc/v7/simulation_test.go
@@ -31,7 +31,7 @@ func TestSimulateTransactions(t *testing.T) {
 	mockVM := mocks.NewMockVM(mockCtrl)
 	handler := rpcv7.New(mockReader, nil, mockVM, n, utils.NewNopZapLogger())
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 	mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil).AnyTimes()
 	headsHeader := &core.Header{
 		SequencerAddress: n.BlockHashMetaInfo.FallBackSequencerAddress,
@@ -224,7 +224,7 @@ func TestSimulateTransactionsShouldErrorWithoutSenderAddressOrResourceBounds(t *
 
 			mockReader := mocks.NewMockReader(mockCtrl)
 			mockVM := mocks.NewMockVM(mockCtrl)
-			mockState := mocks.NewMockCommonState(mockCtrl)
+			mockState := mocks.NewMockStateReader(mockCtrl)
 
 			mockReader.EXPECT().Network().Return(n)
 			mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v7/storage_test.go b/rpc/v7/storage_test.go
index d22c26e600..f842fd8068 100644
--- a/rpc/v7/storage_test.go
+++ b/rpc/v7/storage_test.go
@@ -63,7 +63,7 @@ func TestStorageAt(t *testing.T) {
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	t.Run("non-existent contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v7/trace.go b/rpc/v7/trace.go
index b755da13d8..0c04b82b5f 100644
--- a/rpc/v7/trace.go
+++ b/rpc/v7/trace.go
@@ -13,6 +13,7 @@ import (
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/jsonrpc"
 	"github.com/NethermindEth/juno/rpc/rpccore"
diff --git a/rpc/v7/trace_test.go b/rpc/v7/trace_test.go
index 3e81dbb167..4c82b595e5 100644
--- a/rpc/v7/trace_test.go
+++ b/rpc/v7/trace_test.go
@@ -311,7 +311,7 @@ func TestTraceTransaction(t *testing.T) {
 		mockReader.EXPECT().BlockByHash(header.Hash).Return(block, nil)
 
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(nil, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		headState.EXPECT().Class(tx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 
@@ -427,7 +427,7 @@ func TestTraceTransaction(t *testing.T) {
 			&pending,
 			nil,
 		).Times(2)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).
 			Return(headState, nopCloser, nil).Times(2)
 
@@ -712,7 +712,7 @@ func TestTraceBlockTransactions(t *testing.T) {
 			NewClasses: map[felt.Felt]core.ClassDefinition{*declareTx.ClassHash: declaredClass.Class},
 		}
 		mockSyncReader.EXPECT().PendingData().Return(&pending, nil).Times(2)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).
 			Return(headState, nopCloser, nil).Times(2)
 
@@ -827,7 +827,7 @@ func TestTraceBlockTransactions(t *testing.T) {
 		mockReader.EXPECT().BlockByHash(blockHash).Return(block, nil)
 
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(nil, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		headState.EXPECT().Class(tx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 
@@ -1556,7 +1556,7 @@ func TestCall(t *testing.T) {
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	t.Run("call - unknown contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v8/compiled_casm_test.go b/rpc/v8/compiled_casm_test.go
index 825b1dda5c..bdf7279104 100644
--- a/rpc/v8/compiled_casm_test.go
+++ b/rpc/v8/compiled_casm_test.go
@@ -37,7 +37,7 @@ func TestCompiledCasm(t *testing.T) {
 	t.Run("class doesn't exist", func(t *testing.T) {
 		classHash := felt.NewUnsafeFromString[felt.Felt]("0x111")
 
-		mockState := mocks.NewMockCommonState(mockCtrl)
+		mockState := mocks.NewMockStateReader(mockCtrl)
 		mockState.EXPECT().Class(classHash).Return(nil, db.ErrKeyNotFound)
 		rd.EXPECT().HeadState().Return(mockState, nopCloser, nil)
 
@@ -66,7 +66,7 @@ func TestCompiledCasm(t *testing.T) {
 		err = json.Unmarshal(program, &deprecatedCairoDefinition)
 		require.NoError(t, err)
 
-		mockState := mocks.NewMockCommonState(mockCtrl)
+		mockState := mocks.NewMockStateReader(mockCtrl)
 		mockState.EXPECT().Class(classHash).Return(&core.DeclaredClassDefinition{Class: class}, nil)
 		rd.EXPECT().HeadState().Return(mockState, nopCloser, nil)
 
@@ -108,7 +108,7 @@ func TestCompiledCasm(t *testing.T) {
 			Compiled: casmClass,
 		}
 
-		mockState := mocks.NewMockCommonState(mockCtrl)
+		mockState := mocks.NewMockStateReader(mockCtrl)
 		mockState.EXPECT().Class(classHash).Return(&core.DeclaredClassDefinition{Class: sierraClass}, nil)
 		rd.EXPECT().HeadState().Return(mockState, nopCloser, nil)
 
diff --git a/rpc/v8/estimate_fee_test.go b/rpc/v8/estimate_fee_test.go
index 10a5bbca65..77b5b035ed 100644
--- a/rpc/v8/estimate_fee_test.go
+++ b/rpc/v8/estimate_fee_test.go
@@ -30,7 +30,7 @@ func TestEstimateFee(t *testing.T) {
 	log := utils.NewNopZapLogger()
 	handler := rpc.New(mockReader, nil, mockVM, log)
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 	mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil).AnyTimes()
 	mockReader.EXPECT().HeadsHeader().Return(&core.Header{}, nil).AnyTimes()
 
diff --git a/rpc/v8/handlers_test.go b/rpc/v8/handlers_test.go
index be025d7518..72d874cc84 100644
--- a/rpc/v8/handlers_test.go
+++ b/rpc/v8/handlers_test.go
@@ -34,7 +34,7 @@ func TestThrottledVMError(t *testing.T) {
 
 	throttledVM := node.NewThrottledVM(mockVM, 0, 0)
 	handler := rpcv8.New(mockReader, mockSyncReader, throttledVM, nil)
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	throttledErr := "VM throughput limit reached"
 	t.Run("call", func(t *testing.T) {
@@ -87,9 +87,9 @@ func TestThrottledVMError(t *testing.T) {
 		}
 
 		mockReader.EXPECT().BlockByHash(blockHash).Return(block, nil)
-		state := mocks.NewMockCommonState(mockCtrl)
+		state := mocks.NewMockStateReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(state, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		headState.EXPECT().Class(declareTx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 		blockID := blockIDHash(t, blockHash)
diff --git a/rpc/v8/helpers.go b/rpc/v8/helpers.go
index 742badf1b3..48e3f4ee75 100644
--- a/rpc/v8/helpers.go
+++ b/rpc/v8/helpers.go
@@ -9,6 +9,7 @@ import (
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/jsonrpc"
 	"github.com/NethermindEth/juno/rpc/rpccore"
@@ -19,7 +20,7 @@ func (h *Handler) l1Head() (core.L1Head, *jsonrpc.Error) {
 	if err != nil && !errors.Is(err, db.ErrKeyNotFound) {
 		return core.L1Head{}, jsonrpc.Err(jsonrpc.InternalError, err.Error())
 	}
-	// empty L1Head is returned if l1 head doesn't exist
+	// empty l1Head is returned if l1 head doesn't exist
 	return l1Head, nil
 }
 
diff --git a/rpc/v8/pending_data_wrapper.go b/rpc/v8/pending_data_wrapper.go
index 4be358c6dd..18e661b793 100644
--- a/rpc/v8/pending_data_wrapper.go
+++ b/rpc/v8/pending_data_wrapper.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 
 	"github.com/NethermindEth/juno/core"
+
 	"github.com/NethermindEth/juno/sync/pendingdata"
 )
 
diff --git a/rpc/v8/pending_data_wrapper_test.go b/rpc/v8/pending_data_wrapper_test.go
index 2b933512eb..759412ec5c 100644
--- a/rpc/v8/pending_data_wrapper_test.go
+++ b/rpc/v8/pending_data_wrapper_test.go
@@ -128,7 +128,7 @@ func TestPendingDataWrapper_PendingState(t *testing.T) {
 	mockReader := mocks.NewMockReader(mockCtrl)
 	handler := rpc.New(mockReader, mockSyncReader, nil, nil)
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 	t.Run("Returns pending state when starknet version < 0.14.0", func(t *testing.T) {
 		stateDiff := core.EmptyStateDiff()
 		pendingData := core.Pending{
diff --git a/rpc/v8/simulation_test.go b/rpc/v8/simulation_test.go
index 4322f71e09..e17f6e8c3c 100644
--- a/rpc/v8/simulation_test.go
+++ b/rpc/v8/simulation_test.go
@@ -39,21 +39,17 @@ func TestSimulateTransactions(t *testing.T) {
 	defaultMockBehavior := func(
 		mockReader *mocks.MockReader,
 		_ *mocks.MockVM,
-		mockState *mocks.MockCommonState,
+		mockState *mocks.MockStateReader,
 	) {
 		mockReader.EXPECT().Network().Return(n)
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
 		mockReader.EXPECT().HeadsHeader().Return(headsHeader, nil)
 	}
 	tests := []struct {
-		name         string
-		stepsUsed    uint64
-		err          *jsonrpc.Error
-		mockBehavior func(
-			mockReader *mocks.MockReader,
-			mockVM *mocks.MockVM,
-			mockState *mocks.MockCommonState,
-		)
+		name            string
+		stepsUsed       uint64
+		err             *jsonrpc.Error
+		mockBehavior    func(*mocks.MockReader, *mocks.MockVM, *mocks.MockStateReader)
 		simulationFlags []rpcv6.SimulationFlag
 		simulatedTxs    []rpc.SimulatedTransaction
 	}{
@@ -63,9 +59,8 @@ func TestSimulateTransactions(t *testing.T) {
 			mockBehavior: func(
 				mockReader *mocks.MockReader,
 				mockVM *mocks.MockVM,
-				mockState *mocks.MockCommonState,
+				mockState *mocks.MockStateReader,
 			) {
-				t.Parallel()
 				defaultMockBehavior(mockReader, mockVM, mockState)
 				mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &vm.BlockInfo{
 					Header: headsHeader,
@@ -87,9 +82,8 @@ func TestSimulateTransactions(t *testing.T) {
 			mockBehavior: func(
 				mockReader *mocks.MockReader,
 				mockVM *mocks.MockVM,
-				mockState *mocks.MockCommonState,
+				mockState *mocks.MockStateReader,
 			) {
-				t.Parallel()
 				defaultMockBehavior(mockReader, mockVM, mockState)
 				mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &vm.BlockInfo{
 					Header: headsHeader,
@@ -110,9 +104,8 @@ func TestSimulateTransactions(t *testing.T) {
 			mockBehavior: func(
 				mockReader *mocks.MockReader,
 				mockVM *mocks.MockVM,
-				mockState *mocks.MockCommonState,
+				mockState *mocks.MockStateReader,
 			) {
-				t.Parallel()
 				defaultMockBehavior(mockReader, mockVM, mockState)
 				mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &vm.BlockInfo{
 					Header: headsHeader,
@@ -133,9 +126,8 @@ func TestSimulateTransactions(t *testing.T) {
 			mockBehavior: func(
 				mockReader *mocks.MockReader,
 				mockVM *mocks.MockVM,
-				mockState *mocks.MockCommonState,
+				mockState *mocks.MockStateReader,
 			) {
-				t.Parallel()
 				defaultMockBehavior(mockReader, mockVM, mockState)
 				mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &vm.BlockInfo{
 					Header: headsHeader,
@@ -163,7 +155,7 @@ func TestSimulateTransactions(t *testing.T) {
 
 			mockReader := mocks.NewMockReader(mockCtrl)
 			mockVM := mocks.NewMockVM(mockCtrl)
-			mockState := mocks.NewMockCommonState(mockCtrl)
+			mockState := mocks.NewMockStateReader(mockCtrl)
 
 			test.mockBehavior(mockReader, mockVM, mockState)
 			handler := rpc.New(mockReader, nil, mockVM, utils.NewNopZapLogger())
@@ -287,7 +279,7 @@ func TestSimulateTransactionsShouldErrorWithoutSenderAddressOrResourceBounds(t *
 
 			mockReader := mocks.NewMockReader(mockCtrl)
 			mockVM := mocks.NewMockVM(mockCtrl)
-			mockState := mocks.NewMockCommonState(mockCtrl)
+			mockState := mocks.NewMockStateReader(mockCtrl)
 
 			mockReader.EXPECT().Network().Return(n)
 			mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v8/storage.go b/rpc/v8/storage.go
index c5614d8350..228767fe87 100644
--- a/rpc/v8/storage.go
+++ b/rpc/v8/storage.go
@@ -7,6 +7,7 @@ import (
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
 	"github.com/NethermindEth/juno/core/state"
+
 	"github.com/NethermindEth/juno/core/trie"
 	"github.com/NethermindEth/juno/core/trie2"
 	"github.com/NethermindEth/juno/core/trie2/trienode"
@@ -224,7 +225,7 @@ func getClassProof(tr core.CommonTrie, classes []felt.Felt) ([]*HashToNode, erro
 	case *trie2.Trie:
 		classProof := trie2.NewProofNodeSet()
 		for _, class := range classes {
-			if err := t.Prove(&class, classProof); err != nil {
+			if err := (*trie2.Trie)(t).Prove(&class, classProof); err != nil {
 				return nil, err
 			}
 		}
@@ -241,9 +242,9 @@ func getContractProof(
 ) (*ContractProof, error) {
 	switch t := tr.(type) {
 	case *trie.Trie:
-		return getContractProofWithDeprecatedTrie(t, state, contracts)
+		return getContractProofWithDeprecatedTrie((*trie.Trie)(t), state, contracts)
 	case *trie2.Trie:
-		return getContractProofWithTrie(t, state, contracts)
+		return getContractProofWithTrie((*trie2.Trie)(t), state, contracts)
 	default:
 		return nil, fmt.Errorf("unknown trie type: %T", tr)
 	}
@@ -497,7 +498,6 @@ type ContractProof struct {
 	Nodes      []*HashToNode `json:"nodes"`
 	LeavesData []*LeafData   `json:"contract_leaves_data"`
 }
-
 type GlobalRoots struct {
 	ContractsTreeRoot *felt.Felt `json:"contracts_tree_root"`
 	ClassesTreeRoot   *felt.Felt `json:"classes_tree_root"`
diff --git a/rpc/v8/storage_test.go b/rpc/v8/storage_test.go
index d4b789317f..0ea6803a18 100644
--- a/rpc/v8/storage_test.go
+++ b/rpc/v8/storage_test.go
@@ -82,7 +82,7 @@ func TestStorageAt(t *testing.T) {
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	t.Run("non-existent contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
@@ -287,7 +287,7 @@ func TestStorageProof(t *testing.T) {
 	headBlock := &core.Block{Header: &core.Header{Hash: blkHash, Number: blockNumber}}
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 	mockReader.EXPECT().HeadState().Return(mockState, func() error { return nil }, nil).AnyTimes()
 	mockReader.EXPECT().Height().Return(blockNumber, nil).AnyTimes()
 	mockReader.EXPECT().Head().Return(headBlock, nil).AnyTimes()
diff --git a/rpc/v8/trace.go b/rpc/v8/trace.go
index 0d683637f2..df092cbfae 100644
--- a/rpc/v8/trace.go
+++ b/rpc/v8/trace.go
@@ -11,6 +11,7 @@ import (
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/jsonrpc"
 	"github.com/NethermindEth/juno/rpc/rpccore"
diff --git a/rpc/v8/trace_test.go b/rpc/v8/trace_test.go
index 3f9ddff750..be40f37b27 100644
--- a/rpc/v8/trace_test.go
+++ b/rpc/v8/trace_test.go
@@ -311,7 +311,7 @@ func TestTraceTransaction(t *testing.T) {
 		mockReader.EXPECT().BlockByHash(header.Hash).Return(block, nil)
 
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(nil, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		headState.EXPECT().Class(tx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 
@@ -411,7 +411,7 @@ func TestTraceTransaction(t *testing.T) {
 			&pending,
 			nil,
 		).Times(2)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).
 			Return(headState, nopCloser, nil).Times(2)
 
@@ -674,7 +674,7 @@ func TestTraceBlockTransactions(t *testing.T) {
 			NewClasses: map[felt.Felt]core.ClassDefinition{*declareTx.ClassHash: declaredClass.Class},
 		}
 		mockSyncReader.EXPECT().PendingData().Return(&pending, nil).Times(2)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).
 			Return(headState, nopCloser, nil).Times(2)
 
@@ -802,7 +802,7 @@ func TestTraceBlockTransactions(t *testing.T) {
 		mockReader.EXPECT().BlockByHash(blockHash).Return(block, nil)
 
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(nil, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		headState.EXPECT().Class(tx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 
@@ -1316,7 +1316,7 @@ func TestCall(t *testing.T) {
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	t.Run("call - unknown contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v9/class_test.go b/rpc/v9/class_test.go
index 7401bc198b..0e63e3fad6 100644
--- a/rpc/v9/class_test.go
+++ b/rpc/v9/class_test.go
@@ -12,7 +12,7 @@ import (
 	"github.com/NethermindEth/juno/mocks"
 	rpccore "github.com/NethermindEth/juno/rpc/rpccore"
 	rpcv6 "github.com/NethermindEth/juno/rpc/v6"
-	rpcv9 "github.com/NethermindEth/juno/rpc/v9"
+	rpc "github.com/NethermindEth/juno/rpc/v9"
 	adaptfeeder "github.com/NethermindEth/juno/starknetdata/feeder"
 	"github.com/NethermindEth/juno/utils"
 	"github.com/stretchr/testify/assert"
@@ -29,7 +29,7 @@ func TestClass(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	mockState.EXPECT().Class(gomock.Any()).DoAndReturn(
 		func(classHash *felt.Felt) (*core.DeclaredClassDefinition, error) {
@@ -40,7 +40,7 @@ func TestClass(t *testing.T) {
 		return nil
 	}, nil).AnyTimes()
 	mockReader.EXPECT().HeadsHeader().Return(new(core.Header), nil).AnyTimes()
-	handler := rpcv9.New(mockReader, nil, nil, utils.NewNopZapLogger())
+	handler := rpc.New(mockReader, nil, nil, utils.NewNopZapLogger())
 
 	latest := blockIDLatest(t)
 
@@ -75,7 +75,7 @@ func TestClass(t *testing.T) {
 
 	t.Run("state by id error", func(t *testing.T) {
 		mockReader := mocks.NewMockReader(mockCtrl)
-		handler := rpcv9.New(mockReader, nil, nil, utils.NewNopZapLogger())
+		handler := rpc.New(mockReader, nil, nil, utils.NewNopZapLogger())
 
 		mockReader.EXPECT().HeadState().Return(nil, nil, db.ErrKeyNotFound)
 
@@ -86,8 +86,8 @@ func TestClass(t *testing.T) {
 
 	t.Run("class hash not found error", func(t *testing.T) {
 		mockReader := mocks.NewMockReader(mockCtrl)
-		mockState := mocks.NewMockCommonState(mockCtrl)
-		handler := rpcv9.New(mockReader, nil, nil, utils.NewNopZapLogger())
+		mockState := mocks.NewMockStateReader(mockCtrl)
+		handler := rpc.New(mockReader, nil, nil, utils.NewNopZapLogger())
 
 		mockReader.EXPECT().HeadState().Return(mockState, func() error {
 			return nil
@@ -109,7 +109,7 @@ func TestClassAt(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	deprecatedCairoContractAddress := felt.NewRandom[felt.Felt]()
 	deprecatedCairoClassHash := felt.NewUnsafeFromString[felt.Felt](
@@ -134,7 +134,7 @@ func TestClassAt(t *testing.T) {
 		return nil
 	}, nil).AnyTimes()
 	mockReader.EXPECT().HeadsHeader().Return(new(core.Header), nil).AnyTimes()
-	handler := rpcv9.New(mockReader, nil, nil, utils.NewNopZapLogger())
+	handler := rpc.New(mockReader, nil, nil, utils.NewNopZapLogger())
 
 	latest := blockIDLatest(t)
 
@@ -167,7 +167,7 @@ func TestClassHashAt(t *testing.T) {
 	mockReader := mocks.NewMockReader(mockCtrl)
 	mockSyncReader := mocks.NewMockSyncReader(mockCtrl)
 	log := utils.NewNopZapLogger()
-	handler := rpcv9.New(mockReader, mockSyncReader, nil, log)
+	handler := rpc.New(mockReader, mockSyncReader, nil, log)
 
 	targetAddress := felt.FromUint64[felt.Felt](1234)
 	t.Run("empty blockchain", func(t *testing.T) {
@@ -194,7 +194,7 @@ func TestClassHashAt(t *testing.T) {
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	t.Run("non-existent contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v9/compiled_casm_test.go b/rpc/v9/compiled_casm_test.go
index 890721d037..72274bdd81 100644
--- a/rpc/v9/compiled_casm_test.go
+++ b/rpc/v9/compiled_casm_test.go
@@ -37,7 +37,7 @@ func TestCompiledCasm(t *testing.T) {
 	t.Run("class doesn't exist", func(t *testing.T) {
 		classHash := felt.NewUnsafeFromString[felt.Felt]("0x111")
 
-		mockState := mocks.NewMockCommonState(mockCtrl)
+		mockState := mocks.NewMockStateReader(mockCtrl)
 		mockState.EXPECT().Class(classHash).Return(nil, db.ErrKeyNotFound)
 		rd.EXPECT().HeadState().Return(mockState, nopCloser, nil)
 
@@ -66,7 +66,7 @@ func TestCompiledCasm(t *testing.T) {
 		err = json.Unmarshal(program, &deprecatedCairoDefinition)
 		require.NoError(t, err)
 
-		mockState := mocks.NewMockCommonState(mockCtrl)
+		mockState := mocks.NewMockStateHistoryReader(mockCtrl)
 		mockState.EXPECT().Class(classHash).Return(&core.DeclaredClassDefinition{Class: class}, nil)
 		rd.EXPECT().HeadState().Return(mockState, nopCloser, nil)
 
@@ -108,7 +108,7 @@ func TestCompiledCasm(t *testing.T) {
 			Compiled: &casm,
 		}
 
-		mockState := mocks.NewMockCommonState(mockCtrl)
+		mockState := mocks.NewMockStateHistoryReader(mockCtrl)
 		mockState.EXPECT().Class(classHash).Return(&core.DeclaredClassDefinition{Class: cairoClass}, nil)
 		rd.EXPECT().HeadState().Return(mockState, nopCloser, nil)
 
diff --git a/rpc/v9/estimate_fee_test.go b/rpc/v9/estimate_fee_test.go
index b8a1c814de..4bd99bcebe 100644
--- a/rpc/v9/estimate_fee_test.go
+++ b/rpc/v9/estimate_fee_test.go
@@ -30,7 +30,7 @@ func TestEstimateFee(t *testing.T) {
 	log := utils.NewNopZapLogger()
 	handler := rpc.New(mockReader, nil, mockVM, log)
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 	mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil).AnyTimes()
 	mockReader.EXPECT().HeadsHeader().Return(&core.Header{}, nil).AnyTimes()
 
diff --git a/rpc/v9/handlers_test.go b/rpc/v9/handlers_test.go
index 779d20068a..25c90e5a17 100644
--- a/rpc/v9/handlers_test.go
+++ b/rpc/v9/handlers_test.go
@@ -34,7 +34,7 @@ func TestThrottledVMError(t *testing.T) {
 
 	throttledVM := node.NewThrottledVM(mockVM, 0, 0)
 	handler := rpcv9.New(mockReader, mockSyncReader, throttledVM, nil)
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	throttledErr := "VM throughput limit reached"
 	t.Run("call", func(t *testing.T) {
@@ -87,9 +87,9 @@ func TestThrottledVMError(t *testing.T) {
 		}
 
 		mockReader.EXPECT().BlockByHash(blockHash).Return(block, nil)
-		state := mocks.NewMockCommonState(mockCtrl)
+		state := mocks.NewMockStateReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(state, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		headState.EXPECT().Class(declareTx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 		blockID := blockIDHash(t, blockHash)
diff --git a/rpc/v9/helpers.go b/rpc/v9/helpers.go
index e5ae90a7e1..6f381010df 100644
--- a/rpc/v9/helpers.go
+++ b/rpc/v9/helpers.go
@@ -9,6 +9,7 @@ import (
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/jsonrpc"
 	"github.com/NethermindEth/juno/rpc/rpccore"
diff --git a/rpc/v9/nonce_test.go b/rpc/v9/nonce_test.go
index 29b22b7ce1..43525b224a 100644
--- a/rpc/v9/nonce_test.go
+++ b/rpc/v9/nonce_test.go
@@ -52,7 +52,7 @@ func TestNonce(t *testing.T) {
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	t.Run("non-existent contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v9/pending_data_wrapper.go b/rpc/v9/pending_data_wrapper.go
index 8b401582f5..3de26e4617 100644
--- a/rpc/v9/pending_data_wrapper.go
+++ b/rpc/v9/pending_data_wrapper.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 
 	"github.com/NethermindEth/juno/core"
+
 	"github.com/NethermindEth/juno/sync/pendingdata"
 )
 
diff --git a/rpc/v9/pending_data_wrapper_test.go b/rpc/v9/pending_data_wrapper_test.go
index fd1ba3a0d5..330514dd91 100644
--- a/rpc/v9/pending_data_wrapper_test.go
+++ b/rpc/v9/pending_data_wrapper_test.go
@@ -117,7 +117,7 @@ func TestPendingDataWrapper_PendingState(t *testing.T) {
 	mockReader := mocks.NewMockReader(mockCtrl)
 	handler := rpc.New(mockReader, mockSyncReader, nil, nil)
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 	t.Run("Returns pending state", func(t *testing.T) {
 		stateDiff := core.EmptyStateDiff()
 		pendingData := core.PreConfirmed{
diff --git a/rpc/v9/simulation_test.go b/rpc/v9/simulation_test.go
index 6d4cb9e8b0..b6bdffa063 100644
--- a/rpc/v9/simulation_test.go
+++ b/rpc/v9/simulation_test.go
@@ -39,7 +39,7 @@ func TestSimulateTransactions(t *testing.T) {
 	defaultMockBehavior := func(
 		mockReader *mocks.MockReader,
 		_ *mocks.MockVM,
-		mockState *mocks.MockCommonState,
+		mockState *mocks.MockStateReader,
 	) {
 		mockReader.EXPECT().Network().Return(n)
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
@@ -49,7 +49,7 @@ func TestSimulateTransactions(t *testing.T) {
 		name            string
 		stepsUsed       uint64
 		err             *jsonrpc.Error
-		mockBehavior    func(*mocks.MockReader, *mocks.MockVM, *mocks.MockCommonState)
+		mockBehavior    func(*mocks.MockReader, *mocks.MockVM, *mocks.MockStateReader)
 		simulationFlags []rpcv6.SimulationFlag
 		simulatedTxs    []rpc.SimulatedTransaction
 	}{
@@ -59,9 +59,8 @@ func TestSimulateTransactions(t *testing.T) {
 			mockBehavior: func(
 				mockReader *mocks.MockReader,
 				mockVM *mocks.MockVM,
-				mockState *mocks.MockCommonState,
+				mockState *mocks.MockStateReader,
 			) {
-				t.Parallel()
 				defaultMockBehavior(mockReader, mockVM, mockState)
 				mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &vm.BlockInfo{
 					Header: headsHeader,
@@ -83,9 +82,8 @@ func TestSimulateTransactions(t *testing.T) {
 			mockBehavior: func(
 				mockReader *mocks.MockReader,
 				mockVM *mocks.MockVM,
-				mockState *mocks.MockCommonState,
+				mockState *mocks.MockStateReader,
 			) {
-				t.Parallel()
 				defaultMockBehavior(mockReader, mockVM, mockState)
 				mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &vm.BlockInfo{
 					Header: headsHeader,
@@ -106,9 +104,8 @@ func TestSimulateTransactions(t *testing.T) {
 			mockBehavior: func(
 				mockReader *mocks.MockReader,
 				mockVM *mocks.MockVM,
-				mockState *mocks.MockCommonState,
+				mockState *mocks.MockStateReader,
 			) {
-				t.Parallel()
 				defaultMockBehavior(mockReader, mockVM, mockState)
 				mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &vm.BlockInfo{
 					Header: headsHeader,
@@ -129,9 +126,8 @@ func TestSimulateTransactions(t *testing.T) {
 			mockBehavior: func(
 				mockReader *mocks.MockReader,
 				mockVM *mocks.MockVM,
-				mockState *mocks.MockCommonState,
+				mockState *mocks.MockStateReader,
 			) {
-				t.Parallel()
 				defaultMockBehavior(mockReader, mockVM, mockState)
 				mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &vm.BlockInfo{
 					Header: headsHeader,
@@ -159,7 +155,7 @@ func TestSimulateTransactions(t *testing.T) {
 
 			mockReader := mocks.NewMockReader(mockCtrl)
 			mockVM := mocks.NewMockVM(mockCtrl)
-			mockState := mocks.NewMockCommonState(mockCtrl)
+			mockState := mocks.NewMockStateReader(mockCtrl)
 
 			test.mockBehavior(mockReader, mockVM, mockState)
 			handler := rpc.New(mockReader, nil, mockVM, utils.NewNopZapLogger())
@@ -283,7 +279,7 @@ func TestSimulateTransactionsShouldErrorWithoutSenderAddressOrResourceBounds(t *
 
 			mockReader := mocks.NewMockReader(mockCtrl)
 			mockVM := mocks.NewMockVM(mockCtrl)
-			mockState := mocks.NewMockCommonState(mockCtrl)
+			mockState := mocks.NewMockStateReader(mockCtrl)
 
 			mockReader.EXPECT().Network().Return(n)
 			mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rpc/v9/state_update_test.go b/rpc/v9/state_update_test.go
index 88b04acd9a..b7e9cda800 100644
--- a/rpc/v9/state_update_test.go
+++ b/rpc/v9/state_update_test.go
@@ -12,7 +12,7 @@ import (
 	"github.com/NethermindEth/juno/mocks"
 	rpccore "github.com/NethermindEth/juno/rpc/rpccore"
 	rpcv6 "github.com/NethermindEth/juno/rpc/v6"
-	rpcv9 "github.com/NethermindEth/juno/rpc/v9"
+	rpc "github.com/NethermindEth/juno/rpc/v9"
 	adaptfeeder "github.com/NethermindEth/juno/starknetdata/feeder"
 	"github.com/NethermindEth/juno/utils"
 	"github.com/stretchr/testify/assert"
@@ -21,7 +21,7 @@ import (
 )
 
 func TestStateUpdate(t *testing.T) {
-	errTests := map[string]rpcv9.BlockID{
+	errTests := map[string]rpc.BlockID{
 		"latest":        blockIDLatest(t),
 		"pre_confirmed": blockIDPreConfirmed(t),
 		"hash":          blockIDHash(t, &felt.One),
@@ -41,7 +41,7 @@ func TestStateUpdate(t *testing.T) {
 				mockSyncReader.EXPECT().PendingData().Return(nil, core.ErrPendingDataNotFound)
 			}
 			log := utils.NewNopZapLogger()
-			handler := rpcv9.New(chain, mockSyncReader, nil, log)
+			handler := rpc.New(chain, mockSyncReader, nil, log)
 
 			update, rpcErr := handler.StateUpdate(&id)
 			assert.Empty(t, update)
@@ -51,7 +51,7 @@ func TestStateUpdate(t *testing.T) {
 
 	log := utils.NewNopZapLogger()
 	mockReader := mocks.NewMockReader(mockCtrl)
-	handler := rpcv9.New(mockReader, mockSyncReader, nil, log)
+	handler := rpc.New(mockReader, mockSyncReader, nil, log)
 	client := feeder.NewTestClient(t, n)
 	mainnetGw := adaptfeeder.New(client)
 
diff --git a/rpc/v9/storage.go b/rpc/v9/storage.go
index fdbb5e04f5..7aecb5c2d7 100644
--- a/rpc/v9/storage.go
+++ b/rpc/v9/storage.go
@@ -7,6 +7,7 @@ import (
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
 	"github.com/NethermindEth/juno/core/state"
+
 	"github.com/NethermindEth/juno/core/trie"
 	"github.com/NethermindEth/juno/core/trie2"
 	"github.com/NethermindEth/juno/core/trie2/trienode"
@@ -218,7 +219,7 @@ func getClassProof(tr core.CommonTrie, classes []felt.Felt) ([]*HashToNode, erro
 	case *trie.Trie:
 		classProof := trie.NewProofNodeSet()
 		for _, class := range classes {
-			if err := t.Prove(&class, classProof); err != nil {
+			if err := (*trie.Trie)(t).Prove(&class, classProof); err != nil {
 				return nil, err
 			}
 		}
@@ -226,7 +227,7 @@ func getClassProof(tr core.CommonTrie, classes []felt.Felt) ([]*HashToNode, erro
 	case *trie2.Trie:
 		classProof := trie2.NewProofNodeSet()
 		for _, class := range classes {
-			if err := t.Prove(&class, classProof); err != nil {
+			if err := (*trie2.Trie)(t).Prove(&class, classProof); err != nil {
 				return nil, err
 			}
 		}
@@ -245,9 +246,9 @@ func getContractProof(
 	// care about which trie implementation is being used and the output format should be the same
 	switch t := tr.(type) {
 	case *trie.Trie:
-		return getContractProofWithDeprecatedTrie(t, state, contracts)
+		return getContractProofWithDeprecatedTrie((*trie.Trie)(t), state, contracts)
 	case *trie2.Trie:
-		return getContractProofWithTrie(t, state, contracts)
+		return getContractProofWithTrie((*trie2.Trie)(t), state, contracts)
 	default:
 		return nil, fmt.Errorf("unknown trie type: %T", tr)
 	}
diff --git a/rpc/v9/storage_test.go b/rpc/v9/storage_test.go
index 7c4ebef263..d297a231f8 100644
--- a/rpc/v9/storage_test.go
+++ b/rpc/v9/storage_test.go
@@ -81,7 +81,7 @@ func TestStorageAt(t *testing.T) {
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	t.Run("non-existent contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
@@ -298,7 +298,7 @@ func TestStorageProof(t *testing.T) {
 	headBlock := &core.Block{Header: &core.Header{Hash: blkHash, Number: blockNumber}}
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 	mockReader.EXPECT().HeadState().Return(mockState, func() error { return nil }, nil).AnyTimes()
 	mockReader.EXPECT().Height().Return(blockNumber, nil).AnyTimes()
 	mockReader.EXPECT().Head().Return(headBlock, nil).AnyTimes()
diff --git a/rpc/v9/trace_test.go b/rpc/v9/trace_test.go
index a335048c2b..52a2621d8b 100644
--- a/rpc/v9/trace_test.go
+++ b/rpc/v9/trace_test.go
@@ -358,7 +358,7 @@ func TestTraceTransaction(t *testing.T) {
 		mockReader.EXPECT().BlockByHash(header.Hash).Return(block, nil)
 
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(nil, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		headState.EXPECT().Class(tx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 
@@ -440,7 +440,7 @@ func TestTraceTransaction(t *testing.T) {
 			&pending,
 			nil,
 		).Times(2)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).
 			Return(headState, nopCloser, nil).Times(2)
 
@@ -518,7 +518,7 @@ func TestTraceTransaction(t *testing.T) {
 			&preConfirmed,
 			nil,
 		)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockNumber(header.Number-1).
 			Return(headState, nopCloser, nil)
 
@@ -612,7 +612,7 @@ func TestTraceTransaction(t *testing.T) {
 			nil,
 		)
 		mockReader.EXPECT().Receipt(hash).Return(nil, nil, uint64(0), db.ErrKeyNotFound)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateHistoryReader(mockCtrl)
 		mockReader.EXPECT().StateAtBlockHash(preLatest.Block.ParentHash).
 			Return(headState, nopCloser, nil)
 
@@ -853,7 +853,7 @@ func TestTraceBlockTransactions(t *testing.T) {
 		mockReader.EXPECT().BlockByHash(blockHash).Return(block, nil)
 
 		mockReader.EXPECT().StateAtBlockHash(header.ParentHash).Return(nil, nopCloser, nil)
-		headState := mocks.NewMockCommonState(mockCtrl)
+		headState := mocks.NewMockStateReader(mockCtrl)
 		headState.EXPECT().Class(tx.ClassHash).Return(declaredClass, nil)
 		mockReader.EXPECT().HeadState().Return(headState, nopCloser, nil)
 
@@ -1346,7 +1346,7 @@ func TestCall(t *testing.T) {
 		assert.Equal(t, rpccore.ErrBlockNotFound, rpcErr)
 	})
 
-	mockState := mocks.NewMockCommonState(mockCtrl)
+	mockState := mocks.NewMockStateReader(mockCtrl)
 
 	t.Run("call - unknown contract", func(t *testing.T) {
 		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 5675074ab0..d09294494b 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "1.87.0"
+channel = "1.86.0"
 components = ["rustfmt", "clippy"]
diff --git a/sequencer/sequencer.go b/sequencer/sequencer.go
index 87347088f3..9c4ca7f1b4 100644
--- a/sequencer/sequencer.go
+++ b/sequencer/sequencer.go
@@ -9,6 +9,7 @@ import (
 	"github.com/NethermindEth/juno/builder"
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/feed"
 	"github.com/NethermindEth/juno/mempool"
 	"github.com/NethermindEth/juno/plugin"
diff --git a/starknet/class.go b/starknet/class.go
index 14e4170415..8415b01e20 100644
--- a/starknet/class.go
+++ b/starknet/class.go
@@ -88,7 +88,7 @@ type CasmClass struct {
 	Hints                  json.RawMessage `json:"hints"`
 	PythonicHints          json.RawMessage `json:"pythonic_hints"`
 	CompilerVersion        string          `json:"compiler_version"`
-	BytecodeSegmentLengths *SegmentLengths `json:"bytecode_segment_lengths,omitempty"`
+	BytecodeSegmentLengths SegmentLengths  `json:"bytecode_segment_lengths"`
 	EntryPoints            struct {
 		External    []CompiledEntryPoint `json:"EXTERNAL"`
 		L1Handler   []CompiledEntryPoint `json:"L1_HANDLER"`
diff --git a/sync/pendingdata/helpers_test.go b/sync/pendingdata/helpers_test.go
index 8b110405b7..35af249ce8 100644
--- a/sync/pendingdata/helpers_test.go
+++ b/sync/pendingdata/helpers_test.go
@@ -16,7 +16,7 @@ func TestResolvePendingDataBaseState(t *testing.T) {
 	t.Cleanup(mockCtrl.Finish)
 
 	mockReader := mocks.NewMockReader(mockCtrl)
-	mockStateReader := mocks.NewMockCommonState(mockCtrl)
+	mockStateReader := mocks.NewMockStateHistoryReader(mockCtrl)
 	t.Run("PendingBlockVariant", func(t *testing.T) {
 		// Create a pending block
 		pending := &core.Pending{
diff --git a/sync/sync.go b/sync/sync.go
index c3956df096..c6f701bc2b 100644
--- a/sync/sync.go
+++ b/sync/sync.go
@@ -11,6 +11,7 @@ import (
 	"github.com/NethermindEth/juno/blockchain"
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/feed"
 	junoplugin "github.com/NethermindEth/juno/plugin"
diff --git a/vm/rust/Cargo.lock b/vm/rust/Cargo.lock
index 30ca52507a..4ed63ec203 100644
--- a/vm/rust/Cargo.lock
+++ b/vm/rust/Cargo.lock
@@ -102,9 +102,9 @@ checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
 
 [[package]]
 name = "apollo_compile_to_native_types"
-version = "0.16.0-rc.1"
+version = "0.15.0-rc.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2e1832a7d46b878c9d79a4f8686423916f8a4edc35fbfce2ddb98f7ec5f2d8f"
+checksum = "389c8e9ea0c68822b179c75ac3aae646b101c390d01095d993e1ae41287d41d5"
 dependencies = [
  "apollo_config",
  "serde",
@@ -113,9 +113,9 @@ dependencies = [
 
 [[package]]
 name = "apollo_config"
-version = "0.16.0-rc.1"
+version = "0.15.0-rc.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ada910d739cb2ac2ec59766ea956de736f87965b2de60799feedf0de46f7d57a"
+checksum = "b63c97b0be7573c6e0191c8b34776c64ed1bb621148f7d14d14fef4422d630a4"
 dependencies = [
  "apollo_infra_utils",
  "clap",
@@ -132,9 +132,9 @@ dependencies = [
 
 [[package]]
 name = "apollo_infra_utils"
-version = "0.16.0-rc.1"
+version = "0.15.0-rc.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "780c31485db92467019b1ba6cb0a4596c883030238f36ee1e6205fd65b6415e0"
+checksum = "171220821a924e7c170341fc564553163488a17496194ea5f7d2039f294bc2e4"
 dependencies = [
  "apollo_proc_macros",
  "num_enum",
@@ -147,9 +147,9 @@ dependencies = [
 
 [[package]]
 name = "apollo_metrics"
-version = "0.16.0-rc.1"
+version = "0.15.0-rc.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e403e211be2ef8f5af561ee982c4d99291af022d93a63c3b5e983cdcdf4c33a"
+checksum = "eddd44db0a445e928fd4e78641587ef33e4391f186418089511998a90c2f1f2e"
 dependencies = [
  "indexmap 2.9.0",
  "metrics",
@@ -160,9 +160,9 @@ dependencies = [
 
 [[package]]
 name = "apollo_proc_macros"
-version = "0.16.0-rc.1"
+version = "0.15.0-rc.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dde929210d699f0fce6c8e4068881a48304c5ff1f09e6607962725d1d7bd015d"
+checksum = "a7989de6d0cf43a44d6c69c20f183e23af6959fc2be53f65554e4efaf8e6cb5b"
 dependencies = [
  "lazy_static",
  "proc-macro2",
@@ -494,22 +494,21 @@ checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
 
 [[package]]
 name = "bincode"
-version = "2.0.1"
+version = "1.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
 dependencies = [
- "bincode_derive",
  "serde",
- "unty",
 ]
 
 [[package]]
-name = "bincode_derive"
+name = "bincode"
 version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
 dependencies = [
- "virtue",
+ "serde",
+ "unty",
 ]
 
 [[package]]
@@ -545,15 +544,6 @@ dependencies = [
  "wyz",
 ]
 
-[[package]]
-name = "blake2"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
-dependencies = [
- "digest",
-]
-
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -565,9 +555,9 @@ dependencies = [
 
 [[package]]
 name = "blockifier"
-version = "0.16.0-rc.1"
+version = "0.15.0-rc.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b33eff1e4bb8d60cc248781b3aeb87e61c0707f3fd3f483b78ce72bbc29e15c"
+checksum = "63be42f5ff48f7f9065b8b03d137fece1cc153c7aefcffb267abd5abd6e4e09a"
 dependencies = [
  "anyhow",
  "apollo_compile_to_native_types",
@@ -582,7 +572,6 @@ dependencies = [
  "cairo-lang-casm",
  "cairo-lang-runner",
  "cairo-lang-starknet-classes",
- "cairo-lang-utils",
  "cairo-vm",
  "dashmap",
  "derive_more",
@@ -716,9 +705,9 @@ checksum = "ade8366b8bd5ba243f0a58f036cc0ca8a2f069cff1a2351ef1cac6b083e16fc0"
 
 [[package]]
 name = "cairo-lang-casm"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d1d84a85b59c753aa4a7f0c455a5c815e0aebb89faf0c8ab366b0d87c0bb934"
+checksum = "88bf35a939eaed69b8a71405c5d56fa52c3b1c76701b8c1056fe22b3e2569c7d"
 dependencies = [
  "cairo-lang-utils",
  "indoc",
@@ -730,9 +719,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-compiler"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a5cbeb4e134cf29c63d18a235beae3f124bef2824ec45d09d6e18a0c334e509"
+checksum = "c13c2341fb2272999f6152b0fc2238148fe93c745183a07acba031b27eeb0b66"
 dependencies = [
  "anyhow",
  "cairo-lang-defs",
@@ -741,7 +730,6 @@ dependencies = [
  "cairo-lang-lowering",
  "cairo-lang-parser",
  "cairo-lang-project",
- "cairo-lang-runnable-utils",
  "cairo-lang-semantic",
  "cairo-lang-sierra",
  "cairo-lang-sierra-generator",
@@ -757,20 +745,20 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-debug"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa5311e1c31d413f3fa34e40e48b662c19151f0fb4b10467d627a52c93eae918"
+checksum = "17cf782d64a29c4acb1eb2759c39783d5e92c397d5ae3775754edae5d2c665ee"
 dependencies = [
  "cairo-lang-utils",
 ]
 
 [[package]]
 name = "cairo-lang-defs"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "872feccf7b8f70ed5d74c40548bf974fbcc5069b2ea1ae15a9b8f1ab911c536b"
+checksum = "80a146574d443e7fba848c069d7d84879c4635df5811963a18bf042df3e34e61"
 dependencies = [
- "bincode",
+ "bincode 1.3.3",
  "cairo-lang-debug",
  "cairo-lang-diagnostics",
  "cairo-lang-filesystem",
@@ -782,14 +770,13 @@ dependencies = [
  "serde",
  "smol_str",
  "typetag",
- "xxhash-rust",
 ]
 
 [[package]]
 name = "cairo-lang-diagnostics"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d0e7c551a634708366af3003176f2f9cdea56fd4a91c834ddd802030366f6a5"
+checksum = "cb704187b1543aa4a2e0030d13ae6e0ad63712e5362cac3ded3237623a2b1b32"
 dependencies = [
  "cairo-lang-debug",
  "cairo-lang-filesystem",
@@ -799,9 +786,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-eq-solver"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed04fc3f52d68157f359257c477e30f68dec36bbf568c85d567812583cd5f9c8"
+checksum = "a5a2e6145241a4812820948278a86e11c25adc30e9a19b2e24b2517be19eedac"
 dependencies = [
  "cairo-lang-utils",
  "good_lp",
@@ -809,9 +796,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-filesystem"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca1835a43a00a90d5cd4ca3f6bb9178ec450d55458e8b56ac34ca1d6d0ccf58f"
+checksum = "3c903cdcae48aa02c0ed41e1fd54b3231da51f1edf9538327ed155463594b8be"
 dependencies = [
  "cairo-lang-debug",
  "cairo-lang-utils",
@@ -825,9 +812,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-formatter"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bd0736456004f1d334bad5b366c6933c4b856a23a5dfade96cfe0a1c5eb3ddb"
+checksum = "a943f0818cfc091c3302acd92053ff2a642004d32757c3b4f94c5aa18e184ac0"
 dependencies = [
  "anyhow",
  "cairo-lang-diagnostics",
@@ -838,18 +825,19 @@ dependencies = [
  "diffy",
  "ignore",
  "itertools 0.14.0",
+ "rust-analyzer-salsa",
  "serde",
  "thiserror 2.0.12",
 ]
 
 [[package]]
 name = "cairo-lang-lowering"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd2e1d66c241fba4f3dc43e42956001940298fb4ea5970acfc8b2db8bf4b6629"
+checksum = "7b86cd38af57c36b2a72a2483d04d8b17ea2f9a554fd45b9d83375773f948818"
 dependencies = [
  "assert_matches",
- "bincode",
+ "bincode 1.3.3",
  "cairo-lang-debug",
  "cairo-lang-defs",
  "cairo-lang-diagnostics",
@@ -871,9 +859,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-parser"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15c3ab263d4afd34a002dc0e37f9bacca734aa133dbbb8540651d28308977a68"
+checksum = "f64f0a5ca9ac54975cdec98fe8491d9b62922b7cb048e6ded00188383b841b25"
 dependencies = [
  "cairo-lang-diagnostics",
  "cairo-lang-filesystem",
@@ -892,9 +880,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-plugins"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "566059584384c12fa598ae0e0509fd3d12b3985a25872de22e37245c4bc5762c"
+checksum = "6230c6d37e5e8361900709112e56b42e48478806b829a086727ef59b2f7f3310"
 dependencies = [
  "cairo-lang-defs",
  "cairo-lang-diagnostics",
@@ -917,9 +905,9 @@ checksum = "123ac0ecadf31bacae77436d72b88fa9caef2b8e92c89ce63a125ae911a12fae"
 
 [[package]]
 name = "cairo-lang-proc-macros"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61599d8cac760505d1913fa5d7dddcf019f22d47f0748ff66b1b58afe1858b62"
+checksum = "b1e4872352761cf6d7f47eeb1626e3b1d84a514017fb4251173148d8c04f36d5"
 dependencies = [
  "cairo-lang-debug",
  "quote",
@@ -928,9 +916,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-project"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99635e2569cebc31583110b417e6a410990a494c7d56998f2be0a169a1158456"
+checksum = "2327b8c070f9e50ac85a410f03c6aaf6a0dffee5ba8299d6af4bf2344587ac42"
 dependencies = [
  "cairo-lang-filesystem",
  "cairo-lang-utils",
@@ -941,9 +929,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-runnable-utils"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f747c3d433ec5e82576e59852fd8c86a802fefe55e7bdbb9c0db61adb1a40e7b"
+checksum = "775b064b0265e8408565b1ec9d360116015acf35753f02db255cbb13ad30670e"
 dependencies = [
  "cairo-lang-casm",
  "cairo-lang-sierra",
@@ -959,9 +947,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-runner"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40a9ab4bb286d641463b2253070c145c53ff7e71f29cda2a49915f79ff7db927"
+checksum = "e7166250692bda4b8b31f0480b8ba7fe75793b15bd4f0b6e5b5fe5d6dde01da8"
 dependencies = [
  "ark-ff 0.5.0",
  "ark-secp256k1 0.5.0",
@@ -980,7 +968,7 @@ dependencies = [
  "num-bigint",
  "num-integer",
  "num-traits",
- "rand 0.9.2",
+ "rand 0.9.1",
  "sha2",
  "smol_str",
  "starknet-types-core",
@@ -989,9 +977,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-semantic"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf1e01333b127fa3733f2f93b3febc45219ef55b807d196f298cadea6ad8fe44"
+checksum = "f53a1ea47d1a0295179881d5578fc2b2c8cd5d2ac99bd81958c423d54960bb84"
 dependencies = [
  "cairo-lang-debug",
  "cairo-lang-defs",
@@ -1016,9 +1004,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-sierra"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "300655046f505cf806a918918e5397b20c22b579d78c2ef09bc7d4d59fd733be"
+checksum = "a48fe249ba77fb39363b1b40c81556c8d272083508b4618fb65b964559aca0ee"
 dependencies = [
  "anyhow",
  "cairo-lang-utils",
@@ -1043,9 +1031,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-sierra-ap-change"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c51190f463ac9f7d4a2ce0e0345cfc92334589811a7114eeeec84029999d7f1"
+checksum = "fad6cbf5cc904f4309179793fc3757c1db9615e71c1b78eff601d2e22206d1c6"
 dependencies = [
  "cairo-lang-eq-solver",
  "cairo-lang-sierra",
@@ -1059,9 +1047,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-sierra-gas"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb0d0f038acd79aedcadad4ad2ad928b0881c4e96a2d9ad0e0b3173a6111f313"
+checksum = "704ec6a8cb1b38f78571d5561519e87672ed5008a018a422842fa2a122ca3c34"
 dependencies = [
  "cairo-lang-eq-solver",
  "cairo-lang-sierra",
@@ -1075,9 +1063,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-sierra-generator"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bc8d2a89273ba24529319982a4a7833f2a6c4a87752baea2bc70ceb4b3285b7"
+checksum = "2e011122028a59557ff075b22f550f7d0267b493f3db3dbefc281ff6795d108c"
 dependencies = [
  "cairo-lang-debug",
  "cairo-lang-defs",
@@ -1099,9 +1087,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-sierra-to-casm"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c852277442b2d8ca9741cdc8ccb737c6ad381d300ab4e2d982a98ba40e5f5b6"
+checksum = "6a43885fd8e806f5c50a80473798faad1a9a919f474e469d3027aece4f8b2002"
 dependencies = [
  "assert_matches",
  "cairo-lang-casm",
@@ -1120,9 +1108,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-sierra-type-size"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "265aa8daaa94cc4d5e135a82c0bbe7d28d2c0fbc612332903dbf1a68ed15978f"
+checksum = "860006ddce78cae65babf37ff279c31358336ae76717991837d7e0868561878c"
 dependencies = [
  "cairo-lang-sierra",
  "cairo-lang-utils",
@@ -1130,9 +1118,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-starknet"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "deb8bf3ccf8fe1f910291d388a2351b6f40ad32be07bdbd3a628e103387b1a48"
+checksum = "4ba6eb0a421d3411f4948e002d3dd81ab134044465bda3131f2718f56afda409"
 dependencies = [
  "anyhow",
  "cairo-lang-compiler",
@@ -1140,7 +1128,6 @@ dependencies = [
  "cairo-lang-diagnostics",
  "cairo-lang-filesystem",
  "cairo-lang-lowering",
- "cairo-lang-parser",
  "cairo-lang-plugins",
  "cairo-lang-semantic",
  "cairo-lang-sierra",
@@ -1162,9 +1149,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-starknet-classes"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4839b63927954a7c3d018fd012ce0bea256db205b85ee45df27fb1e90cb10e02"
+checksum = "2cf81db2c36c1e3fe3bbf64ebc5c237f748e9f41bdd42a6ed3e03e00086d768c"
 dependencies = [
  "cairo-lang-casm",
  "cairo-lang-sierra",
@@ -1185,9 +1172,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-syntax"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f83d5b0213ddab04090f4a10d009ff3428a0d6e289f4fea31798210d60d5cb"
+checksum = "f36620fd45292fd0276bd581e774222fbd06e13aa8a4bf820a4be8ad3bcec100"
 dependencies = [
  "cairo-lang-debug",
  "cairo-lang-filesystem",
@@ -1203,9 +1190,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-syntax-codegen"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d00ae64466774b6e34a91c4a66202778b17ef5a844a6f668436e28d71ccb9b2"
+checksum = "0e5e3c6be0b159dad1239fa83562087448aeb1d44b0ead059ea6ab73728909a8"
 dependencies = [
  "genco",
  "xshell",
@@ -1213,9 +1200,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-test-utils"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebbd4ebcd82ab07fba3d376a6aa992aa552fcb7f051736f6b5a2122381754bdb"
+checksum = "4c65df2eee1678a29b4b9dcff5c10a70b44e38d445ba2522025b1b6b7177b61f"
 dependencies = [
  "cairo-lang-formatter",
  "cairo-lang-utils",
@@ -1226,9 +1213,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-utils"
-version = "2.12.3"
+version = "2.12.0-dev.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cca315cce0937801a772bee5fe92cca28b8172421bdd2f67c96e8288a0dcfb9f"
+checksum = "5f043065d60a8a2510bfacb6c91767298fed50ed9abbd69ff7698322b7cb1e65"
 dependencies = [
  "hashbrown 0.15.2",
  "indexmap 2.9.0",
@@ -1243,12 +1230,12 @@ dependencies = [
 
 [[package]]
 name = "cairo-vm"
-version = "2.5.0"
+version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c21cacdf4e290ab5f0018f24d6bf97f8d3a8809bd09568550669270e7f9ed534"
+checksum = "2afc2bb5cf948599994a1f1634edc81934c3952e2f32c8e49efbde63d767fa69"
 dependencies = [
  "anyhow",
- "bincode",
+ "bincode 2.0.1",
  "bitvec",
  "generic-array",
  "hashbrown 0.15.2",
@@ -1828,10 +1815,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
 dependencies = [
  "cfg-if",
- "js-sys",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "wasm-bindgen",
 ]
 
 [[package]]
@@ -2340,13 +2325,11 @@ dependencies = [
 
 [[package]]
 name = "lambdaworks-crypto"
-version = "0.13.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58b1a1c1102a5a7fbbda117b79fb3a01e033459c738a3c1642269603484fd1c1"
+checksum = "bbc2a4da0d9e52ccfe6306801a112e81a8fc0c76aa3e4449fefeda7fef72bb34"
 dependencies = [
  "lambdaworks-math",
- "rand 0.8.5",
- "rand_chacha 0.3.1",
  "serde",
  "sha2",
  "sha3",
@@ -2354,14 +2337,10 @@ dependencies = [
 
 [[package]]
 name = "lambdaworks-math"
-version = "0.13.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "018a95aa873eb49896a858dee0d925c33f3978d073c64b08dd4f2c9b35a017c6"
+checksum = "d1bd2632acbd9957afc5aeec07ad39f078ae38656654043bf16e046fa2730e23"
 dependencies = [
- "getrandom 0.2.15",
- "num-bigint",
- "num-traits",
- "rand 0.8.5",
  "serde",
  "serde_json",
 ]
@@ -2972,9 +2951,9 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.2"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
@@ -3318,35 +3297,19 @@ name = "size-of"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4e36eca171fddeda53901b0a436573b3f2391eaa9189d439b2bd8ea8cebd7e3"
-
-[[package]]
-name = "sizeof"
-version = "0.16.0-rc.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29dcfb1a76f2e5486a3c2d4e66d939813ce9be7500b2169e059a627ed13436cd"
 dependencies = [
- "sizeof_internal",
- "sizeof_macro",
+ "size-of-derive",
 ]
 
 [[package]]
-name = "sizeof_internal"
-version = "0.16.0-rc.1"
+name = "size-of-derive"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2361e1b34f9c2b742419e30e99e2f3094a846dd93fb5edc23ee0f714feb4e43d"
-dependencies = [
- "starknet-types-core",
-]
-
-[[package]]
-name = "sizeof_macro"
-version = "0.16.0-rc.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6503474d48a3ff40a3da73f2e277e33e958245d78fc77e2386c5e521d38b16d"
+checksum = "eefff4890f5308d477f3da563af8bdb8fbb6fabaec4c974bd211896fa7945e68"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.100",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -3397,9 +3360,9 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
 name = "starknet-crypto"
-version = "0.8.1"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1004a16c25dc6113c19d4f9d0c19ff97d85804829894bba22c0d0e9e7b249812"
+checksum = "039a3bad70806b494c9e6b21c5238a6c8a373d66a26071859deb0ccca6f93634"
 dependencies = [
  "crypto-bigint",
  "hex",
@@ -3416,28 +3379,25 @@ dependencies = [
 
 [[package]]
 name = "starknet-curve"
-version = "0.6.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22c898ae81b6409532374cf237f1bd752d068b96c6ad500af9ebbd0d9bb712f6"
+checksum = "bcde6bd74269b8161948190ace6cf069ef20ac6e79cd2ba09b320efa7500b6de"
 dependencies = [
  "starknet-types-core",
 ]
 
 [[package]]
 name = "starknet-types-core"
-version = "0.2.3"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab92594a86ac627dd4c8d3350362cc8035e55c548c27c71dfa4c9fc6b3b6ab1a"
+checksum = "4037bcb26ce7c508448d221e570d075196fd4f6912ae6380981098937af9522a"
 dependencies = [
- "blake2",
- "digest",
  "lambdaworks-crypto",
  "lambdaworks-math",
  "lazy_static",
  "num-bigint",
  "num-integer",
  "num-traits",
- "rand 0.9.2",
  "serde",
  "size-of",
  "zeroize",
@@ -3445,9 +3405,9 @@ dependencies = [
 
 [[package]]
 name = "starknet_api"
-version = "0.16.0-rc.1"
+version = "0.15.0-rc.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9893be10768a72f91012e34ad3fbf66d4e058d3b1886195ebcd05815d3969e00"
+checksum = "5d8aab893c06cdba387b8ef61a079ae0ccdcb926d6ecca11107f536d788e62a8"
 dependencies = [
  "apollo_infra_utils",
  "base64",
@@ -3470,7 +3430,7 @@ dependencies = [
  "serde",
  "serde_json",
  "sha3",
- "sizeof",
+ "size-of",
  "starknet-crypto",
  "starknet-types-core",
  "strum",
@@ -3952,12 +3912,6 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
-[[package]]
-name = "virtue"
-version = "0.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
-
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -4195,12 +4149,6 @@ version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32ac00cd3f8ec9c1d33fb3e7958a82df6989c42d747bd326c822b1d625283547"
 
-[[package]]
-name = "xxhash-rust"
-version = "0.8.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdd20c5420375476fbd4394763288da7eb0cc0b8c11deed431a91562af7335d3"
-
 [[package]]
 name = "yansi"
 version = "1.0.1"
diff --git a/vm/rust/Cargo.toml b/vm/rust/Cargo.toml
index 22ca4a3887..6fda4bcab1 100644
--- a/vm/rust/Cargo.toml
+++ b/vm/rust/Cargo.toml
@@ -8,13 +8,13 @@ edition = "2021"
 [dependencies]
 serde = "1.0.208"
 serde_json = { version = "1.0.125", features = ["raw_value"] }
-blockifier = { version = "0.16.0-rc.1", features = ["node_api"] }
-cairo-lang-casm = "=2.12.3"
-cairo-lang-starknet-classes = "=2.12.3"
-cairo-lang-runner = { version =  "=2.12.3" }
-starknet_api = "0.16.0-rc.1"
-cairo-vm = "=2.5.0"
-starknet-types-core = { version = "=0.2.3", features = ["hash", "prime-bigint"] }
+blockifier = { version = "0.15.0-rc.4", features = ["node_api"] }
+cairo-lang-casm = "=2.12.0-dev.1"
+cairo-lang-starknet-classes = "=2.12.0-dev.1"
+cairo-lang-runner = { version =  "=2.12.0-dev.1" }
+starknet_api = "0.15.0-rc.4"
+cairo-vm = "=2.3.1"
+starknet-types-core = { version = "0.1.8", features = ["hash", "prime-bigint"] }
 indexmap = "2.1.0"
 cached = "0.55.1"
 once_cell = "1.19.0"
diff --git a/vm/rust/src/entrypoint/execute/execute.rs b/vm/rust/src/entrypoint/execute/execute.rs
index 10a3b6fe20..4277456854 100644
--- a/vm/rust/src/entrypoint/execute/execute.rs
+++ b/vm/rust/src/entrypoint/execute/execute.rs
@@ -180,7 +180,7 @@ pub fn cairo_vm_execute(
         )
         .map_err(|err| {
             JunoError::tx_non_execution_error(
-                format!("failed building txn state diff reason: {err:?}"),
+                format!("failed building txn state diff reason: {:?}", err),
                 txn_index,
             )
         })?;
diff --git a/vm/rust/src/entrypoint/execute/utils.rs b/vm/rust/src/entrypoint/execute/utils.rs
index a60237b80f..5c91e2a56e 100644
--- a/vm/rust/src/entrypoint/execute/utils.rs
+++ b/vm/rust/src/entrypoint/execute/utils.rs
@@ -47,13 +47,15 @@ pub fn transaction_from_api(
     match tx {
         StarknetApiTransaction::Deploy(_) => {
             return Err(format!(
-                "Unsupported deploy transaction in the traced block (transaction_hash={tx_hash})",
+                "Unsupported deploy transaction in the traced block (transaction_hash={})",
+                tx_hash,
             ))
         }
         StarknetApiTransaction::Declare(_) if class_info.is_none() => {
             return Err(format!(
-            "Declare transaction must be created with a ContractClass (transaction_hash={tx_hash})",
-        ))
+                "Declare transaction must be created with a ContractClass (transaction_hash={})",
+                tx_hash,
+            ))
         }
         _ => {} // all ok
     };
@@ -66,7 +68,7 @@ pub fn transaction_from_api(
         None,
         execution_flags,
     )
-    .map_err(|err| format!("failed to create transaction from api: {err:?}"))
+    .map_err(|err| format!("failed to create transaction from api: {:?}", err))
 }
 
 pub fn adjust_fee_calculation_result(
@@ -79,9 +81,9 @@ pub fn adjust_fee_calculation_result(
     let (minimal_gas_vector, fee_type) = match &txn {
         Transaction::Account(t) => (
             Some(gas_usage::estimate_minimal_gas_vector(
-                block_context,
+                &block_context,
                 t,
-                gas_vector_computation_mode,
+                &gas_vector_computation_mode,
             )),
             t.fee_type(),
         ),
@@ -95,7 +97,7 @@ pub fn adjust_fee_calculation_result(
         .l1_gas
         .max(minimal_gas_vector.l1_gas);
 
-    let adjusted_l1_data_gas_consumed = tx_execution_info
+    let mut adjusted_l1_data_gas_consumed = tx_execution_info
         .receipt
         .gas
         .l1_data_gas
@@ -107,8 +109,9 @@ pub fn adjust_fee_calculation_result(
         .l2_gas
         .max(minimal_gas_vector.l2_gas);
 
-    if *gas_vector_computation_mode == GasVectorComputationMode::NoL2Gas {
-        adjusted_l1_gas_consumed = adjusted_l1_gas_consumed
+    match gas_vector_computation_mode {
+        GasVectorComputationMode::NoL2Gas => {
+            adjusted_l1_gas_consumed = adjusted_l1_gas_consumed
                 .checked_add(
                     block_context
                         .versioned_constants()
@@ -117,15 +120,18 @@ pub fn adjust_fee_calculation_result(
                 .ok_or_else(|| {
                     JunoError::tx_non_execution_error(
                         format!(
-                            "addition of L2 gas ({adjusted_l2_gas_consumed}) to L1 gas ({adjusted_l1_gas_consumed}) conversion overflowed.",
+                            "addition of L2 gas ({}) to L1 gas ({}) conversion overflowed.",
+                            adjusted_l2_gas_consumed, adjusted_l1_gas_consumed,
                         ),
                         txn_index,
                     )
                 })?;
 
-        adjusted_l2_gas_consumed = GasAmount(0);
+            adjusted_l1_data_gas_consumed = adjusted_l1_data_gas_consumed;
+            adjusted_l2_gas_consumed = GasAmount(0);
+        }
+        _ => {}
     };
-
     let tip = if block_context.versioned_constants().enable_tip {
         match txn {
             Transaction::Account(txn) => txn.tip(),
diff --git a/vm/rust/src/entrypoint/utils.rs b/vm/rust/src/entrypoint/utils.rs
index b46d7bbdfa..b60df990b8 100644
--- a/vm/rust/src/entrypoint/utils.rs
+++ b/vm/rust/src/entrypoint/utils.rs
@@ -123,8 +123,6 @@ pub fn build_block_context(
             eth_fee_token_address: ContractAddress::try_from(eth_fee_token_felt)?,
             strk_fee_token_address: ContractAddress::try_from(strk_fee_token_felt)?,
         },
-        // TODO(Ege): make this configurable
-        is_l3: false,
     };
 
     pre_process_block(
diff --git a/vm/rust/src/error/call.rs b/vm/rust/src/error/call.rs
index 2fbb5a258e..f9e860f0a1 100644
--- a/vm/rust/src/error/call.rs
+++ b/vm/rust/src/error/call.rs
@@ -24,7 +24,7 @@ impl CallError {
         entry_point: EntryPointSelector,
     ) -> Self {
         TransactionExecutionError::ExecutionError {
-            error: Box::new(error),
+            error,
             class_hash,
             storage_address: contract_address,
             selector: entry_point,
diff --git a/vm/rust/src/error/execution.rs b/vm/rust/src/error/execution.rs
index 38c30376d8..117bf5ea69 100644
--- a/vm/rust/src/error/execution.rs
+++ b/vm/rust/src/error/execution.rs
@@ -18,7 +18,7 @@ impl From<StateError> for ExecutionError {
     fn from(e: StateError) -> Self {
         match e {
             StateError::StateReadError(_) => Self::Internal(e.to_string()),
-            _ => Self::Custom(format!("State error: {e}")),
+            _ => Self::Custom(format!("State error: {}", e)),
         }
     }
 }
diff --git a/vm/rust/src/ffi_entrypoint.rs b/vm/rust/src/ffi_entrypoint.rs
index c9bddc02fb..717b428f83 100644
--- a/vm/rust/src/ffi_entrypoint.rs
+++ b/vm/rust/src/ffi_entrypoint.rs
@@ -152,7 +152,8 @@ pub extern "C" fn setVersionedConstants(json_bytes: *const c_char) -> *const c_c
                 CString::new("").unwrap().into_raw()
             },
             Err(e) => CString::new(format!(
-                "Failed to load versioned constants from paths: {e}",
+                "Failed to load versioned constants from paths: {}",
+                e
             ))
             .unwrap()
             .into_raw(),
diff --git a/vm/rust/src/ffi_type/class_info.rs b/vm/rust/src/ffi_type/class_info.rs
index a831f65cd9..412709cfba 100644
--- a/vm/rust/src/ffi_type/class_info.rs
+++ b/vm/rust/src/ffi_type/class_info.rs
@@ -17,7 +17,7 @@ pub struct ClassInfo {
 
 pub fn class_info_from_json_str(raw_json: &str) -> Result<BlockifierClassInfo, String> {
     let class_info: ClassInfo = serde_json::from_str(raw_json)
-        .map_err(|err| format!("failed parsing class info: {err:?}"))?;
+        .map_err(|err| format!("failed parsing class info: {:?}", err))?;
 
     let class_def = class_info.contract_class.get();
     let sierra_version: SierraVersion;
@@ -30,17 +30,17 @@ pub fn class_info_from_json_str(raw_json: &str) -> Result<BlockifierClassInfo, S
             abi_len = 0;
             match parse_deprecated_class_definition(class_def.to_string()) {
                 Ok(class) => class,
-                Err(err) => return Err(format!("failed parsing deprecated class: {err:?}")),
+                Err(err) => return Err(format!("failed parsing deprecated class: {:?}", err)),
             }
         }
         1 => {
             sierra_version = SierraVersion::from_str(&class_info.sierra_version)
-                .map_err(|err| format!("failed parsing sierra version: {err:?}"))?;
+                .map_err(|err| format!("failed parsing sierra version: {:?}", err))?;
             sierra_len = class_info.sierra_program_length;
             abi_len = class_info.abi_length;
             match parse_casm_definition(class_def.to_string(), sierra_version.clone()) {
                 Ok(class) => class,
-                Err(err) => return Err(format!("failed parsing casm class: {err:?}")),
+                Err(err) => return Err(format!("failed parsing casm class: {:?}", err)),
             }
         }
         _ => {
@@ -52,7 +52,7 @@ pub fn class_info_from_json_str(raw_json: &str) -> Result<BlockifierClassInfo, S
     };
 
     BlockifierClassInfo::new(&class, sierra_len, abi_len, sierra_version)
-        .map_err(|err| format!("failed creating BlockifierClassInfo: {err:?}"))
+        .map_err(|err| format!("failed creating BlockifierClassInfo: {:?}", err))
 }
 
 fn parse_deprecated_class_definition(
diff --git a/vm/rust/src/ffi_type/function_invocation.rs b/vm/rust/src/ffi_type/function_invocation.rs
index 6214ef7598..7b97bc7cad 100644
--- a/vm/rust/src/ffi_type/function_invocation.rs
+++ b/vm/rust/src/ffi_type/function_invocation.rs
@@ -9,7 +9,7 @@ use blockifier::{
 use serde::Serialize;
 use starknet_api::{
     contract_class::EntryPointType,
-    core::{ClassHash, ContractAddress, EntryPointSelector, L1Address},
+    core::{ClassHash, ContractAddress, EntryPointSelector, EthAddress},
     transaction::{
         fields::{Calldata, GasVectorComputationMode},
         EventContent, L2ToL1Payload,
@@ -28,7 +28,7 @@ pub struct FunctionCall {
 pub struct OrderedMessage {
     pub order: usize,
     pub from_address: ContractAddress,
-    pub to_address: L1Address,
+    pub to_address: EthAddress,
     pub payload: L2ToL1Payload,
 }
 
diff --git a/vm/rust/src/state_reader/ffi.rs b/vm/rust/src/state_reader/ffi.rs
index 704d629f13..64c0277295 100644
--- a/vm/rust/src/state_reader/ffi.rs
+++ b/vm/rust/src/state_reader/ffi.rs
@@ -23,14 +23,4 @@ extern "C" {
         reader_handle: usize,
         class_hash: *const c_uchar,
     ) -> *const c_char;
-    pub fn JunoStateGetCompiledClassHash(
-        reader_handle: usize,
-        class_hash: *const c_uchar,
-        buffer: *mut c_uchar,
-    ) -> c_int;
-    pub fn JunoStateGetCompiledClassHashV2(
-        reader_handle: usize,
-        class_hash: *const c_uchar,
-        buffer: *mut c_uchar,
-    ) -> c_int;
 }
diff --git a/vm/rust/src/state_reader/state_reader.rs b/vm/rust/src/state_reader/state_reader.rs
index c656a824e5..baf3ccad28 100644
--- a/vm/rust/src/state_reader/state_reader.rs
+++ b/vm/rust/src/state_reader/state_reader.rs
@@ -17,8 +17,7 @@ use crate::{
     ffi_entrypoint::BlockInfo,
     ffi_type::class_info::class_info_from_json_str,
     state_reader::ffi::{
-        JunoFree, JunoStateGetClassHashAt, JunoStateGetCompiledClass,
-        JunoStateGetCompiledClassHash, JunoStateGetCompiledClassHashV2, JunoStateGetNonceAt,
+        JunoFree, JunoStateGetClassHashAt, JunoStateGetCompiledClass, JunoStateGetNonceAt,
         JunoStateGetStorageAt,
     },
 };
@@ -31,9 +30,6 @@ struct CachedRunnableCompiledClass {
 static CLASS_CACHE: Lazy<Mutex<SizedCache<ClassHash, CachedRunnableCompiledClass>>> =
     Lazy::new(|| Mutex::new(SizedCache::with_size(128)));
 
-static CASM_CLASS_HASH_V2_CACHE: Lazy<Mutex<SizedCache<ClassHash, CompiledClassHash>>> =
-    Lazy::new(|| Mutex::new(SizedCache::with_size(128)));
-
 pub enum BlockHeight {
     Height(u64),
     Pending,
@@ -187,65 +183,8 @@ impl StateReader for JunoStateReader {
     }
 
     /// Returns the compiled class hash of the given class hash.
-    /// Returns CompiledClassHash::default() if no v1_class is found for the given class hash.
-    fn get_compiled_class_hash(&self, class_hash: ClassHash) -> StateResult<CompiledClassHash> {
-        let class_hash_bytes = felt_to_byte_array(&class_hash.0);
-        let mut buffer: [u8; 32] = [0; 32];
-        let wrote = unsafe {
-            JunoStateGetCompiledClassHash(
-                self.handle,
-                class_hash_bytes.as_ptr(),
-                buffer.as_mut_ptr(),
-            )
-        };
-        if wrote == 0 {
-            Ok(CompiledClassHash::default())
-        } else {
-            assert!(wrote == 32, "Juno didn't write 32 bytes");
-            Ok(CompiledClassHash(Felt::from_bytes_be(&buffer)))
-        }
-    }
-
-    /// Returns the compiled class hash (v2) of the given class hash.
-    /// Returns `StateError::MissingCompiledClassHashV2` if no v1_class is found for the given class
-    /// hash.
-    fn get_compiled_class_hash_v2(
-        &self,
-        class_hash: ClassHash,
-        compiled_class: &RunnableCompiledClass,
-    ) -> StateResult<CompiledClassHash> {
-        if let Some(cached_hash) = CASM_CLASS_HASH_V2_CACHE
-            .lock()
-            .unwrap()
-            .cache_get(&class_hash)
-            .cloned()
-        {
-            return Ok(cached_hash);
-        }
-
-        let class_hash_bytes = felt_to_byte_array(&class_hash.0);
-        let mut buffer: [u8; 32] = [0; 32];
-        let wrote = unsafe {
-            JunoStateGetCompiledClassHashV2(
-                self.handle,
-                class_hash_bytes.as_ptr(),
-                buffer.as_mut_ptr(),
-            )
-        };
-
-        let casm_hash_v2 = if wrote == 0 {
-            blockifier::state::utils::get_compiled_class_hash_v2(self, class_hash, compiled_class)?
-        } else {
-            assert!(wrote == 32, "Juno didn't write 32 bytes");
-            CompiledClassHash(Felt::from_bytes_be(&buffer))
-        };
-
-        CASM_CLASS_HASH_V2_CACHE
-            .lock()
-            .unwrap()
-            .cache_set(class_hash, casm_hash_v2);
-
-        Ok(casm_hash_v2)
+    fn get_compiled_class_hash(&self, _class_hash: ClassHash) -> StateResult<CompiledClassHash> {
+        unimplemented!()
     }
 }
 
diff --git a/vm/rust/src/versioned_constants.rs b/vm/rust/src/versioned_constants.rs
index 6b905001f2..adbc47da2a 100644
--- a/vm/rust/src/versioned_constants.rs
+++ b/vm/rust/src/versioned_constants.rs
@@ -16,10 +16,10 @@ impl VersionedConstantsMap {
 
         for (version, path) in version_with_path {
             let constants = VersionedConstants::from_path(Path::new(&path))
-                .with_context(|| format!("Failed to parse JSON in file: {path}"))?;
+                .with_context(|| format!("Failed to parse JSON in file: {}", path))?;
 
             let parsed_version = StarknetVersion::try_from(version.as_str())
-                .with_context(|| format!("Failed to parse version string: {version}"))?;
+                .with_context(|| format!("Failed to parse version string: {}", version))?;
 
             result.insert(parsed_version, constants);
         }
diff --git a/vm/state.go b/vm/state.go
index ff3df8fbdc..1020893cea 100644
--- a/vm/state.go
+++ b/vm/state.go
@@ -99,37 +99,3 @@ func fillBufferWithFelt(val *felt.Felt, buffer unsafe.Pointer) C.int {
 	feltBytes := val.Bytes()
 	return C.int(copy(unsafe.Slice((*byte)(buffer), felt.Bytes), feltBytes[:]))
 }
-
-//export JunoStateGetCompiledClassHash
-func JunoStateGetCompiledClassHash(
-	readerHandle C.uintptr_t,
-	classHash,
-	buffer unsafe.Pointer,
-) C.int {
-	context := unwrapContext(readerHandle)
-
-	classHashFelt := makeFeltFromPtr(classHash)
-	val, err := context.state.CompiledClassHash((*felt.SierraClassHash)(classHashFelt))
-	if err != nil {
-		return 0
-	}
-
-	return fillBufferWithFelt((*felt.Felt)(&val), buffer)
-}
-
-//export JunoStateGetCompiledClassHashV2
-func JunoStateGetCompiledClassHashV2(
-	readerHandle C.uintptr_t,
-	classHash,
-	buffer unsafe.Pointer,
-) C.int {
-	context := unwrapContext(readerHandle)
-
-	classHashFelt := makeFeltFromPtr(classHash)
-	val, err := context.state.CompiledClassHashV2((*felt.SierraClassHash)(classHashFelt))
-	if err != nil {
-		return 0
-	}
-
-	return fillBufferWithFelt((*felt.Felt)(&val), buffer)
-}
diff --git a/vm/testdata/versioned_constants/0_13_2.json b/vm/testdata/versioned_constants/0_13_2.json
index b9eaffb8c9..a1a4e1a5b6 100644
--- a/vm/testdata/versioned_constants/0_13_2.json
+++ b/vm/testdata/versioned_constants/0_13_2.json
@@ -56,8 +56,6 @@
     "ignore_inner_event_resources": false,
     "disable_deploy_in_validation_mode": false,
     "enable_reverts": false,
-    "enable_casm_hash_migration": false,
-    "block_casm_hash_v1_declares": false,
     "max_recursion_depth": 50,
     "segment_arena_cells": false,
     "os_constants": {
diff --git a/vm/testdata/versioned_constants/0_14_0.json b/vm/testdata/versioned_constants/0_14_0.json
index 0f8e1276eb..da18fc005c 100644
--- a/vm/testdata/versioned_constants/0_14_0.json
+++ b/vm/testdata/versioned_constants/0_14_0.json
@@ -8,7 +8,7 @@
         "max_calldata_length": 5000,
         "max_contract_bytecode_size": 81920
     },
-    "invoke_tx_max_n_steps": 10000000,
+    "invoke_tx_max_n_steps": 6000000,
     "deprecated_l2_resource_gas_costs": {
         "gas_per_data_felt": [
             128,
@@ -56,8 +56,6 @@
     "ignore_inner_event_resources": false,
     "disable_deploy_in_validation_mode": true,
     "enable_reverts": true,
-    "enable_casm_hash_migration": false,
-    "block_casm_hash_v1_declares": false,
     "max_recursion_depth": 50,
     "segment_arena_cells": false,
     "os_constants": {
@@ -76,7 +74,7 @@
         "error_entry_point_failed": "ENTRYPOINT_FAILED",
         "error_entry_point_not_found": "ENTRYPOINT_NOT_FOUND",
         "execute_entry_point_selector": "0x15d40a3d6ca2ac30f4031e42be28da9b056fef9bb7357ac5e85627ee876e5ad",
-        "execute_max_sierra_gas": 1000000000,
+        "execute_max_sierra_gas": 600000000,
         "default_initial_gas_cost": {
             "step_gas_cost": 100000000
         },
@@ -132,8 +130,7 @@
             "0x0309c042d3729173c7f2f91a34f04d8c509c1b292d334679ef1aabf8da0899cc",
             "0x01a7820094feaf82d53f53f214b81292d717e7bb9a92bb2488092cd306f3993f",
             "0x033434ad846cdd5f23eb73ff09fe6fddd568284a0fb7d1be20ee482f044dabe2",
-            "0x041cb0280ebadaa75f996d8d92c6f265f6d040bb3ba442e5f86a554f1765244e",
-            "0x3530cc4759d78042f1b543bf797f5f3d647cde0388c33734cf91b7f7b9314a9"
+            "0x041cb0280ebadaa75f996d8d92c6f265f6d040bb3ba442e5f86a554f1765244e"
         ],
         "v1_bound_accounts_cairo1": [
             "0x01a736d6ed154502257f02b1ccdf4d9d1089f80811cd6acad48e6b6a9d1f2003",
diff --git a/vm/vm.go b/vm/vm.go
index bb31df9775..32aff3d9f2 100644
--- a/vm/vm.go
+++ b/vm/vm.go
@@ -20,6 +20,7 @@ import (
 
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+
 	"github.com/NethermindEth/juno/starknet"
 	"github.com/NethermindEth/juno/utils"
 )
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 0b04e86b30..aa112dea25 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -8,6 +8,7 @@ import (
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
 	"github.com/NethermindEth/juno/core/state"
+
 	"github.com/NethermindEth/juno/core/state/statefactory"
 	statetestutils "github.com/NethermindEth/juno/core/state/statetestutils"
 	"github.com/NethermindEth/juno/core/trie2/triedb"