Add 9 bytes of metadata to FlatKV store

sei-db/state_db/bench/wrappers/flatkv_wrapper.go

@@ -61,8 +61,7 @@ func (f *flatKVWrapper) Close() error {
 }
 
 func (f *flatKVWrapper) Read(key []byte) (data []byte, found bool, err error) {
-	data, found = f.base.Get(key)
-	return data, found, nil
+	return f.base.Get(key)
 }
 
 func (f *flatKVWrapper) GetPhaseTimer() *metrics.PhaseTimer {

sei-db/state_db/sc/composite/store_test.go

@@ -26,19 +26,28 @@ func (f *failingEVMStore) LoadVersion(int64, bool) (flatkv.Store, error) {
 }
 func (f *failingEVMStore) ApplyChangeSets([]*proto.NamedChangeSet) error { return nil }
 func (f *failingEVMStore) Commit() (int64, error)                        { return 0, nil }
-func (f *failingEVMStore) Get([]byte) ([]byte, bool)                     { return nil, false }
-func (f *failingEVMStore) Has([]byte) bool                               { return false }
-func (f *failingEVMStore) Iterator(_, _ []byte) flatkv.Iterator          { return nil }
-func (f *failingEVMStore) IteratorByPrefix([]byte) flatkv.Iterator       { return nil }
-func (f *failingEVMStore) RootHash() []byte                              { return nil }
-func (f *failingEVMStore) Version() int64                                { return 0 }
-func (f *failingEVMStore) WriteSnapshot(string) error                    { return nil }
-func (f *failingEVMStore) Rollback(int64) error                          { return nil }
-func (f *failingEVMStore) Exporter(int64) (types.Exporter, error)        { return nil, nil }
-func (f *failingEVMStore) Importer(int64) (types.Importer, error)        { return nil, nil }
-func (f *failingEVMStore) GetPhaseTimer() *metrics.PhaseTimer            { return nil }
-func (f *failingEVMStore) CommittedRootHash() []byte                     { return nil }
-func (f *failingEVMStore) Close() error                                  { return nil }
+func (f *failingEVMStore) Get([]byte) ([]byte, bool, error)              { return nil, false, nil }
+func (f *failingEVMStore) GetBlockHeightModified([]byte) (int64, bool, error) {
+	return -1, false, nil
+}
+func (f *failingEVMStore) Has([]byte) (bool, error)                { return false, nil }
+func (f *failingEVMStore) Iterator(_, _ []byte) flatkv.Iterator    { return nil }
+func (f *failingEVMStore) IteratorByPrefix([]byte) flatkv.Iterator { return nil }
+func (f *failingEVMStore) RootHash() []byte                        { return nil }
+func (f *failingEVMStore) Version() int64                          { return 0 }
+func (f *failingEVMStore) WriteSnapshot(string) error              { return nil }
+func (f *failingEVMStore) Rollback(int64) error                    { return nil }
+func (f *failingEVMStore) Exporter(int64) (types.Exporter, error)  { return nil, nil }
+func (f *failingEVMStore) Importer(int64) (types.Importer, error)  { return nil, nil }
+func (f *failingEVMStore) GetPhaseTimer() *metrics.PhaseTimer      { return nil }
+func (f *failingEVMStore) CommittedRootHash() []byte               { return nil }
+func (f *failingEVMStore) Close() error                            { return nil }
+
+func padLeft32(val ...byte) []byte {
+	var b [32]byte
+	copy(b[32-len(val):], val)
+	return b[:]
+}
 
 func TestCompositeStoreBasicOperations(t *testing.T) {
 	dir := t.TempDir()
@@ -201,7 +210,7 @@ func TestLatticeHashCommitInfo(t *testing.T) {
 				Name: EVMStoreName,
 				Changeset: proto.ChangeSet{
 					Pairs: []*proto.KVPair{
-						{Key: evmStorageKey, Value: []byte{round}},
+						{Key: evmStorageKey, Value: padLeft32(round)},
 					},
 				},
 			},
@@ -509,7 +518,7 @@ func TestExportImportSplitWrite(t *testing.T) {
 	slot := flatkv.Slot{0xBB}
 	storageKey := evm.BuildMemIAVLEVMKey(evm.EVMKeyStorage,
 		flatkv.StorageKey(addr, slot))
-	storageVal := []byte{0x42}
+	storageVal := padLeft32(0x42)
 
 	nonceKey := evm.BuildMemIAVLEVMKey(evm.EVMKeyNonce, addr[:])
 	nonceVal := []byte{0, 0, 0, 0, 0, 0, 0, 10}
@@ -571,11 +580,13 @@ func TestExportImportSplitWrite(t *testing.T) {
 
 	// Verify FlatKV data
 	require.NotNil(t, dst.evmCommitter)
-	got, found := dst.evmCommitter.Get(storageKey)
+	got, found, err := dst.evmCommitter.Get(storageKey)
+	require.NoError(t, err)
 	require.True(t, found, "storage key should exist in FlatKV after import")
 	require.Equal(t, storageVal, got)
 
-	got, found = dst.evmCommitter.Get(nonceKey)
+	got, found, err = dst.evmCommitter.Get(nonceKey)
+	require.NoError(t, err)
 	require.True(t, found, "nonce key should exist in FlatKV after import")
 	require.Equal(t, nonceVal, got)
 }
@@ -699,7 +710,7 @@ func TestReconcileVersionsAfterCrash(t *testing.T) {
 				Name: EVMStoreName,
 				Changeset: proto.ChangeSet{
 					Pairs: []*proto.KVPair{
-						{Key: storageKey, Value: []byte{i}},
+						{Key: storageKey, Value: padLeft32(i)},
 					},
 				},
 			},
@@ -766,7 +777,7 @@ func TestReconcileVersionsThenContinueCommitting(t *testing.T) {
 				{Key: []byte("bal"), Value: []byte{i}},
 			}}},
 			{Name: EVMStoreName, Changeset: proto.ChangeSet{Pairs: []*proto.KVPair{
-				{Key: storageKey, Value: []byte{i}},
+				{Key: storageKey, Value: padLeft32(i)},
 			}}},
 		}))
 		_, err = cs.Commit()
@@ -796,13 +807,13 @@ func TestReconcileVersionsThenContinueCommitting(t *testing.T) {
 	// Continue committing new blocks on top of the reconciled state.
 	// Version 3 is re-created with new data (0xA3 instead of 0x03).
 	for i := byte(0); i < 3; i++ {
-		v := []byte{0xA0 + i + 3}
+		v := 0xA0 + i + 3
 		require.NoError(t, cs2.ApplyChangeSets([]*proto.NamedChangeSet{
 			{Name: "bank", Changeset: proto.ChangeSet{Pairs: []*proto.KVPair{
-				{Key: []byte("bal"), Value: v},
+				{Key: []byte("bal"), Value: []byte{v}},
 			}}},
 			{Name: EVMStoreName, Changeset: proto.ChangeSet{Pairs: []*proto.KVPair{
-				{Key: storageKey, Value: v},
+				{Key: storageKey, Value: padLeft32(v)},
 			}}},
 		}))
 		ver, err := cs2.Commit()
@@ -827,9 +838,10 @@ func TestReconcileVersionsThenContinueCommitting(t *testing.T) {
 	bankStore := cs3.GetChildStoreByName("bank")
 	require.Equal(t, []byte{0xA5}, bankStore.Get([]byte("bal")))
 
-	got, found := cs3.evmCommitter.Get(storageKey)
+	got, found, err := cs3.evmCommitter.Get(storageKey)
+	require.NoError(t, err)
 	require.True(t, found)
-	require.Equal(t, []byte{0xA5}, got)
+	require.Equal(t, padLeft32(0xA5), got)
 }
 
 func TestReconcileVersionsCosmosAheadByMultiple(t *testing.T) {
@@ -860,7 +872,7 @@ func TestReconcileVersionsCosmosAheadByMultiple(t *testing.T) {
 				Name: EVMStoreName,
 				Changeset: proto.ChangeSet{
 					Pairs: []*proto.KVPair{
-						{Key: storageKey, Value: []byte{i}},
+						{Key: storageKey, Value: padLeft32(i)},
 					},
 				},
 			},

sei-db/state_db/sc/flatkv/api.go

@@ -33,11 +33,15 @@ type Store interface {
 	// Commit persists buffered writes and advances the version.
 	Commit() (int64, error)
 
-	// Get returns the value for the x/evm memiavl key, or (nil, false) if not found.
-	Get(key []byte) ([]byte, bool)
+	// Get returns the value for the x/evm memiavl key. If not found, returns (nil, false, nil).
+	Get(key []byte) (value []byte, found bool, err error)
+
+	// GetBlockHeightModified returns the block height at which the key was last modified.
+	// If not found, returns (-1, false, nil).
+	GetBlockHeightModified(key []byte) (int64, bool, error)
 
 	// Has reports whether the x/evm memiavl key exists.
-	Has(key []byte) bool
+	Has(key []byte) (bool, error)
 
 	// Iterator returns an iterator over [start, end) in memiavl key order.
 	// Pass nil for unbounded.

sei-db/state_db/sc/flatkv/config.go

@@ -95,6 +95,10 @@ type Config struct {
 	// Controls the number of goroutines pre-allocated in the thread pool for miscellaneous operations.
 	// The number of threads in this pool is equal to MiscThreadsPerCore * runtime.NumCPU() + MiscConstantThreadCount.
 	MiscConstantThreadCount int
+
+	// If true, FlatKV will return an error if it encounters an unsupported key type. Otherwise,
+	// it will log a warning and continue.
+	StrictKeyTypeCheck bool
 }
 
 // DefaultConfig returns Config with safe default values.
@@ -120,6 +124,7 @@ func DefaultConfig() *Config {
 		ReaderPoolQueueSize:       1024,
 		MiscPoolThreadsPerCore:    4.0,
 		MiscConstantThreadCount:   0,
+		StrictKeyTypeCheck:        true,
 	}
 
 	cfg.AccountCacheConfig.MaxSize = unit.GB

sei-db/state_db/sc/flatkv/crash_recovery_test.go

@@ -94,7 +94,7 @@ func TestCrashRecoveryGlobalMetadataAheadOfDataDBs(t *testing.T) {
 	addr := addrN(0x02)
 	for i := 1; i <= 5; i++ {
 		key := evm.BuildMemIAVLEVMKey(evm.EVMKeyStorage, StorageKey(addr, slotN(byte(i))))
-		cs := makeChangeSet(key, []byte{byte(i * 11)}, false)
+		cs := makeChangeSet(key, padLeft32(byte(i*11)), false)
 		require.NoError(t, s.ApplyChangeSets([]*proto.NamedChangeSet{cs}))
 		_, err := s.Commit()
 		require.NoError(t, err)
@@ -122,9 +122,10 @@ func TestCrashRecoveryGlobalMetadataAheadOfDataDBs(t *testing.T) {
 
 	for i := 1; i <= 5; i++ {
 		key := evm.BuildMemIAVLEVMKey(evm.EVMKeyStorage, StorageKey(addr, slotN(byte(i))))
-		val, found := s2.Get(key)
+		val, found, err := s2.Get(key)
+		require.NoError(t, err)
 		require.True(t, found, "slot %d should exist after recovery", i)
-		require.Equal(t, []byte{byte(i * 11)}, val)
+		require.Equal(t, padLeft32(byte(i*11)), val)
 	}
 }
 
@@ -142,7 +143,7 @@ func TestCrashRecoveryWALReplayLargeGap(t *testing.T) {
 	addr := addrN(0x03)
 	for i := 1; i <= 20; i++ {
 		key := evm.BuildMemIAVLEVMKey(evm.EVMKeyStorage, StorageKey(addr, slotN(byte(i))))
-		cs := makeChangeSet(key, []byte{byte(i)}, false)
+		cs := makeChangeSet(key, padLeft32(byte(i)), false)
 		require.NoError(t, s.ApplyChangeSets([]*proto.NamedChangeSet{cs}))
 		_, err := s.Commit()
 		require.NoError(t, err)
@@ -164,9 +165,10 @@ func TestCrashRecoveryWALReplayLargeGap(t *testing.T) {
 	// All 20 storage slots should be readable.
 	for i := 1; i <= 20; i++ {
 		key := evm.BuildMemIAVLEVMKey(evm.EVMKeyStorage, StorageKey(addr, slotN(byte(i))))
-		val, found := s2.Get(key)
+		val, found, err := s2.Get(key)
+		require.NoError(t, err)
 		require.True(t, found, "slot %d should exist", i)
-		require.Equal(t, []byte{byte(i)}, val)
+		require.Equal(t, padLeft32(byte(i)), val)
 	}
 }
 
@@ -182,7 +184,7 @@ func TestCrashRecoveryEmptyWALAfterSnapshot(t *testing.T) {
 
 	addr := addrN(0x04)
 	key := evm.BuildMemIAVLEVMKey(evm.EVMKeyStorage, StorageKey(addr, slotN(0x01)))
-	cs := makeChangeSet(key, []byte{0xAA}, false)
+	cs := makeChangeSet(key, padLeft32(0xAA), false)
 	require.NoError(t, s.ApplyChangeSets([]*proto.NamedChangeSet{cs}))
 	_, err = s.Commit()
 	require.NoError(t, err)
@@ -205,12 +207,13 @@ func TestCrashRecoveryEmptyWALAfterSnapshot(t *testing.T) {
 	require.Equal(t, expectedVersion, s2.Version())
 	require.Equal(t, expectedHash, s2.RootHash())
 
-	val, found := s2.Get(key)
+	val, found, err := s2.Get(key)
+	require.NoError(t, err)
 	require.True(t, found)
-	require.Equal(t, []byte{0xAA}, val)
+	require.Equal(t, padLeft32(0xAA), val)
 
 	// Can continue committing after recovery from snapshot-only state.
-	cs2 := makeChangeSet(key, []byte{0xBB}, false)
+	cs2 := makeChangeSet(key, padLeft32(0xBB), false)
 	require.NoError(t, s2.ApplyChangeSets([]*proto.NamedChangeSet{cs2}))
 	v, err := s2.Commit()
 	require.NoError(t, err)
@@ -248,7 +251,7 @@ func TestCrashRecoveryCorruptedAccountValueInDB(t *testing.T) {
 	}
 	err = s.ApplyChangeSets([]*proto.NamedChangeSet{cs2})
 	require.Error(t, err, "should fail on corrupted AccountValue")
-	require.Contains(t, err.Error(), "corrupted AccountValue")
+	require.Contains(t, err.Error(), "unsupported serialization version")
 }
 
 func TestCrashRecoveryCrashAfterWALBeforeDBCommit(t *testing.T) {
@@ -265,14 +268,14 @@ func TestCrashRecoveryCrashAfterWALBeforeDBCommit(t *testing.T) {
 	addr := addrN(0x06)
 	slot := slotN(0x01)
 	key := evm.BuildMemIAVLEVMKey(evm.EVMKeyStorage, StorageKey(addr, slot))
-	cs := makeChangeSet(key, []byte{0x11}, false)
+	cs := makeChangeSet(key, padLeft32(0x11), false)
 	require.NoError(t, s.ApplyChangeSets([]*proto.NamedChangeSet{cs}))
 	_, err = s.Commit()
 	require.NoError(t, err)
 	hashAfterV1 := s.RootHash()
 
 	// Now simulate writing v2 to WAL but "crashing" before DB commit.
-	cs2 := makeChangeSet(key, []byte{0x22}, false)
+	cs2 := makeChangeSet(key, padLeft32(0x22), false)
 	require.NoError(t, s.ApplyChangeSets([]*proto.NamedChangeSet{cs2}))
 
 	// Write v2 to WAL manually (like Commit step 1).
@@ -298,9 +301,10 @@ func TestCrashRecoveryCrashAfterWALBeforeDBCommit(t *testing.T) {
 	require.Equal(t, int64(2), s2.Version())
 	require.NotEqual(t, hashAfterV1, s2.RootHash(), "hash should differ after v2 replay")
 
-	val, found := s2.Get(key)
+	val, found, err := s2.Get(key)
+	require.NoError(t, err)
 	require.True(t, found)
-	require.Equal(t, []byte{0x22}, val, "v2 value should be present after catchup")
+	require.Equal(t, padLeft32(0x22), val, "v2 value should be present after catchup")
 	verifyLtHashConsistency(t, s2)
 }
 
@@ -321,7 +325,7 @@ func TestCrashRecoveryLtHashConsistencyAfterAllPaths(t *testing.T) {
 			noncePair(addr, uint64(i)),
 			{
 				Key:   evm.BuildMemIAVLEVMKey(evm.EVMKeyStorage, StorageKey(addr, slotN(byte(i)))),
-				Value: []byte{byte(i)},
+				Value: padLeft32(byte(i)),
 			},
 		}
 		cs := &proto.NamedChangeSet{
@@ -381,7 +385,7 @@ func TestCrashRecoveryCorruptLtHashBlobInMetadata(t *testing.T) {
 
 	cs := makeChangeSet(
 		evm.BuildMemIAVLEVMKey(evm.EVMKeyStorage, StorageKey(addrN(0x01), slotN(0x01))),
-		[]byte{0x11}, false,
+		padLeft32(0x11), false,
 	)
 	require.NoError(t, s.ApplyChangeSets([]*proto.NamedChangeSet{cs}))
 	_, err = s.Commit()
@@ -416,7 +420,7 @@ func TestCrashRecoveryCorruptLtHashBlobInPerDBMeta(t *testing.T) {
 
 	cs := makeChangeSet(
 		evm.BuildMemIAVLEVMKey(evm.EVMKeyStorage, StorageKey(addrN(0x02), slotN(0x01))),
-		[]byte{0x22}, false,
+		padLeft32(0x22), false,
 	)
 	require.NoError(t, s.ApplyChangeSets([]*proto.NamedChangeSet{cs}))
 	_, err = s.Commit()
@@ -451,7 +455,7 @@ func TestCrashRecoveryGlobalVersionOverflow(t *testing.T) {
 
 	cs := makeChangeSet(
 		evm.BuildMemIAVLEVMKey(evm.EVMKeyStorage, StorageKey(addrN(0x03), slotN(0x01))),
-		[]byte{0x33}, false,
+		padLeft32(0x33), false,
 	)
 	require.NoError(t, s.ApplyChangeSets([]*proto.NamedChangeSet{cs}))
 	_, err = s.Commit()