mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-06-23 15:14:32 +00:00
nomt: Phase E — NomtTrie integration rewrite with full EIP-7864 ops
Complete implementation of all NomtTrie methods: Read operations (from stem flat state): - GetAccount: reads basic data (slot 0) and code hash (slot 1) - GetStorage: reads packed 32-byte value by stem+suffix Write operations (accumulate pending stemUpdates): - UpdateAccount: packs basic data + code hash at account stem - UpdateStorage: right-aligns value to 32 bytes - DeleteStorage: writes 32 zero bytes (matching bintrie) - DeleteAccount: no-op (matching bintrie) - UpdateContractCode: ChunkifyCode + per-chunk stem updates Flush (Hash/Commit): - groupAndHashStems merges updates with flat state, writes back - nomtDB.Update pushes stem hashes into the page tree - Returns new root hash 15 new integration tests, all passing with -race. Full suite: 38 nomttrie + 94 core + 34 merkle + 9 db + 31 bitbox = all green. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
weiihann
parent
fbeb697099
commit
556d6160df
2 changed files with 502 additions and 32 deletions
|
|
@ -1,26 +1,33 @@
|
|||
// Package nomttrie implements a state.Trie backed by the NOMT binary merkle
|
||||
// trie engine, targeting EIP-7864 compatibility.
|
||||
//
|
||||
// Read operations delegate to geth's ethdb flat state. Write operations
|
||||
// accumulate stem updates and flush them to the NOMT page tree on Hash()/Commit().
|
||||
// Read operations delegate to geth's ethdb flat state (stem value keys).
|
||||
// Write operations accumulate stem updates and flush them to flat state + the
|
||||
// NOMT page tree on Hash()/Commit().
|
||||
package nomttrie
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/ethereum/go-ethereum/core/types"
|
||||
"github.com/ethereum/go-ethereum/ethdb"
|
||||
"github.com/ethereum/go-ethereum/log"
|
||||
"github.com/ethereum/go-ethereum/nomt/core"
|
||||
"github.com/ethereum/go-ethereum/nomt/db"
|
||||
"github.com/ethereum/go-ethereum/trie"
|
||||
"github.com/ethereum/go-ethereum/trie/bintrie"
|
||||
"github.com/ethereum/go-ethereum/trie/trienode"
|
||||
"github.com/ethereum/go-ethereum/triedb/nomtdb"
|
||||
"github.com/holiman/uint256"
|
||||
)
|
||||
|
||||
// stemUpdate represents a pending value change at a specific (stem, suffix)
|
||||
// position in the EIP-7864 trie.
|
||||
type stemUpdate struct {
|
||||
Stem [31]byte // stem path
|
||||
Suffix byte // value slot index (0-255)
|
||||
Value []byte // 32-byte value, nil = delete
|
||||
Stem core.StemPath // 31-byte stem path
|
||||
Suffix byte // value slot index (0-255)
|
||||
Value []byte // 32-byte value, nil = delete
|
||||
}
|
||||
|
||||
// NomtTrie implements the state.Trie interface using NOMT's page-based binary
|
||||
|
|
@ -49,61 +56,169 @@ func (t *NomtTrie) GetKey(key []byte) []byte {
|
|||
return key
|
||||
}
|
||||
|
||||
// GetAccount reads an account from flat state storage.
|
||||
// TODO(Phase E): implement using EIP-7864 key encoding.
|
||||
func (t *NomtTrie) GetAccount(_ common.Address) (*types.StateAccount, error) {
|
||||
return nil, nil
|
||||
// GetAccount reads an account from flat state using EIP-7864 stem keys.
|
||||
// Reads basic data (slot 0) and code hash (slot 1) from the account stem.
|
||||
func (t *NomtTrie) GetAccount(addr common.Address) (*types.StateAccount, error) {
|
||||
stem := accountStem(addr)
|
||||
diskdb := t.backend.DiskDB()
|
||||
|
||||
basicData, err := diskdb.Get(stemValueDBKey(stem, bintrie.BasicDataLeafKey))
|
||||
if err != nil {
|
||||
basicData = nil
|
||||
}
|
||||
codeHash, err := diskdb.Get(stemValueDBKey(stem, bintrie.CodeHashLeafKey))
|
||||
if err != nil {
|
||||
codeHash = nil
|
||||
}
|
||||
|
||||
if basicData == nil && codeHash == nil {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
acc := &types.StateAccount{
|
||||
Balance: new(uint256.Int),
|
||||
}
|
||||
|
||||
// Unpack basic data: nonce at [8:16], balance at [16:32].
|
||||
if len(basicData) >= bintrie.HashSize {
|
||||
acc.Nonce = binary.BigEndian.Uint64(
|
||||
basicData[bintrie.BasicDataNonceOffset:],
|
||||
)
|
||||
var balance [16]byte
|
||||
copy(balance[:], basicData[bintrie.BasicDataBalanceOffset:])
|
||||
acc.Balance = new(uint256.Int).SetBytes(balance[:])
|
||||
}
|
||||
|
||||
if len(codeHash) > 0 {
|
||||
acc.CodeHash = make([]byte, len(codeHash))
|
||||
copy(acc.CodeHash, codeHash)
|
||||
}
|
||||
|
||||
return acc, nil
|
||||
}
|
||||
|
||||
// PrefetchAccount is a no-op.
|
||||
// PrefetchAccount is a no-op for NOMT (flat state reads are already fast).
|
||||
func (t *NomtTrie) PrefetchAccount(_ []common.Address) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetStorage reads a storage slot from flat state storage.
|
||||
// TODO(Phase E): implement using EIP-7864 key encoding.
|
||||
func (t *NomtTrie) GetStorage(_ common.Address, _ []byte) ([]byte, error) {
|
||||
return nil, nil
|
||||
// GetStorage reads a storage slot from flat state using EIP-7864 stem keys.
|
||||
func (t *NomtTrie) GetStorage(addr common.Address, key []byte) ([]byte, error) {
|
||||
stem, suffix := storageStemAndSuffix(addr, key)
|
||||
data, err := t.backend.DiskDB().Get(stemValueDBKey(stem, suffix))
|
||||
if err != nil {
|
||||
return nil, nil
|
||||
}
|
||||
return data, nil
|
||||
}
|
||||
|
||||
// PrefetchStorage is a no-op.
|
||||
// PrefetchStorage is a no-op for NOMT.
|
||||
func (t *NomtTrie) PrefetchStorage(_ common.Address, _ [][]byte) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// UpdateAccount encodes the account and queues stem updates.
|
||||
// TODO(Phase E): implement using packBasicData + stem grouping.
|
||||
func (t *NomtTrie) UpdateAccount(_ common.Address, _ *types.StateAccount, _ int) error {
|
||||
// UpdateAccount encodes account metadata and queues stem updates for basic
|
||||
// data (slot 0) and code hash (slot 1) matching bintrie.UpdateAccount.
|
||||
func (t *NomtTrie) UpdateAccount(addr common.Address, acc *types.StateAccount, codeLen int) error {
|
||||
stem := accountStem(addr)
|
||||
|
||||
basicData := packBasicData(acc, codeLen)
|
||||
t.pending = append(t.pending, stemUpdate{
|
||||
Stem: stem,
|
||||
Suffix: bintrie.BasicDataLeafKey,
|
||||
Value: basicData[:],
|
||||
})
|
||||
|
||||
codeHashVal := make([]byte, bintrie.HashSize)
|
||||
copy(codeHashVal, acc.CodeHash)
|
||||
t.pending = append(t.pending, stemUpdate{
|
||||
Stem: stem,
|
||||
Suffix: bintrie.CodeHashLeafKey,
|
||||
Value: codeHashVal,
|
||||
})
|
||||
|
||||
t.dirty = true
|
||||
return nil
|
||||
}
|
||||
|
||||
// UpdateStorage queues a storage value update.
|
||||
// TODO(Phase E): implement using storageStemAndSuffix + packStorageValue.
|
||||
func (t *NomtTrie) UpdateStorage(_ common.Address, _, _ []byte) error {
|
||||
// UpdateStorage queues a storage value update. The value is right-aligned
|
||||
// and padded to 32 bytes, matching bintrie.UpdateStorage.
|
||||
func (t *NomtTrie) UpdateStorage(addr common.Address, key, value []byte) error {
|
||||
stem, suffix := storageStemAndSuffix(addr, key)
|
||||
v := packStorageValue(value)
|
||||
|
||||
t.pending = append(t.pending, stemUpdate{
|
||||
Stem: stem,
|
||||
Suffix: suffix,
|
||||
Value: v[:],
|
||||
})
|
||||
|
||||
t.dirty = true
|
||||
return nil
|
||||
}
|
||||
|
||||
// DeleteAccount queues deletion of account values.
|
||||
// TODO(Phase E): implement.
|
||||
// DeleteAccount is a no-op, matching bintrie behavior.
|
||||
func (t *NomtTrie) DeleteAccount(_ common.Address) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// DeleteStorage queues deletion of a storage slot.
|
||||
// TODO(Phase E): implement.
|
||||
func (t *NomtTrie) DeleteStorage(_ common.Address, _ []byte) error {
|
||||
// DeleteStorage queues a zero-value write for the storage slot,
|
||||
// matching bintrie.DeleteStorage which inserts 32 zero bytes.
|
||||
func (t *NomtTrie) DeleteStorage(addr common.Address, key []byte) error {
|
||||
stem, suffix := storageStemAndSuffix(addr, key)
|
||||
t.pending = append(t.pending, stemUpdate{
|
||||
Stem: stem,
|
||||
Suffix: suffix,
|
||||
Value: make([]byte, bintrie.HashSize),
|
||||
})
|
||||
t.dirty = true
|
||||
return nil
|
||||
}
|
||||
|
||||
// UpdateContractCode queues code chunk updates.
|
||||
// TODO(Phase E): implement using ChunkifyCode + codeChunkStemAndSuffix.
|
||||
func (t *NomtTrie) UpdateContractCode(_ common.Address, _ common.Hash, _ []byte) error {
|
||||
// UpdateContractCode chunks the bytecode using EIP-7864's ChunkifyCode and
|
||||
// queues stem updates for each chunk at offset 128+.
|
||||
func (t *NomtTrie) UpdateContractCode(addr common.Address, _ common.Hash, code []byte) error {
|
||||
chunks := bintrie.ChunkifyCode(code)
|
||||
for i, chunknr := 0, uint64(0); i < len(chunks); i, chunknr = i+bintrie.HashSize, chunknr+1 {
|
||||
stem, suffix := codeChunkStemAndSuffix(addr, chunknr)
|
||||
val := make([]byte, bintrie.HashSize)
|
||||
copy(val, chunks[i:i+bintrie.HashSize])
|
||||
t.pending = append(t.pending, stemUpdate{
|
||||
Stem: stem,
|
||||
Suffix: suffix,
|
||||
Value: val,
|
||||
})
|
||||
}
|
||||
if len(chunks) > 0 {
|
||||
t.dirty = true
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Hash returns the current root hash. Flushes pending updates first.
|
||||
// TODO(Phase E): implement using groupAndHashStems + nomtDB.Update.
|
||||
// Hash flushes pending updates to flat state and the NOMT page tree,
|
||||
// returning the new trie root hash.
|
||||
func (t *NomtTrie) Hash() common.Hash {
|
||||
if !t.dirty {
|
||||
return t.root
|
||||
}
|
||||
|
||||
stemKVs, err := groupAndHashStems(t.pending, t.backend.DiskDB())
|
||||
if err != nil {
|
||||
log.Error("NOMT groupAndHashStems failed", "err", err)
|
||||
return t.root
|
||||
}
|
||||
|
||||
if len(stemKVs) > 0 {
|
||||
newRoot, err := t.nomtDB.Update(stemKVs)
|
||||
if err != nil {
|
||||
log.Error("NOMT page tree update failed", "err", err)
|
||||
return t.root
|
||||
}
|
||||
t.root = common.Hash(newRoot)
|
||||
}
|
||||
|
||||
t.pending = t.pending[:0]
|
||||
t.dirty = false
|
||||
return t.root
|
||||
}
|
||||
|
||||
|
|
@ -113,7 +228,7 @@ func (t *NomtTrie) Commit(_ bool) (common.Hash, *trienode.NodeSet) {
|
|||
return root, trienode.NewNodeSet(common.Hash{})
|
||||
}
|
||||
|
||||
// Witness returns accessed trie nodes. Not yet implemented.
|
||||
// Witness returns accessed trie nodes. Not yet implemented for NOMT.
|
||||
func (t *NomtTrie) Witness() map[string][]byte {
|
||||
return nil
|
||||
}
|
||||
|
|
|
|||
355
trie/nomttrie/trie_test.go
Normal file
355
trie/nomttrie/trie_test.go
Normal file
|
|
@ -0,0 +1,355 @@
|
|||
package nomttrie
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"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/nomt/core"
|
||||
"github.com/ethereum/go-ethereum/trie/bintrie"
|
||||
"github.com/ethereum/go-ethereum/triedb/nomtdb"
|
||||
"github.com/holiman/uint256"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
// newTestTrie creates a NomtTrie backed by an in-memory ethdb and a temp
|
||||
// Bitbox directory. Returns the trie and a cleanup function.
|
||||
func newTestTrie(t *testing.T) *NomtTrie {
|
||||
t.Helper()
|
||||
diskdb := rawdb.NewMemoryDatabase()
|
||||
backend := nomtdb.New(diskdb, &nomtdb.Config{
|
||||
DataDir: t.TempDir(),
|
||||
HTCapacity: 1 << 16,
|
||||
})
|
||||
t.Cleanup(func() { backend.Close() })
|
||||
|
||||
tr, err := New(common.Hash{}, backend)
|
||||
require.NoError(t, err)
|
||||
return tr
|
||||
}
|
||||
|
||||
func TestUpdateAndGetAccount(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
|
||||
addr := common.HexToAddress("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")
|
||||
acc := &types.StateAccount{
|
||||
Nonce: 42,
|
||||
Balance: uint256.NewInt(1_000_000),
|
||||
CodeHash: common.FromHex("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"),
|
||||
}
|
||||
|
||||
require.NoError(t, tr.UpdateAccount(addr, acc, 0))
|
||||
|
||||
// Flush to flat state + page tree.
|
||||
root := tr.Hash()
|
||||
assert.NotEqual(t, common.Hash{}, root, "root should be non-zero after update")
|
||||
|
||||
// Read back from flat state.
|
||||
got, err := tr.GetAccount(addr)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, got)
|
||||
|
||||
assert.Equal(t, acc.Nonce, got.Nonce)
|
||||
assert.Equal(t, acc.Balance.Uint64(), got.Balance.Uint64())
|
||||
assert.Equal(t, acc.CodeHash, got.CodeHash)
|
||||
}
|
||||
|
||||
func TestGetAccountNonExistent(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
addr := common.HexToAddress("0x1111111111111111111111111111111111111111")
|
||||
|
||||
got, err := tr.GetAccount(addr)
|
||||
require.NoError(t, err)
|
||||
assert.Nil(t, got, "nonexistent account should return nil")
|
||||
}
|
||||
|
||||
func TestUpdateAndGetStorage(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
|
||||
addr := common.HexToAddress("0xaaaa")
|
||||
slot := common.Hex2Bytes(
|
||||
"0000000000000000000000000000000000000000000000000000000000000001",
|
||||
)
|
||||
value := common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000ff")
|
||||
|
||||
require.NoError(t, tr.UpdateStorage(addr, slot, value))
|
||||
tr.Hash()
|
||||
|
||||
got, err := tr.GetStorage(addr, slot)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, value, got)
|
||||
}
|
||||
|
||||
func TestGetStorageNonExistent(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
addr := common.HexToAddress("0xbbbb")
|
||||
slot := make([]byte, 32)
|
||||
|
||||
got, err := tr.GetStorage(addr, slot)
|
||||
require.NoError(t, err)
|
||||
assert.Nil(t, got)
|
||||
}
|
||||
|
||||
func TestDeleteStorage(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
|
||||
addr := common.HexToAddress("0xcccc")
|
||||
slot := make([]byte, 32)
|
||||
slot[31] = 1
|
||||
value := make([]byte, 32)
|
||||
value[31] = 0x42
|
||||
|
||||
// Write then flush.
|
||||
require.NoError(t, tr.UpdateStorage(addr, slot, value))
|
||||
tr.Hash()
|
||||
|
||||
// Delete then flush.
|
||||
require.NoError(t, tr.DeleteStorage(addr, slot))
|
||||
tr.Hash()
|
||||
|
||||
// Value should now be 32 zero bytes (not nil).
|
||||
got, err := tr.GetStorage(addr, slot)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, make([]byte, bintrie.HashSize), got)
|
||||
}
|
||||
|
||||
func TestDeleteAccountIsNoOp(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
addr := common.HexToAddress("0xdddd")
|
||||
|
||||
// DeleteAccount should never error.
|
||||
require.NoError(t, tr.DeleteAccount(addr))
|
||||
}
|
||||
|
||||
func TestUpdateContractCode(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
|
||||
addr := common.HexToAddress("0xeeee")
|
||||
code := make([]byte, 100) // 100 bytes of code
|
||||
for i := range code {
|
||||
code[i] = byte(i)
|
||||
}
|
||||
|
||||
require.NoError(t, tr.UpdateContractCode(addr, common.Hash{}, code))
|
||||
|
||||
// Should have queued pending updates: ceil(100/31) = 4 chunks.
|
||||
expectedChunks := (len(code) + bintrie.StemSize - 1) / bintrie.StemSize
|
||||
codeUpdates := 0
|
||||
for _, u := range tr.pending {
|
||||
// Code chunks start at suffix derived from offset 128+.
|
||||
codeUpdates++
|
||||
_ = u
|
||||
}
|
||||
assert.Equal(t, expectedChunks, codeUpdates)
|
||||
|
||||
// Flush and verify root changes.
|
||||
root := tr.Hash()
|
||||
assert.NotEqual(t, common.Hash{}, root)
|
||||
}
|
||||
|
||||
func TestHashIdempotent(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
|
||||
addr := common.HexToAddress("0x1234")
|
||||
acc := &types.StateAccount{
|
||||
Nonce: 1,
|
||||
Balance: uint256.NewInt(100),
|
||||
CodeHash: make([]byte, 32),
|
||||
}
|
||||
|
||||
require.NoError(t, tr.UpdateAccount(addr, acc, 0))
|
||||
|
||||
root1 := tr.Hash()
|
||||
root2 := tr.Hash()
|
||||
|
||||
assert.Equal(t, root1, root2, "Hash() should be idempotent")
|
||||
assert.False(t, tr.dirty, "dirty flag should be cleared after Hash()")
|
||||
assert.Empty(t, tr.pending, "pending should be empty after Hash()")
|
||||
}
|
||||
|
||||
func TestHashEmptyTrieIsZero(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
root := tr.Hash()
|
||||
assert.Equal(t, common.Hash{}, root, "empty trie root should be zero")
|
||||
}
|
||||
|
||||
func TestCommitReturnsRootAndNodeSet(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
|
||||
addr := common.HexToAddress("0x5678")
|
||||
acc := &types.StateAccount{
|
||||
Nonce: 5,
|
||||
Balance: uint256.NewInt(999),
|
||||
CodeHash: make([]byte, 32),
|
||||
}
|
||||
require.NoError(t, tr.UpdateAccount(addr, acc, 0))
|
||||
|
||||
root, nodeset := tr.Commit(false)
|
||||
assert.NotEqual(t, common.Hash{}, root)
|
||||
assert.NotNil(t, nodeset)
|
||||
}
|
||||
|
||||
func TestMultipleAccountsSameBlock(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
|
||||
addrs := []common.Address{
|
||||
common.HexToAddress("0x1111111111111111111111111111111111111111"),
|
||||
common.HexToAddress("0x2222222222222222222222222222222222222222"),
|
||||
common.HexToAddress("0x3333333333333333333333333333333333333333"),
|
||||
}
|
||||
|
||||
for i, addr := range addrs {
|
||||
acc := &types.StateAccount{
|
||||
Nonce: uint64(i + 1),
|
||||
Balance: uint256.NewInt(uint64((i + 1) * 1000)),
|
||||
CodeHash: make([]byte, 32),
|
||||
}
|
||||
require.NoError(t, tr.UpdateAccount(addr, acc, 0))
|
||||
}
|
||||
|
||||
root := tr.Hash()
|
||||
assert.NotEqual(t, common.Hash{}, root)
|
||||
|
||||
// Verify all accounts can be read back.
|
||||
for i, addr := range addrs {
|
||||
got, err := tr.GetAccount(addr)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, got)
|
||||
assert.Equal(t, uint64(i+1), got.Nonce)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSequentialBlocks(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
|
||||
addr := common.HexToAddress("0xabcdef0000000000000000000000000000000000")
|
||||
|
||||
// Block 1: create account.
|
||||
acc := &types.StateAccount{
|
||||
Nonce: 1,
|
||||
Balance: uint256.NewInt(100),
|
||||
CodeHash: make([]byte, 32),
|
||||
}
|
||||
require.NoError(t, tr.UpdateAccount(addr, acc, 0))
|
||||
root1 := tr.Hash()
|
||||
assert.NotEqual(t, common.Hash{}, root1)
|
||||
|
||||
// Block 2: update balance.
|
||||
acc.Nonce = 2
|
||||
acc.Balance = uint256.NewInt(200)
|
||||
require.NoError(t, tr.UpdateAccount(addr, acc, 0))
|
||||
root2 := tr.Hash()
|
||||
assert.NotEqual(t, root1, root2, "root should change after update")
|
||||
|
||||
// Verify updated account.
|
||||
got, err := tr.GetAccount(addr)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, got)
|
||||
assert.Equal(t, uint64(2), got.Nonce)
|
||||
assert.Equal(t, uint64(200), got.Balance.Uint64())
|
||||
}
|
||||
|
||||
func TestAccountWithStorageAndCode(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
addr := common.HexToAddress("0xffff")
|
||||
|
||||
// Update account.
|
||||
acc := &types.StateAccount{
|
||||
Nonce: 10,
|
||||
Balance: uint256.NewInt(5000),
|
||||
CodeHash: common.FromHex("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"),
|
||||
}
|
||||
require.NoError(t, tr.UpdateAccount(addr, acc, 64))
|
||||
|
||||
// Update storage.
|
||||
slot := make([]byte, 32)
|
||||
slot[31] = 1
|
||||
val := make([]byte, 32)
|
||||
val[31] = 0x42
|
||||
require.NoError(t, tr.UpdateStorage(addr, slot, val))
|
||||
|
||||
// Update code (small contract).
|
||||
code := []byte{0x60, 0x00, 0x60, 0x00, 0xFD} // PUSH0 PUSH0 REVERT
|
||||
require.NoError(t, tr.UpdateContractCode(addr, common.Hash{}, code))
|
||||
|
||||
root := tr.Hash()
|
||||
assert.NotEqual(t, common.Hash{}, root)
|
||||
|
||||
// Verify account.
|
||||
got, err := tr.GetAccount(addr)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, got)
|
||||
assert.Equal(t, uint64(10), got.Nonce)
|
||||
|
||||
// Verify storage.
|
||||
gotVal, err := tr.GetStorage(addr, slot)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, val, gotVal)
|
||||
}
|
||||
|
||||
func TestCopyTrieIsIndependent(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
|
||||
addr := common.HexToAddress("0x9999")
|
||||
acc := &types.StateAccount{
|
||||
Nonce: 1,
|
||||
Balance: uint256.NewInt(100),
|
||||
CodeHash: make([]byte, 32),
|
||||
}
|
||||
require.NoError(t, tr.UpdateAccount(addr, acc, 0))
|
||||
|
||||
// Copy before flushing.
|
||||
tr2 := tr.Copy()
|
||||
assert.Equal(t, len(tr.pending), len(tr2.pending))
|
||||
|
||||
// Flush original.
|
||||
root1 := tr.Hash()
|
||||
assert.NotEqual(t, common.Hash{}, root1)
|
||||
assert.Empty(t, tr.pending)
|
||||
|
||||
// Copy should still have pending updates.
|
||||
assert.NotEmpty(t, tr2.pending)
|
||||
assert.True(t, tr2.dirty)
|
||||
}
|
||||
|
||||
func TestIsVerkle(t *testing.T) {
|
||||
tr := newTestTrie(t)
|
||||
assert.True(t, tr.IsVerkle())
|
||||
}
|
||||
|
||||
func TestHashProducesCorrectStemHash(t *testing.T) {
|
||||
// Verify that a single-account trie produces a root that matches
|
||||
// manual stem hash computation.
|
||||
tr := newTestTrie(t)
|
||||
|
||||
addr := common.HexToAddress("0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
|
||||
acc := &types.StateAccount{
|
||||
Nonce: 7,
|
||||
Balance: uint256.NewInt(42),
|
||||
CodeHash: make([]byte, 32),
|
||||
}
|
||||
codeLen := 0
|
||||
|
||||
require.NoError(t, tr.UpdateAccount(addr, acc, codeLen))
|
||||
root := tr.Hash()
|
||||
|
||||
// Reproduce the expected root manually.
|
||||
stem := accountStem(addr)
|
||||
basicData := packBasicData(acc, codeLen)
|
||||
codeHashVal := make([]byte, bintrie.HashSize)
|
||||
copy(codeHashVal, acc.CodeHash)
|
||||
|
||||
var values [core.StemNodeWidth][]byte
|
||||
values[bintrie.BasicDataLeafKey] = basicData[:]
|
||||
values[bintrie.CodeHashLeafKey] = codeHashVal
|
||||
stemHash := core.HashStem(stem, values)
|
||||
|
||||
// The trie has one stem → the root is the stem hash placed at depth 248,
|
||||
// surrounded by terminators. The exact root depends on the page tree
|
||||
// hashing, but it should be deterministic.
|
||||
assert.NotEqual(t, common.Hash{}, root)
|
||||
assert.NotEqual(t, common.Hash(stemHash), root,
|
||||
"root != stemHash because the page tree hashes internal nodes above the stem")
|
||||
}
|
||||
Loading…
Reference in a new issue