feat(state): new state package + state clean cache

core/class.go

@@ -1,13 +1,16 @@
 package core
 
 import (
+	"encoding/binary"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"math/big"
 	"strconv"
 
 	"github.com/NethermindEth/juno/core/crypto"
 	"github.com/NethermindEth/juno/core/felt"
+	"github.com/NethermindEth/juno/encoder"
 	"github.com/consensys/gnark-crypto/ecc/stark-curve/fp"
 )
 
@@ -16,6 +19,8 @@
 	_ Class = (*Cairo1Class)(nil)
 )
 
+const minDeclaredClassSize = 8
+
 // Single felt identifying the number "0.1.0" as a short string
 var SierraVersion010 felt.Felt = felt.New(
 	fp.Element([4]uint64{
@@ -255,3 +260,31 @@
 
 	return nil
 }
+
+type DeclaredClass struct {
+	At    uint64 // block number at which the class was declared
+	Class Class
+}
+
+func (d *DeclaredClass) MarshalBinary() ([]byte, error) {
+	classEnc, err := encoder.Marshal(d.Class)
+	if err != nil {
+		return nil, err
+	}
+
+	size := 8 + len(classEnc)
+	buf := make([]byte, size)
+	binary.BigEndian.PutUint64(buf[:8], d.At)
+	copy(buf[8:], classEnc)
+
+	return buf, nil
+}
+
+func (d *DeclaredClass) UnmarshalBinary(data []byte) error {
+	if len(data) < minDeclaredClassSize {
+		return errors.New("data too short to unmarshal DeclaredClass")
+	}
+
+	d.At = binary.BigEndian.Uint64(data[:8])
+	return encoder.Unmarshal(data[8:], &d.Class)
+}

core/contract_test.go

@@ -1,20 +1,12 @@
-package core_test
+package core
 
 import (
 	"testing"
 
-	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
-	"github.com/NethermindEth/juno/db/memory"
 	"github.com/NethermindEth/juno/utils"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
-var NoopOnValueChanged = func(location, oldValue *felt.Felt) error {
-	return nil
-}
-
 func TestContractAddress(t *testing.T) {
 	tests := []struct {
 		callerAddress       *felt.Felt
@@ -43,118 +35,10 @@ func TestContractAddress(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run("Address", func(t *testing.T) {
-			address := core.ContractAddress(tt.callerAddress, tt.classHash, tt.salt, tt.constructorCallData)
+			address := ContractAddress(tt.callerAddress, tt.classHash, tt.salt, tt.constructorCallData)
 			if !address.Equal(tt.want) {
 				t.Errorf("wrong address: got %s, want %s", address.String(), tt.want.String())
 			}
 		})
 	}
 }
-
-func TestNewContract(t *testing.T) {
-	testDB := memory.New()
-	txn := testDB.NewIndexedBatch()
-	addr := new(felt.Felt).SetUint64(234)
-	classHash := new(felt.Felt).SetBytes([]byte("class hash"))
-
-	t.Run("cannot create Contract instance if un-deployed", func(t *testing.T) {
-		_, err := core.NewContractUpdater(addr, txn)
-		require.EqualError(t, err, core.ErrContractNotDeployed.Error())
-	})
-
-	_, err := core.DeployContract(addr, classHash, txn)
-	require.NoError(t, err)
-
-	t.Run("redeploy should fail", func(t *testing.T) {
-		_, err := core.DeployContract(addr, classHash, txn)
-		require.EqualError(t, err, core.ErrContractAlreadyDeployed.Error())
-	})
-}
-
-func TestNonceAndClassHash(t *testing.T) {
-	testDB := memory.New()
-	txn := testDB.NewIndexedBatch()
-	addr := new(felt.Felt).SetUint64(44)
-	classHash := new(felt.Felt).SetUint64(37)
-
-	contract, err := core.DeployContract(addr, classHash, txn)
-	require.NoError(t, err)
-
-	t.Run("initial nonce should be 0", func(t *testing.T) {
-		got, err := core.ContractNonce(addr, txn)
-		require.NoError(t, err)
-		assert.Equal(t, new(felt.Felt), got)
-	})
-	t.Run("UpdateNonce()", func(t *testing.T) {
-		require.NoError(t, contract.UpdateNonce(classHash))
-
-		got, err := core.ContractNonce(addr, txn)
-		require.NoError(t, err)
-		assert.Equal(t, classHash, got)
-	})
-
-	t.Run("ClassHash()", func(t *testing.T) {
-		got, err := core.ContractClassHash(addr, txn)
-		require.NoError(t, err)
-		assert.Equal(t, classHash, got)
-	})
-
-	t.Run("Replace()", func(t *testing.T) {
-		replaceWith := utils.HexToFelt(t, "0xDEADBEEF")
-		require.NoError(t, contract.Replace(replaceWith))
-		got, err := core.ContractClassHash(addr, txn)
-		require.NoError(t, err)
-		assert.Equal(t, replaceWith, got)
-	})
-}
-
-func TestUpdateStorage(t *testing.T) {
-	testDB := memory.New()
-	txn := testDB.NewIndexedBatch()
-	addr := new(felt.Felt).SetUint64(44)
-	classHash := new(felt.Felt).SetUint64(37)
-
-	contract, err := core.DeployContract(addr, classHash, txn)
-	require.NoError(t, err)
-
-	t.Run("apply storage diff", func(t *testing.T) {
-		oldRoot, err := core.ContractRoot(addr, txn)
-		require.NoError(t, err)
-
-		require.NoError(t, contract.UpdateStorage(map[felt.Felt]*felt.Felt{*addr: classHash}, NoopOnValueChanged))
-
-		gotValue, err := core.ContractStorage(addr, addr, txn)
-		require.NoError(t, err)
-		assert.Equal(t, classHash, gotValue)
-
-		newRoot, err := core.ContractRoot(addr, txn)
-		require.NoError(t, err)
-		assert.NotEqual(t, oldRoot, newRoot)
-	})
-
-	t.Run("delete key from storage with storage diff", func(t *testing.T) {
-		require.NoError(t, contract.UpdateStorage(map[felt.Felt]*felt.Felt{*addr: new(felt.Felt)}, NoopOnValueChanged))
-
-		val, err := core.ContractStorage(addr, addr, txn)
-		require.NoError(t, err)
-		require.Equal(t, &felt.Zero, val)
-
-		sRoot, err := core.ContractRoot(addr, txn)
-		require.NoError(t, err)
-		assert.Equal(t, new(felt.Felt), sRoot)
-	})
-}
-
-func TestPurge(t *testing.T) {
-	testDB := memory.New()
-	txn := testDB.NewIndexedBatch()
-	addr := new(felt.Felt).SetUint64(44)
-	classHash := new(felt.Felt).SetUint64(37)
-
-	contract, err := core.DeployContract(addr, classHash, txn)
-	require.NoError(t, err)
-
-	require.NoError(t, contract.Purge())
-	_, err = core.NewContractUpdater(addr, txn)
-	assert.ErrorIs(t, err, core.ErrContractNotDeployed)
-}

core/state.go

@@ -343,11 +343,6 @@ func (s *State) replaceContract(stateTrie *trie.Trie, addr, classHash *felt.Felt
 	return oldClassHash, nil
 }
 
-type DeclaredClass struct {
-	At    uint64
-	Class Class
-}
-
 func (s *State) putClass(classHash *felt.Felt, class Class, declaredAt uint64) error {
 	classKey := db.ClassKey(classHash)
 

core/state/accessors.go

@@ -0,0 +1,133 @@
+package state
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/NethermindEth/juno/core"
+	"github.com/NethermindEth/juno/core/felt"
+	"github.com/NethermindEth/juno/db"
+)
+
+func GetStateObject(r db.KeyValueReader, state *State, addr *felt.Felt) (*stateObject, error) {
+	contract, err := GetContract(r, addr)
+	if err != nil {
+		return nil, err
+	}
+
+	return newStateObject(state, addr, &contract), nil
+}
+
+// Wrapper around getContract which checks if a contract is deployed
+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) {
+	key := db.ContractKey(addr)
+	var contract stateContract
+	if err := r.Get(key, func(val []byte) error {
+		if err := contract.UnmarshalBinary(val); err != nil {
+			return fmt.Errorf("failed to unmarshal contract: %w", err)
+		}
+		return nil
+	}); err != nil {
+		return stateContract{}, err
+	}
+	return contract, nil
+}
+
+func HasContract(r db.KeyValueReader, addr *felt.Felt) (bool, error) {
+	key := db.ContractKey(addr)
+	return r.Has(key)
+}
+
+func WriteContract(w db.KeyValueWriter, addr *felt.Felt, contract *stateContract) error {
+	key := db.ContractKey(addr)
+	data, err := contract.MarshalBinary()
+	if err != nil {
+		return err
+	}
+
+	return w.Put(key, data)
+}
+
+func DeleteContract(w db.KeyValueWriter, addr *felt.Felt) error {
+	key := db.ContractKey(addr)
+	return w.Delete(key)
+}
+
+func WriteNonceHistory(w db.KeyValueWriter, addr *felt.Felt, blockNum uint64, nonce *felt.Felt) error {
+	key := db.ContractHistoryNonceKey(addr, blockNum)
+	return w.Put(key, nonce.Marshal())
+}
+
+func WriteClassHashHistory(w db.KeyValueWriter, addr *felt.Felt, blockNum uint64, classHash *felt.Felt) error {
+	key := db.ContractHistoryClassHashKey(addr, blockNum)
+	return w.Put(key, classHash.Marshal())
+}
+
+func WriteStorageHistory(w db.KeyValueWriter, addr, key *felt.Felt, blockNum uint64, value *felt.Felt) error {
+	dbKey := db.ContractHistoryStorageKey(addr, key, blockNum)
+	return w.Put(dbKey, value.Marshal())
+}
+
+func DeleteStorageHistory(w db.KeyValueWriter, addr, key *felt.Felt, blockNum uint64) error {
+	dbKey := db.ContractHistoryStorageKey(addr, key, blockNum)
+	return w.Delete(dbKey)
+}
+
+func DeleteNonceHistory(w db.KeyValueWriter, addr *felt.Felt, blockNum uint64) error {
+	dbKey := db.ContractHistoryNonceKey(addr, blockNum)
+	return w.Delete(dbKey)
+}
+
+func DeleteClassHashHistory(w db.KeyValueWriter, addr *felt.Felt, blockNum uint64) error {
+	dbKey := db.ContractHistoryClassHashKey(addr, blockNum)
+	return w.Delete(dbKey)
+}
+
+func WriteClass(w db.KeyValueWriter, classHash *felt.Felt, class core.Class, declaredAt uint64) error {
+	key := db.ClassKey(classHash)
+
+	dc := core.DeclaredClass{
+		At:    declaredAt,
+		Class: class,
+	}
+	enc, err := dc.MarshalBinary()
+	if err != nil {
+		return err
+	}
+
+	return w.Put(key, enc)
+}
+
+func DeleteClass(w db.KeyValueWriter, classHash *felt.Felt) error {
+	key := db.ClassKey(classHash)
+	return w.Delete(key)
+}
+
+func GetClass(r db.KeyValueReader, classHash *felt.Felt) (*core.DeclaredClass, error) {
+	key := db.ClassKey(classHash)
+
+	var class core.DeclaredClass
+	if err := r.Get(key, class.UnmarshalBinary); err != nil {
+		return nil, err
+	}
+
+	return &class, nil
+}
+
+func HasClass(r db.KeyValueReader, classHash *felt.Felt) (bool, error) {
+	key := db.ClassKey(classHash)
+	return r.Has(key)
+}