Roy Crihfield
761d60acdf
The Geth `core/state` and `trie` packages underwent a big refactor between `v1.11.6` and `1.13.14`. This code, which was adapted from those, needed corresponding updates. To do this I applied the diff patches from Geth directly where possible and in some places had to clone new parts of the Geth code and adapt them. In order to make this process as straightforward as possible in the future, I've attempted to minimize the number of changes vs. Geth and added some documentation in the `trie_by_cid` package. Reviewed-on: #5
335 lines
9.8 KiB
Go
335 lines
9.8 KiB
Go
// Copyright 2022 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>
|
|
|
|
package pathdb
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/cerc-io/ipld-eth-statedb/trie_by_cid/trie/testutil"
|
|
"github.com/cerc-io/ipld-eth-statedb/trie_by_cid/trie/triestate"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
)
|
|
|
|
// randomStateSet generates a random state change set.
|
|
func randomStateSet(n int) *triestate.Set {
|
|
var (
|
|
accounts = make(map[common.Address][]byte)
|
|
storages = make(map[common.Address]map[common.Hash][]byte)
|
|
)
|
|
for i := 0; i < n; i++ {
|
|
addr := testutil.RandomAddress()
|
|
storages[addr] = make(map[common.Hash][]byte)
|
|
for j := 0; j < 3; j++ {
|
|
v, _ := rlp.EncodeToBytes(common.TrimLeftZeroes(testutil.RandBytes(32)))
|
|
storages[addr][testutil.RandomHash()] = v
|
|
}
|
|
account := generateAccount(types.EmptyRootHash)
|
|
accounts[addr] = types.SlimAccountRLP(account)
|
|
}
|
|
return triestate.New(accounts, storages, nil)
|
|
}
|
|
|
|
func makeHistory() *history {
|
|
return newHistory(testutil.RandomHash(), types.EmptyRootHash, 0, randomStateSet(3))
|
|
}
|
|
|
|
func makeHistories(n int) []*history {
|
|
var (
|
|
parent = types.EmptyRootHash
|
|
result []*history
|
|
)
|
|
for i := 0; i < n; i++ {
|
|
root := testutil.RandomHash()
|
|
h := newHistory(root, parent, uint64(i), randomStateSet(3))
|
|
parent = root
|
|
result = append(result, h)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func TestEncodeDecodeHistory(t *testing.T) {
|
|
var (
|
|
m meta
|
|
dec history
|
|
obj = makeHistory()
|
|
)
|
|
// check if meta data can be correctly encode/decode
|
|
blob := obj.meta.encode()
|
|
if err := m.decode(blob); err != nil {
|
|
t.Fatalf("Failed to decode %v", err)
|
|
}
|
|
if !reflect.DeepEqual(&m, obj.meta) {
|
|
t.Fatal("meta is mismatched")
|
|
}
|
|
|
|
// check if account/storage data can be correctly encode/decode
|
|
accountData, storageData, accountIndexes, storageIndexes := obj.encode()
|
|
if err := dec.decode(accountData, storageData, accountIndexes, storageIndexes); err != nil {
|
|
t.Fatalf("Failed to decode, err: %v", err)
|
|
}
|
|
if !compareSet(dec.accounts, obj.accounts) {
|
|
t.Fatal("account data is mismatched")
|
|
}
|
|
if !compareStorages(dec.storages, obj.storages) {
|
|
t.Fatal("storage data is mismatched")
|
|
}
|
|
if !compareList(dec.accountList, obj.accountList) {
|
|
t.Fatal("account list is mismatched")
|
|
}
|
|
if !compareStorageList(dec.storageList, obj.storageList) {
|
|
t.Fatal("storage list is mismatched")
|
|
}
|
|
}
|
|
|
|
func checkHistory(t *testing.T, db ethdb.KeyValueReader, freezer *rawdb.ResettableFreezer, id uint64, root common.Hash, exist bool) {
|
|
blob := rawdb.ReadStateHistoryMeta(freezer, id)
|
|
if exist && len(blob) == 0 {
|
|
t.Fatalf("Failed to load trie history, %d", id)
|
|
}
|
|
if !exist && len(blob) != 0 {
|
|
t.Fatalf("Unexpected trie history, %d", id)
|
|
}
|
|
if exist && rawdb.ReadStateID(db, root) == nil {
|
|
t.Fatalf("Root->ID mapping is not found, %d", id)
|
|
}
|
|
if !exist && rawdb.ReadStateID(db, root) != nil {
|
|
t.Fatalf("Unexpected root->ID mapping, %d", id)
|
|
}
|
|
}
|
|
|
|
func checkHistoriesInRange(t *testing.T, db ethdb.KeyValueReader, freezer *rawdb.ResettableFreezer, from, to uint64, roots []common.Hash, exist bool) {
|
|
for i, j := from, 0; i <= to; i, j = i+1, j+1 {
|
|
checkHistory(t, db, freezer, i, roots[j], exist)
|
|
}
|
|
}
|
|
|
|
func TestTruncateHeadHistory(t *testing.T) {
|
|
var (
|
|
roots []common.Hash
|
|
hs = makeHistories(10)
|
|
db = rawdb.NewMemoryDatabase()
|
|
freezer, _ = openFreezer(t.TempDir(), false)
|
|
)
|
|
defer freezer.Close()
|
|
|
|
for i := 0; i < len(hs); i++ {
|
|
accountData, storageData, accountIndex, storageIndex := hs[i].encode()
|
|
rawdb.WriteStateHistory(freezer, uint64(i+1), hs[i].meta.encode(), accountIndex, storageIndex, accountData, storageData)
|
|
rawdb.WriteStateID(db, hs[i].meta.root, uint64(i+1))
|
|
roots = append(roots, hs[i].meta.root)
|
|
}
|
|
for size := len(hs); size > 0; size-- {
|
|
pruned, err := truncateFromHead(db, freezer, uint64(size-1))
|
|
if err != nil {
|
|
t.Fatalf("Failed to truncate from head %v", err)
|
|
}
|
|
if pruned != 1 {
|
|
t.Error("Unexpected pruned items", "want", 1, "got", pruned)
|
|
}
|
|
checkHistoriesInRange(t, db, freezer, uint64(size), uint64(10), roots[size-1:], false)
|
|
checkHistoriesInRange(t, db, freezer, uint64(1), uint64(size-1), roots[:size-1], true)
|
|
}
|
|
}
|
|
|
|
func TestTruncateTailHistory(t *testing.T) {
|
|
var (
|
|
roots []common.Hash
|
|
hs = makeHistories(10)
|
|
db = rawdb.NewMemoryDatabase()
|
|
freezer, _ = openFreezer(t.TempDir(), false)
|
|
)
|
|
defer freezer.Close()
|
|
|
|
for i := 0; i < len(hs); i++ {
|
|
accountData, storageData, accountIndex, storageIndex := hs[i].encode()
|
|
rawdb.WriteStateHistory(freezer, uint64(i+1), hs[i].meta.encode(), accountIndex, storageIndex, accountData, storageData)
|
|
rawdb.WriteStateID(db, hs[i].meta.root, uint64(i+1))
|
|
roots = append(roots, hs[i].meta.root)
|
|
}
|
|
for newTail := 1; newTail < len(hs); newTail++ {
|
|
pruned, _ := truncateFromTail(db, freezer, uint64(newTail))
|
|
if pruned != 1 {
|
|
t.Error("Unexpected pruned items", "want", 1, "got", pruned)
|
|
}
|
|
checkHistoriesInRange(t, db, freezer, uint64(1), uint64(newTail), roots[:newTail], false)
|
|
checkHistoriesInRange(t, db, freezer, uint64(newTail+1), uint64(10), roots[newTail:], true)
|
|
}
|
|
}
|
|
|
|
func TestTruncateTailHistories(t *testing.T) {
|
|
var cases = []struct {
|
|
limit uint64
|
|
expPruned int
|
|
maxPruned uint64
|
|
minUnpruned uint64
|
|
empty bool
|
|
}{
|
|
{
|
|
1, 9, 9, 10, false,
|
|
},
|
|
{
|
|
0, 10, 10, 0 /* no meaning */, true,
|
|
},
|
|
{
|
|
10, 0, 0, 1, false,
|
|
},
|
|
}
|
|
for i, c := range cases {
|
|
var (
|
|
roots []common.Hash
|
|
hs = makeHistories(10)
|
|
db = rawdb.NewMemoryDatabase()
|
|
freezer, _ = openFreezer(t.TempDir()+fmt.Sprintf("%d", i), false)
|
|
)
|
|
defer freezer.Close()
|
|
|
|
for i := 0; i < len(hs); i++ {
|
|
accountData, storageData, accountIndex, storageIndex := hs[i].encode()
|
|
rawdb.WriteStateHistory(freezer, uint64(i+1), hs[i].meta.encode(), accountIndex, storageIndex, accountData, storageData)
|
|
rawdb.WriteStateID(db, hs[i].meta.root, uint64(i+1))
|
|
roots = append(roots, hs[i].meta.root)
|
|
}
|
|
pruned, _ := truncateFromTail(db, freezer, uint64(10)-c.limit)
|
|
if pruned != c.expPruned {
|
|
t.Error("Unexpected pruned items", "want", c.expPruned, "got", pruned)
|
|
}
|
|
if c.empty {
|
|
checkHistoriesInRange(t, db, freezer, uint64(1), uint64(10), roots, false)
|
|
} else {
|
|
tail := 10 - int(c.limit)
|
|
checkHistoriesInRange(t, db, freezer, uint64(1), c.maxPruned, roots[:tail], false)
|
|
checkHistoriesInRange(t, db, freezer, c.minUnpruned, uint64(10), roots[tail:], true)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTruncateOutOfRange(t *testing.T) {
|
|
var (
|
|
hs = makeHistories(10)
|
|
db = rawdb.NewMemoryDatabase()
|
|
freezer, _ = openFreezer(t.TempDir(), false)
|
|
)
|
|
defer freezer.Close()
|
|
|
|
for i := 0; i < len(hs); i++ {
|
|
accountData, storageData, accountIndex, storageIndex := hs[i].encode()
|
|
rawdb.WriteStateHistory(freezer, uint64(i+1), hs[i].meta.encode(), accountIndex, storageIndex, accountData, storageData)
|
|
rawdb.WriteStateID(db, hs[i].meta.root, uint64(i+1))
|
|
}
|
|
truncateFromTail(db, freezer, uint64(len(hs)/2))
|
|
|
|
// Ensure of-out-range truncations are rejected correctly.
|
|
head, _ := freezer.Ancients()
|
|
tail, _ := freezer.Tail()
|
|
|
|
cases := []struct {
|
|
mode int
|
|
target uint64
|
|
expErr error
|
|
}{
|
|
{0, head, nil}, // nothing to delete
|
|
{0, head + 1, fmt.Errorf("out of range, tail: %d, head: %d, target: %d", tail, head, head+1)},
|
|
{0, tail - 1, fmt.Errorf("out of range, tail: %d, head: %d, target: %d", tail, head, tail-1)},
|
|
{1, tail, nil}, // nothing to delete
|
|
{1, head + 1, fmt.Errorf("out of range, tail: %d, head: %d, target: %d", tail, head, head+1)},
|
|
{1, tail - 1, fmt.Errorf("out of range, tail: %d, head: %d, target: %d", tail, head, tail-1)},
|
|
}
|
|
for _, c := range cases {
|
|
var gotErr error
|
|
if c.mode == 0 {
|
|
_, gotErr = truncateFromHead(db, freezer, c.target)
|
|
} else {
|
|
_, gotErr = truncateFromTail(db, freezer, c.target)
|
|
}
|
|
if !reflect.DeepEqual(gotErr, c.expErr) {
|
|
t.Errorf("Unexpected error, want: %v, got: %v", c.expErr, gotErr)
|
|
}
|
|
}
|
|
}
|
|
|
|
// openFreezer initializes the freezer instance for storing state histories.
|
|
func openFreezer(datadir string, readOnly bool) (*rawdb.ResettableFreezer, error) {
|
|
return rawdb.NewStateFreezer(datadir, readOnly)
|
|
}
|
|
|
|
func compareSet[k comparable](a, b map[k][]byte) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
for key, valA := range a {
|
|
valB, ok := b[key]
|
|
if !ok {
|
|
return false
|
|
}
|
|
if !bytes.Equal(valA, valB) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func compareList[k comparable](a, b []k) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
for i := 0; i < len(a); i++ {
|
|
if a[i] != b[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func compareStorages(a, b map[common.Address]map[common.Hash][]byte) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
for h, subA := range a {
|
|
subB, ok := b[h]
|
|
if !ok {
|
|
return false
|
|
}
|
|
if !compareSet(subA, subB) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func compareStorageList(a, b map[common.Address][]common.Hash) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
for h, la := range a {
|
|
lb, ok := b[h]
|
|
if !ok {
|
|
return false
|
|
}
|
|
if !compareList(la, lb) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|