test(state): exercise accessors through the public API

Move accessors_test.go to package state_test so it compiles against the
exported accessors only, instead of reaching into unexported internals
(stateDB.disk, newTestStateDB). Contract/class tests now write through a
plain memory store, and history tests build a StateDB/StateReader via the
exported constructors.

Drop the "wraps the stored contract on success" case from TestGetStateObject:
it only asserted, via unexported fields, that the constructor copied its
inputs (a tautological test). The not-found case, which is the actual
behavior of GetStateObject, is kept.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Ehsan-saradar

core/state/accessors_test.go

@@ -1,11 +1,15 @@
-package state
+package state_test
 
 import (
 	"testing"
 
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+	"github.com/NethermindEth/juno/core/state"
+	"github.com/NethermindEth/juno/core/trie2/triedb"
 	"github.com/NethermindEth/juno/db"
+	"github.com/NethermindEth/juno/db/memory"
+	_ "github.com/NethermindEth/juno/encoder/registry"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -14,65 +18,65 @@ func TestContractAccessors(t *testing.T) {
 	addr := felt.NewUnsafeFromString[felt.Felt]("0x123")
 
 	// storeContract stores a contract with the given values and fails the test on error.
-	storeContract := func(t *testing.T, stateDB *StateDB, nonce, classHash string, height uint64) {
+	storeContract := func(t *testing.T, disk db.KeyValueWriter, nonce, classHash string, height uint64) {
 		t.Helper()
-		require.NoError(t, WriteContract(
-			stateDB.disk, addr,
+		require.NoError(t, state.WriteContract(
+			disk, addr,
 			felt.UnsafeFromString[felt.Felt](nonce),
 			felt.UnsafeFromString[felt.Felt](classHash),
 			height,
 		))
 	}
 
 	t.Run("absent before write", func(t *testing.T) {
-		stateDB := newTestStateDB()
+		disk := memory.New()
 
-		exists, err := HasContract(stateDB.disk, addr)
+		exists, err := state.HasContract(disk, addr)
 		require.NoError(t, err)
 		assert.False(t, exists)
 
-		_, err = GetContract(stateDB.disk, addr)
+		_, err = state.GetContract(disk, addr)
 		assert.ErrorIs(t, err, db.ErrKeyNotFound)
 	})
 
 	t.Run("write then read round-trip", func(t *testing.T) {
-		stateDB := newTestStateDB()
-		storeContract(t, stateDB, "0x1", "0xabc", 42)
+		disk := memory.New()
+		storeContract(t, disk, "0x1", "0xabc", 42)
 
-		exists, err := HasContract(stateDB.disk, addr)
+		exists, err := state.HasContract(disk, addr)
 		require.NoError(t, err)
 		assert.True(t, exists)
 
-		contract, err := GetContract(stateDB.disk, addr)
+		contract, err := state.GetContract(disk, addr)
 		require.NoError(t, err)
 		assert.Equal(t, felt.UnsafeFromString[felt.Felt]("0x1"), contract.Nonce)
 		assert.Equal(t, felt.UnsafeFromString[felt.Felt]("0xabc"), contract.ClassHash)
 		assert.Equal(t, uint64(42), contract.DeployedHeight)
 	})
 
 	t.Run("overwrite reflects latest values", func(t *testing.T) {
-		stateDB := newTestStateDB()
-		storeContract(t, stateDB, "0x1", "0xabc", 42)
-		storeContract(t, stateDB, "0x2", "0xdef", 99)
+		disk := memory.New()
+		storeContract(t, disk, "0x1", "0xabc", 42)
+		storeContract(t, disk, "0x2", "0xdef", 99)
 
-		contract, err := GetContract(stateDB.disk, addr)
+		contract, err := state.GetContract(disk, addr)
 		require.NoError(t, err)
 		assert.Equal(t, felt.UnsafeFromString[felt.Felt]("0x2"), contract.Nonce)
 		assert.Equal(t, felt.UnsafeFromString[felt.Felt]("0xdef"), contract.ClassHash)
 		assert.Equal(t, uint64(99), contract.DeployedHeight)
 	})
 
 	t.Run("delete removes the contract", func(t *testing.T) {
-		stateDB := newTestStateDB()
-		storeContract(t, stateDB, "0x1", "0xabc", 42)
+		disk := memory.New()
+		storeContract(t, disk, "0x1", "0xabc", 42)
 
-		require.NoError(t, DeleteContract(stateDB.disk, addr))
+		require.NoError(t, state.DeleteContract(disk, addr))
 
-		exists, err := HasContract(stateDB.disk, addr)
+		exists, err := state.HasContract(disk, addr)
 		require.NoError(t, err)
 		assert.False(t, exists)
 
-		_, err = GetContract(stateDB.disk, addr)
+		_, err = state.GetContract(disk, addr)
 		assert.ErrorIs(t, err, db.ErrKeyNotFound)
 	})
 }
@@ -90,26 +94,26 @@ func TestClassAccessors(t *testing.T) {
 	}
 
 	t.Run("absent before write", func(t *testing.T) {
-		stateDB := newTestStateDB()
+		disk := memory.New()
 
-		exists, err := HasClass(stateDB.disk, classHash)
+		exists, err := state.HasClass(disk, classHash)
 		require.NoError(t, err)
 		assert.False(t, exists)
 
-		_, err = GetClass(stateDB.disk, classHash)
+		_, err = state.GetClass(disk, classHash)
 		assert.ErrorIs(t, err, db.ErrKeyNotFound)
 	})
 
 	t.Run("write then read round-trips the encoded class", func(t *testing.T) {
-		stateDB := newTestStateDB()
+		disk := memory.New()
 		class := newClass()
-		require.NoError(t, WriteClass(stateDB.disk, classHash, class))
+		require.NoError(t, state.WriteClass(disk, classHash, class))
 
-		exists, err := HasClass(stateDB.disk, classHash)
+		exists, err := state.HasClass(disk, classHash)
 		require.NoError(t, err)
 		assert.True(t, exists)
 
-		got, err := GetClass(stateDB.disk, classHash)
+		got, err := state.GetClass(disk, classHash)
 		require.NoError(t, err)
 		assert.Equal(t, class.At, got.At)
 		sierra, ok := got.Class.(*core.SierraClass)
@@ -119,16 +123,16 @@ func TestClassAccessors(t *testing.T) {
 	})
 
 	t.Run("delete removes the class", func(t *testing.T) {
-		stateDB := newTestStateDB()
-		require.NoError(t, WriteClass(stateDB.disk, classHash, newClass()))
+		disk := memory.New()
+		require.NoError(t, state.WriteClass(disk, classHash, newClass()))
 
-		require.NoError(t, DeleteClass(stateDB.disk, classHash))
+		require.NoError(t, state.DeleteClass(disk, classHash))
 
-		exists, err := HasClass(stateDB.disk, classHash)
+		exists, err := state.HasClass(disk, classHash)
 		require.NoError(t, err)
 		assert.False(t, exists)
 
-		_, err = GetClass(stateDB.disk, classHash)
+		_, err = state.GetClass(disk, classHash)
 		assert.ErrorIs(t, err, db.ErrKeyNotFound)
 	})
 }
@@ -143,7 +147,7 @@ func TestHistoryAccessors(t *testing.T) {
 		name     string
 		write    func(w db.KeyValueWriter, blockNum uint64, value *felt.Felt) error
 		del      func(w db.KeyValueWriter, blockNum uint64) error
-		readAt   func(r *StateReader, blockNum uint64) (felt.Felt, error)
+		readAt   func(r *state.StateReader, blockNum uint64) (felt.Felt, error)
 		valueOne *felt.Felt
 		valueTwo *felt.Felt
 	}
@@ -152,12 +156,12 @@ func TestHistoryAccessors(t *testing.T) {
 		{
 			name: "nonce",
 			write: func(w db.KeyValueWriter, blockNum uint64, value *felt.Felt) error {
-				return WriteNonceHistory(w, addr, blockNum, value)
+				return state.WriteNonceHistory(w, addr, blockNum, value)
 			},
 			del: func(w db.KeyValueWriter, blockNum uint64) error {
-				return DeleteNonceHistory(w, addr, blockNum)
+				return state.DeleteNonceHistory(w, addr, blockNum)
 			},
-			readAt: func(r *StateReader, blockNum uint64) (felt.Felt, error) {
+			readAt: func(r *state.StateReader, blockNum uint64) (felt.Felt, error) {
 				return r.ContractNonceAt(addr, blockNum)
 			},
 			valueOne: felt.NewUnsafeFromString[felt.Felt]("0x7"),
@@ -166,12 +170,12 @@ func TestHistoryAccessors(t *testing.T) {
 		{
 			name: "class hash",
 			write: func(w db.KeyValueWriter, blockNum uint64, value *felt.Felt) error {
-				return WriteClassHashHistory(w, addr, blockNum, value)
+				return state.WriteClassHashHistory(w, addr, blockNum, value)
 			},
 			del: func(w db.KeyValueWriter, blockNum uint64) error {
-				return DeleteClassHashHistory(w, addr, blockNum)
+				return state.DeleteClassHashHistory(w, addr, blockNum)
 			},
-			readAt: func(r *StateReader, blockNum uint64) (felt.Felt, error) {
+			readAt: func(r *state.StateReader, blockNum uint64) (felt.Felt, error) {
 				return r.ContractClassHashAt(addr, blockNum)
 			},
 			valueOne: felt.NewUnsafeFromString[felt.Felt]("0xaaa"),
@@ -180,12 +184,12 @@ func TestHistoryAccessors(t *testing.T) {
 		{
 			name: "storage",
 			write: func(w db.KeyValueWriter, blockNum uint64, value *felt.Felt) error {
-				return WriteStorageHistory(w, addr, storageKey, blockNum, value)
+				return state.WriteStorageHistory(w, addr, storageKey, blockNum, value)
 			},
 			del: func(w db.KeyValueWriter, blockNum uint64) error {
-				return DeleteStorageHistory(w, addr, storageKey, blockNum)
+				return state.DeleteStorageHistory(w, addr, storageKey, blockNum)
 			},
-			readAt: func(r *StateReader, blockNum uint64) (felt.Felt, error) {
+			readAt: func(r *state.StateReader, blockNum uint64) (felt.Felt, error) {
 				return r.ContractStorageAt(addr, storageKey, blockNum)
 			},
 			valueOne: felt.NewUnsafeFromString[felt.Felt]("0xdef"),
@@ -197,47 +201,48 @@ func TestHistoryAccessors(t *testing.T) {
 
 	for _, k := range kinds {
 		t.Run(k.name, func(t *testing.T) {
-			// newReader returns a fresh state and a reader over it, so each subtest
+			// newReader returns a fresh disk store and a reader over it, so each subtest
 			// starts from an empty history and is independent of execution order.
-			newReader := func(t *testing.T) (*StateDB, *StateReader) {
+			newReader := func(t *testing.T) (db.KeyValueStore, *state.StateReader) {
 				t.Helper()
-				stateDB := newTestStateDB()
-				reader, err := NewStateReader(&felt.Zero, stateDB)
+				disk := memory.New()
+				stateDB := state.NewStateDB(disk, triedb.New(disk, nil))
+				reader, err := state.NewStateReader(&felt.Zero, stateDB)
 				require.NoError(t, err)
-				return stateDB, reader
+				return disk, reader
 			}
 
 			t.Run("reads the written value at its block", func(t *testing.T) {
-				stateDB, reader := newReader(t)
-				require.NoError(t, k.write(stateDB.disk, blockOne, k.valueOne))
+				disk, reader := newReader(t)
+				require.NoError(t, k.write(disk, blockOne, k.valueOne))
 
 				got, err := k.readAt(reader, blockOne)
 				require.NoError(t, err)
 				assert.Equal(t, *k.valueOne, got)
 			})
 
 			t.Run("steps back to the last entry for a later block", func(t *testing.T) {
-				stateDB, reader := newReader(t)
-				require.NoError(t, k.write(stateDB.disk, blockOne, k.valueOne))
+				disk, reader := newReader(t)
+				require.NoError(t, k.write(disk, blockOne, k.valueOne))
 
 				got, err := k.readAt(reader, blockOne+3)
 				require.NoError(t, err)
 				assert.Equal(t, *k.valueOne, got)
 			})
 
 			t.Run("reads zero before the first entry", func(t *testing.T) {
-				stateDB, reader := newReader(t)
-				require.NoError(t, k.write(stateDB.disk, blockOne, k.valueOne))
+				disk, reader := newReader(t)
+				require.NoError(t, k.write(disk, blockOne, k.valueOne))
 
 				got, err := k.readAt(reader, blockOne-1)
 				require.NoError(t, err)
 				assert.Equal(t, felt.Zero, got)
 			})
 
 			t.Run("honours block boundaries across two entries", func(t *testing.T) {
-				stateDB, reader := newReader(t)
-				require.NoError(t, k.write(stateDB.disk, blockOne, k.valueOne))
-				require.NoError(t, k.write(stateDB.disk, blockTwo, k.valueTwo))
+				disk, reader := newReader(t)
+				require.NoError(t, k.write(disk, blockOne, k.valueOne))
+				require.NoError(t, k.write(disk, blockTwo, k.valueTwo))
 
 				between, err := k.readAt(reader, blockTwo-1)
 				require.NoError(t, err)
@@ -249,12 +254,12 @@ func TestHistoryAccessors(t *testing.T) {
 			})
 
 			t.Run("delete drops the entry", func(t *testing.T) {
-				stateDB, reader := newReader(t)
-				require.NoError(t, k.write(stateDB.disk, blockOne, k.valueOne))
-				require.NoError(t, k.write(stateDB.disk, blockTwo, k.valueTwo))
+				disk, reader := newReader(t)
+				require.NoError(t, k.write(disk, blockOne, k.valueOne))
+				require.NoError(t, k.write(disk, blockTwo, k.valueTwo))
 
-				require.NoError(t, k.del(stateDB.disk, blockOne))
-				require.NoError(t, k.del(stateDB.disk, blockTwo))
+				require.NoError(t, k.del(disk, blockOne))
+				require.NoError(t, k.del(disk, blockTwo))
 
 				got, err := k.readAt(reader, blockTwo+1)
 				require.NoError(t, err)
@@ -268,25 +273,9 @@ func TestGetStateObject(t *testing.T) {
 	addr := felt.NewUnsafeFromString[felt.Felt]("0x123")
 
 	t.Run("propagates not-found for a missing contract", func(t *testing.T) {
-		stateDB := newTestStateDB()
+		disk := memory.New()
 
-		_, err := GetStateObject(stateDB.disk, nil, addr)
+		_, err := state.GetStateObject(disk, nil, addr)
 		assert.ErrorIs(t, err, db.ErrKeyNotFound)
 	})
-
-	t.Run("wraps the stored contract on success", func(t *testing.T) {
-		stateDB := newTestStateDB()
-		require.NoError(t, WriteContract(stateDB.disk, addr,
-			felt.UnsafeFromString[felt.Felt]("0x1"),
-			felt.UnsafeFromString[felt.Felt]("0xabc"),
-			42,
-		))
-
-		obj, err := GetStateObject(stateDB.disk, nil, addr)
-		require.NoError(t, err)
-		assert.Equal(t, *addr, obj.addr)
-		assert.Equal(t, felt.UnsafeFromString[felt.Felt]("0x1"), obj.contract.Nonce)
-		assert.Equal(t, felt.UnsafeFromString[felt.Felt]("0xabc"), obj.contract.ClassHash)
-		assert.Equal(t, uint64(42), obj.contract.DeployedHeight)
-	})
 }