fix(state): unify the errors with the old state for backward compatibility

Author: MaksymMalicki

core/deprecatedstate/state_test.go

@@ -52,7 +52,7 @@ func TestUpdate(t *testing.T) {
 
 	t.Run("error when state current root doesn't match state update's old root",
 		func(t *testing.T) {
-			oldRoot := new(felt.Felt).SetBytes([]byte("some old root"))
+			oldRoot := felt.NewFromBytes[felt.Felt]([]byte("some old root"))
 			su := &core.StateUpdate{
 				OldRoot: oldRoot,
 			}
@@ -65,7 +65,7 @@ func TestUpdate(t *testing.T) {
 		})
 
 	t.Run("error when state new root doesn't match state update's new root", func(t *testing.T) {
-		newRoot := new(felt.Felt).SetBytes([]byte("some new root"))
+		newRoot := felt.NewFromBytes[felt.Felt]([]byte("some new root"))
 		su := &core.StateUpdate{
 			NewRoot:   newRoot,
 			OldRoot:   su0.NewRoot,
@@ -116,7 +116,7 @@ func TestUpdate(t *testing.T) {
 	scValue := felt.NewUnsafeFromString[felt.Felt](
 		"0x10979c6b0b36b03be36739a21cc43a51076545ce6d3397f1b45c7e286474ad5",
 	)
-	scAddr := new(felt.Felt).SetUint64(1)
+	scAddr := &felt.One
 
 	su4 := &core.StateUpdate{
 		OldRoot: su3.NewRoot,
@@ -249,7 +249,7 @@ func TestNonce(t *testing.T) {
 	})
 
 	t.Run("update contract nonce", func(t *testing.T) {
-		expectedNonce := new(felt.Felt).SetUint64(1)
+		expectedNonce := &felt.One
 		su = &core.StateUpdate{
 			NewRoot: felt.NewUnsafeFromString[felt.Felt](
 				"0x6210642ffd49f64617fc9e5c0bbe53a6a92769e2996eb312a42d2bdb7f2afc1",

core/state/accessors.go

@@ -1,7 +1,6 @@
 package state
 
 import (
-	"errors"
 	"fmt"
 
 	"github.com/NethermindEth/juno/core"
@@ -19,21 +18,10 @@ func GetStateObject(r db.KeyValueReader, state *State, addr *felt.Felt) (*stateO
 	return &obj, nil
 }
 
-// Gets a contract instance from the database. If it doesn't exist returns a contract not deployed error
-func GetContract(r db.KeyValueReader, addr *felt.Felt) (stateContract, error) {
-	contract, err := getContract(r, addr)
-	if err != nil {
-		if errors.Is(err, db.ErrKeyNotFound) {
-			return stateContract{}, ErrContractNotDeployed
-		}
-		return stateContract{}, err
-	}
-
-	return contract, nil
-}
-
 // Gets a contract instance from the database.
-func getContract(r db.KeyValueReader, addr *felt.Felt) (stateContract, error) {
+// Returns db.ErrKeyNotFound when the contract does not exist, for backward compatibility.
+// TODO: return more precise error (e.g. ErrContractNotDeployed) once deprecated state is removed.
+func GetContract(r db.KeyValueReader, addr *felt.Felt) (stateContract, error) {
 	key := db.ContractKey(addr)
 	var contract stateContract
 	if err := r.Get(key, func(val []byte) error {

core/state/errors.go

@@ -5,7 +5,6 @@ import (
 )
 
 var (
-	ErrContractNotDeployed        = errors.New("contract not deployed")
 	ErrContractAlreadyDeployed    = errors.New("contract already deployed")
 	ErrNoHistoryValue             = errors.New("no history value found")
 	ErrHistoricalTrieNotSupported = errors.New("cannot support historical trie")

core/state/factory/state_factory.go

@@ -76,9 +76,10 @@ func (s *stateHistory) checkDeployed(addr *felt.Felt) error {
 	}
 
 	if !isDeployed {
-		// TODO(weiihann): previously this was db.ErrKeyNotFound
-		// remember to handle it in the rpc
-		return ErrContractNotDeployed
+		// TODO: return a dedicated error like ErrContractNotFound
+		// once deprecated state is removed. Using db.ErrKeyNotFound
+		// for backward compatibility.
+		return db.ErrKeyNotFound
 	}
 
 	return nil

core/state/factory/state_factory_test.go

@@ -122,7 +122,7 @@ func TestStateHistoryContractOperations(t *testing.T) {
 	t.Run("NonExistentContract", func(t *testing.T) {
 		nonExistentAddr := new(felt.Felt).SetUint64(999)
 		_, err := historyBlock0.ContractClassHash(nonExistentAddr)
-		assert.ErrorIs(t, err, ErrContractNotDeployed)
+		assert.ErrorIs(t, err, db.ErrKeyNotFound)
 	})
 }
 

core/state/history.go

@@ -497,7 +497,7 @@ func (s *State) updateContractStorage(blockNum uint64, storage map[felt.Felt]map
 	for addr, storage := range storage {
 		obj, err := s.getStateObject(&addr)
 		if err != nil {
-			if _, ok := noClassContracts[addr]; ok && errors.Is(err, ErrContractNotDeployed) {
+			if _, ok := noClassContracts[addr]; ok && errors.Is(err, db.ErrKeyNotFound) {
 				contract := newContractDeployed(noClassContractsClassHash, blockNum)
 				newObj := newStateObject(s, &addr, &contract)
 				obj = &newObj

core/state/history_test.go

@@ -92,7 +92,7 @@ func (s *StateReader) ContractStorageLastUpdatedBlock(
 func (s *StateReader) ContractDeployedAt(addr *felt.Felt, blockNum uint64) (bool, error) {
 	contract, err := GetContract(s.db.disk, addr)
 	if err != nil {
-		if errors.Is(err, ErrContractNotDeployed) {
+		if errors.Is(err, db.ErrKeyNotFound) {
 			return false, nil
 		}
 		return false, err
@@ -272,7 +272,17 @@ func (s *StateReader) valueAt(prefix []byte, blockNum uint64, cb func(val []byte
 
 	seekKey := binary.BigEndian.AppendUint64(prefix, blockNum)
 	if !it.Seek(seekKey) {
-		return ErrNoHistoryValue
+		// All existing keys (if any) are before seekKey.
+		// The last stored value is the correct answer for this blockNum.
+		if !it.Prev() {
+			// Iterator is truly empty for this prefix — no history exists.
+			return ErrNoHistoryValue
+		}
+		val, err := it.Value()
+		if err != nil {
+			return err
+		}
+		return cb(val)
 	}
 
 	key := it.Key()

core/state/state.go

@@ -63,7 +63,7 @@ func TestUpdate(t *testing.T) {
 	scValue := felt.NewUnsafeFromString[felt.Felt](
 		"0x10979c6b0b36b03be36739a21cc43a51076545ce6d3397f1b45c7e286474ad5",
 	)
-	scAddr := felt.NewFromUint64[felt.Felt](1)
+	scAddr := &felt.One
 
 	stateUpdates := getStateUpdates(t)
 
@@ -175,7 +175,7 @@ func TestUpdate(t *testing.T) {
 		state, err := New(stateUpdates[4].NewRoot, stateDB, batch)
 		require.NoError(t, err)
 		err = state.Update(&core.Header{Number: block5}, su5, nil, false)
-		require.ErrorIs(t, err, ErrContractNotDeployed)
+		require.ErrorIs(t, err, db.ErrKeyNotFound)
 	})
 }
 
@@ -306,7 +306,9 @@ func TestRevert(t *testing.T) {
 		require.NoError(t, state.Revert(&core.Header{Number: block2}, storageStateUpdate))
 		require.NoError(t, batch.Write())
 
-		storage, sErr := state.ContractStorage(&su1FirstDeployedAddress, replacedVal)
+		reader, err = NewStateReader(storageStateUpdate.OldRoot, stateDB)
+		require.NoError(t, err)
+		storage, sErr := reader.ContractStorage(&su1FirstDeployedAddress, replacedVal)
 		require.NoError(t, sErr)
 		assert.Equal(t, felt.Zero, storage)
 	})