mirror of
https://gitlab.com/pulsechaincom/erigon-pulse.git
synced 2024-12-22 11:41:19 +00:00
893 lines
27 KiB
Go
893 lines
27 KiB
Go
// Copyright 2014 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 trie
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"math/big"
|
|
"math/rand"
|
|
"os"
|
|
"reflect"
|
|
"testing"
|
|
"testing/quick"
|
|
|
|
"github.com/davecgh/go-spew/spew"
|
|
"github.com/ledgerwatch/turbo-geth/common"
|
|
"github.com/ledgerwatch/turbo-geth/core/types/accounts"
|
|
"github.com/ledgerwatch/turbo-geth/crypto"
|
|
"github.com/ledgerwatch/turbo-geth/ethdb"
|
|
"github.com/ledgerwatch/turbo-geth/rlp"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func init() {
|
|
spew.Config.Indent = " "
|
|
spew.Config.DisableMethods = false
|
|
}
|
|
|
|
// Used for testing
|
|
func newEmpty() *Trie {
|
|
trie := New(common.Hash{})
|
|
return trie
|
|
}
|
|
|
|
func TestEmptyTrie(t *testing.T) {
|
|
var trie Trie
|
|
res := trie.Hash()
|
|
exp := EmptyRoot
|
|
if res != common.Hash(exp) {
|
|
t.Errorf("expected %x got %x", exp, res)
|
|
}
|
|
}
|
|
|
|
func TestNull(t *testing.T) {
|
|
var trie Trie
|
|
key := make([]byte, 32)
|
|
value := []byte("test")
|
|
trie.Update(key, value)
|
|
v, _ := trie.Get(key)
|
|
if !bytes.Equal(v, value) {
|
|
t.Fatal("wrong value")
|
|
}
|
|
}
|
|
|
|
func TestInsert(t *testing.T) {
|
|
t.Skip("we don't support different key length")
|
|
trie := newEmpty()
|
|
|
|
updateString(trie, "doe", "reindeer")
|
|
updateString(trie, "dog", "puppy")
|
|
updateString(trie, "dogglesworth", "cat")
|
|
|
|
fmt.Printf("\n\n%s\n\n", trie.root.fstring(""))
|
|
exp := common.HexToHash("8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3")
|
|
root := trie.Hash()
|
|
if root != exp {
|
|
t.Errorf("case 1: exp %x got %x", exp, root)
|
|
}
|
|
|
|
trie = newEmpty()
|
|
updateString(trie, "A", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
|
|
|
|
exp = common.HexToHash("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab")
|
|
root = trie.Hash()
|
|
if root != exp {
|
|
t.Errorf("case 2: exp %x got %x", exp, root)
|
|
}
|
|
}
|
|
|
|
func TestGet(t *testing.T) {
|
|
t.Skip("different length of key is not supported")
|
|
trie := newEmpty()
|
|
|
|
updateString(trie, "doe", "reindeer")
|
|
updateString(trie, "dog", "puppy")
|
|
updateString(trie, "dogglesworth", "cat")
|
|
|
|
for i := 0; i < 2; i++ {
|
|
res := getString(trie, "dog")
|
|
if !bytes.Equal(res, []byte("puppy")) {
|
|
t.Errorf("expected puppy got %x", res)
|
|
}
|
|
|
|
unknown := getString(trie, "unknown")
|
|
if unknown != nil {
|
|
t.Errorf("expected nil got %x", unknown)
|
|
}
|
|
|
|
if i == 1 {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDelete(t *testing.T) {
|
|
t.Skip("should be restored. skipped for turbo-geth")
|
|
|
|
trie := newEmpty()
|
|
vals := []struct{ k, v string }{
|
|
{"do", "verb"},
|
|
{"ether", "wookiedoo"},
|
|
{"horse", "stallion"},
|
|
{"shaman", "horse"},
|
|
{"doge", "coin"},
|
|
{"ether", ""},
|
|
{"dog", "puppy"},
|
|
{"shaman", ""},
|
|
}
|
|
for _, val := range vals {
|
|
if val.v != "" {
|
|
updateString(trie, val.k, val.v)
|
|
} else {
|
|
deleteString(trie, val.k)
|
|
}
|
|
}
|
|
|
|
hash := trie.Hash()
|
|
exp := common.HexToHash("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84")
|
|
if hash != exp {
|
|
t.Errorf("expected %x got %x", exp, hash)
|
|
}
|
|
}
|
|
|
|
func TestEmptyValues(t *testing.T) {
|
|
t.Skip("should be restored. skipped for turbo-geth")
|
|
trie := newEmpty()
|
|
|
|
vals := []struct{ k, v string }{
|
|
{"do", "verb"},
|
|
{"ether", "wookiedoo"},
|
|
{"horse", "stallion"},
|
|
{"shaman", "horse"},
|
|
{"doge", "coin"},
|
|
{"ether", ""},
|
|
{"dog", "puppy"},
|
|
{"shaman", ""},
|
|
}
|
|
for _, val := range vals {
|
|
updateString(trie, val.k, val.v)
|
|
}
|
|
|
|
hash := trie.Hash()
|
|
exp := common.HexToHash("5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84")
|
|
if hash != exp {
|
|
t.Errorf("expected %x got %x", exp, hash)
|
|
}
|
|
}
|
|
|
|
func TestReplication(t *testing.T) {
|
|
t.Skip("should be restored. skipped for turbo-geth")
|
|
|
|
trie := newEmpty()
|
|
vals := []struct{ k, v string }{
|
|
{"do", "verb"},
|
|
{"ether", "wookiedoo"},
|
|
{"horse", "stallion"},
|
|
{"shaman", "horse"},
|
|
{"doge", "coin"},
|
|
{"dog", "puppy"},
|
|
{"somethingveryoddindeedthis is", "myothernodedata"},
|
|
}
|
|
for _, val := range vals {
|
|
updateString(trie, val.k, val.v)
|
|
}
|
|
exp := trie.Hash()
|
|
|
|
// create a new trie on top of the database and check that lookups work.
|
|
trie2 := New(exp)
|
|
for _, kv := range vals {
|
|
if string(getString(trie2, kv.k)) != kv.v {
|
|
t.Errorf("trie2 doesn't have %q => %q", kv.k, kv.v)
|
|
}
|
|
}
|
|
hash := trie2.Hash()
|
|
if hash != exp {
|
|
t.Errorf("root failure. expected %x got %x", exp, hash)
|
|
}
|
|
|
|
// perform some insertions on the new trie.
|
|
vals2 := []struct{ k, v string }{
|
|
{"do", "verb"},
|
|
{"ether", "wookiedoo"},
|
|
{"horse", "stallion"},
|
|
// {"shaman", "horse"},
|
|
// {"doge", "coin"},
|
|
// {"ether", ""},
|
|
// {"dog", "puppy"},
|
|
// {"somethingveryoddindeedthis is", "myothernodedata"},
|
|
// {"shaman", ""},
|
|
}
|
|
for _, val := range vals2 {
|
|
updateString(trie2, val.k, val.v)
|
|
}
|
|
if hash := trie2.Hash(); hash != exp {
|
|
t.Errorf("root failure. expected %x got %x", exp, hash)
|
|
}
|
|
}
|
|
|
|
func TestLargeValue(t *testing.T) {
|
|
trie := newEmpty()
|
|
trie.Update([]byte("key1"), []byte{99, 99, 99, 99})
|
|
trie.Update([]byte("key2"), bytes.Repeat([]byte{1}, 32))
|
|
trie.Hash()
|
|
}
|
|
|
|
type countingDB struct {
|
|
ethdb.Database
|
|
gets map[string]int
|
|
}
|
|
|
|
func (db *countingDB) Get(bucket []byte, key []byte) ([]byte, error) {
|
|
db.gets[string(key)]++
|
|
return db.Database.Get(bucket, key)
|
|
}
|
|
|
|
// TestRandomCases tests som cases that were found via random fuzzing
|
|
func TestRandomCases(t *testing.T) {
|
|
var rt []randTestStep = []randTestStep{
|
|
{op: 6, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 0
|
|
{op: 6, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 1
|
|
{op: 0, key: common.Hex2Bytes("d51b182b95d677e5f1c82508c0228de96b73092d78ce78b2230cd948674f66fd1483bd"), value: common.Hex2Bytes("0000000000000002")}, // step 2
|
|
{op: 2, key: common.Hex2Bytes("c2a38512b83107d665c65235b0250002882ac2022eb00711552354832c5f1d030d0e408e"), value: common.Hex2Bytes("")}, // step 3
|
|
{op: 3, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 4
|
|
{op: 3, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 5
|
|
{op: 6, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 6
|
|
{op: 3, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 7
|
|
{op: 0, key: common.Hex2Bytes("c2a38512b83107d665c65235b0250002882ac2022eb00711552354832c5f1d030d0e408e"), value: common.Hex2Bytes("0000000000000008")}, // step 8
|
|
{op: 0, key: common.Hex2Bytes("d51b182b95d677e5f1c82508c0228de96b73092d78ce78b2230cd948674f66fd1483bd"), value: common.Hex2Bytes("0000000000000009")}, // step 9
|
|
{op: 2, key: common.Hex2Bytes("fd"), value: common.Hex2Bytes("")}, // step 10
|
|
{op: 6, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 11
|
|
{op: 6, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 12
|
|
{op: 0, key: common.Hex2Bytes("fd"), value: common.Hex2Bytes("000000000000000d")}, // step 13
|
|
{op: 6, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 14
|
|
{op: 1, key: common.Hex2Bytes("c2a38512b83107d665c65235b0250002882ac2022eb00711552354832c5f1d030d0e408e"), value: common.Hex2Bytes("")}, // step 15
|
|
{op: 3, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 16
|
|
{op: 0, key: common.Hex2Bytes("c2a38512b83107d665c65235b0250002882ac2022eb00711552354832c5f1d030d0e408e"), value: common.Hex2Bytes("0000000000000011")}, // step 17
|
|
{op: 5, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 18
|
|
{op: 3, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 19
|
|
// FIXME: fix these testcases for turbo-geth
|
|
//{op: 0, key: common.Hex2Bytes("d51b182b95d677e5f1c82508c0228de96b73092d78ce78b2230cd948674f66fd1483bd"), value: common.Hex2Bytes("0000000000000014")}, // step 20
|
|
//{op: 0, key: common.Hex2Bytes("d51b182b95d677e5f1c82508c0228de96b73092d78ce78b2230cd948674f66fd1483bd"), value: common.Hex2Bytes("0000000000000015")}, // step 21
|
|
//{op: 0, key: common.Hex2Bytes("c2a38512b83107d665c65235b0250002882ac2022eb00711552354832c5f1d030d0e408e"), value: common.Hex2Bytes("0000000000000016")}, // step 22
|
|
{op: 5, key: common.Hex2Bytes(""), value: common.Hex2Bytes("")}, // step 23
|
|
//{op: 1, key: common.Hex2Bytes("980c393656413a15c8da01978ed9f89feb80b502f58f2d640e3a2f5f7a99a7018f1b573befd92053ac6f78fca4a87268"), value: common.Hex2Bytes("")}, // step 24
|
|
//{op: 1, key: common.Hex2Bytes("fd"), value: common.Hex2Bytes("")}, // step 25
|
|
}
|
|
runRandTest(rt)
|
|
|
|
}
|
|
|
|
// randTest performs random trie operations.
|
|
// Instances of this test are created by Generate.
|
|
type randTest []randTestStep
|
|
|
|
type randTestStep struct {
|
|
op int
|
|
key []byte // for opUpdate, opDelete, opGet
|
|
value []byte // for opUpdate
|
|
err error // for debugging
|
|
}
|
|
|
|
const (
|
|
opUpdate = iota
|
|
opDelete
|
|
opGet
|
|
opCommit
|
|
opHash
|
|
opReset
|
|
opItercheckhash
|
|
opCheckCacheInvariant
|
|
opMax // boundary value, not an actual op
|
|
)
|
|
|
|
func (randTest) Generate(r *rand.Rand, size int) reflect.Value {
|
|
var allKeys [][]byte
|
|
genKey := func() []byte {
|
|
if len(allKeys) < 2 || r.Intn(100) < 10 {
|
|
// new key
|
|
key := make([]byte, r.Intn(50))
|
|
r.Read(key)
|
|
allKeys = append(allKeys, key)
|
|
return key
|
|
}
|
|
// use existing key
|
|
return allKeys[r.Intn(len(allKeys))]
|
|
}
|
|
|
|
var steps randTest
|
|
for i := 0; i < size; i++ {
|
|
step := randTestStep{op: r.Intn(opMax)}
|
|
switch step.op {
|
|
case opUpdate:
|
|
step.key = genKey()
|
|
step.value = make([]byte, 8)
|
|
binary.BigEndian.PutUint64(step.value, uint64(i))
|
|
case opGet, opDelete:
|
|
step.key = genKey()
|
|
}
|
|
steps = append(steps, step)
|
|
}
|
|
return reflect.ValueOf(steps)
|
|
}
|
|
|
|
func runRandTest(rt randTest) bool {
|
|
tr := New(common.Hash{})
|
|
values := make(map[string]string) // tracks content of the trie
|
|
|
|
for i, step := range rt {
|
|
fmt.Printf("{op: %d, key: common.Hex2Bytes(\"%x\"), value: common.Hex2Bytes(\"%x\")}, // step %d\n",
|
|
step.op, step.key, step.value, i)
|
|
switch step.op {
|
|
case opUpdate:
|
|
tr.Update(step.key, step.value)
|
|
values[string(step.key)] = string(step.value)
|
|
case opDelete:
|
|
tr.Delete(step.key)
|
|
delete(values, string(step.key))
|
|
case opGet:
|
|
v, _ := tr.Get(step.key)
|
|
want := values[string(step.key)]
|
|
if string(v) != want {
|
|
rt[i].err = fmt.Errorf("mismatch for key 0x%x, got 0x%x want 0x%x", step.key, v, want)
|
|
}
|
|
case opCommit:
|
|
case opHash:
|
|
tr.Hash()
|
|
case opReset:
|
|
hash := tr.Hash()
|
|
newtr := New(hash)
|
|
tr = newtr
|
|
case opItercheckhash:
|
|
// FIXME: restore for turbo-geth
|
|
/*
|
|
checktr := New(common.Hash{})
|
|
it := NewIterator(tr.NodeIterator(nil))
|
|
for it.Next() {
|
|
checktr.Update(it.Key, it.Value)
|
|
}
|
|
if tr.Hash() != checktr.Hash() {
|
|
rt[i].err = fmt.Errorf("hash mismatch in opItercheckhash")
|
|
}
|
|
*/
|
|
case opCheckCacheInvariant:
|
|
}
|
|
// Abort the test on error.
|
|
if rt[i].err != nil {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func TestRandom(t *testing.T) {
|
|
t.Skip("should be restored. skipped for turbo-geth")
|
|
|
|
if err := quick.Check(runRandTest, nil); err != nil {
|
|
if cerr, ok := err.(*quick.CheckError); ok {
|
|
t.Fatalf("random test iteration %d failed: %s", cerr.Count, spew.Sdump(cerr.In))
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func BenchmarkGet(b *testing.B) { benchGet(b, false) }
|
|
func BenchmarkGetDB(b *testing.B) { benchGet(b, true) }
|
|
func BenchmarkUpdateBE(b *testing.B) { benchUpdate(b, binary.BigEndian) }
|
|
func BenchmarkUpdateLE(b *testing.B) { benchUpdate(b, binary.LittleEndian) }
|
|
|
|
const benchElemCount = 20000
|
|
|
|
func benchGet(b *testing.B, commit bool) {
|
|
trie := new(Trie)
|
|
var tmpdir string
|
|
var tmpdb ethdb.Database
|
|
if commit {
|
|
tmpdir, tmpdb = tempDB()
|
|
trie = New(common.Hash{})
|
|
}
|
|
k := make([]byte, 32)
|
|
for i := 0; i < benchElemCount; i++ {
|
|
binary.LittleEndian.PutUint64(k, uint64(i))
|
|
trie.Update(k, k)
|
|
}
|
|
binary.LittleEndian.PutUint64(k, benchElemCount/2)
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
trie.Get(k)
|
|
}
|
|
b.StopTimer()
|
|
|
|
if commit {
|
|
tmpdb.Close()
|
|
os.RemoveAll(tmpdir)
|
|
}
|
|
}
|
|
|
|
func benchUpdate(b *testing.B, e binary.ByteOrder) *Trie {
|
|
trie := newEmpty()
|
|
k := make([]byte, 32)
|
|
b.ReportAllocs()
|
|
for i := 0; i < b.N; i++ {
|
|
e.PutUint64(k, uint64(i))
|
|
trie.Update(k, k)
|
|
}
|
|
return trie
|
|
}
|
|
|
|
// Benchmarks the trie hashing. Since the trie caches the result of any operation,
|
|
// we cannot use b.N as the number of hashing rouns, since all rounds apart from
|
|
// the first one will be NOOP. As such, we'll use b.N as the number of account to
|
|
// insert into the trie before measuring the hashing.
|
|
func BenchmarkHash(b *testing.B) {
|
|
// Make the random benchmark deterministic
|
|
random := rand.New(rand.NewSource(0))
|
|
|
|
// Create a realistic account trie to hash
|
|
addresses := make([][20]byte, b.N)
|
|
for i := 0; i < len(addresses); i++ {
|
|
for j := 0; j < len(addresses[i]); j++ {
|
|
addresses[i][j] = byte(random.Intn(256))
|
|
}
|
|
}
|
|
accounts := make([][]byte, len(addresses))
|
|
for i := 0; i < len(accounts); i++ {
|
|
var (
|
|
nonce = uint64(random.Int63())
|
|
balance = new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
|
|
root = EmptyRoot
|
|
code = crypto.Keccak256(nil)
|
|
)
|
|
accounts[i], _ = rlp.EncodeToBytes([]interface{}{nonce, balance, root, code})
|
|
}
|
|
// Insert the accounts into the trie and hash it
|
|
trie := newEmpty()
|
|
for i := 0; i < len(addresses); i++ {
|
|
trie.Update(crypto.Keccak256(addresses[i][:]), accounts[i])
|
|
}
|
|
b.ResetTimer()
|
|
b.ReportAllocs()
|
|
trie.Hash()
|
|
}
|
|
|
|
func tempDB() (string, ethdb.Database) {
|
|
dir, err := ioutil.TempDir("", "trie-bench")
|
|
if err != nil {
|
|
panic(fmt.Sprintf("can't create temporary directory: %v", err))
|
|
}
|
|
diskdb, err := ethdb.NewBoltDatabase(dir)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("can't create temporary database: %v", err))
|
|
}
|
|
return dir, diskdb
|
|
}
|
|
|
|
func getString(trie *Trie, k string) []byte {
|
|
v, _ := trie.Get([]byte(k))
|
|
return v
|
|
}
|
|
|
|
func updateString(trie *Trie, k, v string) {
|
|
trie.Update([]byte(k), []byte(v))
|
|
}
|
|
|
|
func deleteString(trie *Trie, k string) {
|
|
trie.Delete([]byte(k))
|
|
}
|
|
|
|
func TestDeepHash(t *testing.T) {
|
|
acc := accounts.NewAccount()
|
|
prefix := "prefix"
|
|
var testdata = [][]struct {
|
|
key string
|
|
value string
|
|
}{
|
|
{{"key1", "value1"}},
|
|
{{"key1", "value1"}, {"key2", "value2"}},
|
|
{{"key1", "value1"}, {"key2", "value2"}, {"key3", "value3"}},
|
|
{{"key1", "value1"}, {"key2", "value2"}, {"\xffek3", "value3"}},
|
|
}
|
|
for i, keyVals := range testdata {
|
|
fmt.Println("Test", i)
|
|
trie := New(common.Hash{})
|
|
for _, keyVal := range keyVals {
|
|
trie.Update([]byte(keyVal.key), []byte(keyVal.value))
|
|
}
|
|
trie.PrintTrie()
|
|
hash1 := trie.Hash()
|
|
|
|
prefixTrie := New(common.Hash{})
|
|
prefixTrie.UpdateAccount([]byte(prefix), &acc)
|
|
for _, keyVal := range keyVals {
|
|
// Add a prefix to every key
|
|
prefixTrie.Update([]byte(prefix+keyVal.key), []byte(keyVal.value))
|
|
}
|
|
|
|
got2, hash2 := prefixTrie.DeepHash([]byte(prefix))
|
|
if !got2 {
|
|
t.Errorf("Expected DeepHash returning true, got false, testcase %d", i)
|
|
}
|
|
if hash1 != hash2 {
|
|
t.Errorf("DeepHash mistmatch: %x, expected %x, testcase %d", hash2, hash1, i)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestHashMapLeak(t *testing.T) {
|
|
// freeze the randomness
|
|
random := rand.New(rand.NewSource(794656320434))
|
|
|
|
// now create a trie with some small and some big leaves
|
|
trie := newEmpty()
|
|
nTouches := 256 * 10
|
|
|
|
var key [1]byte
|
|
var val [8]byte
|
|
for i := 0; i < nTouches; i++ {
|
|
key[0] = byte(random.Intn(256))
|
|
binary.BigEndian.PutUint64(val[:], random.Uint64())
|
|
|
|
option := random.Intn(3)
|
|
if option == 0 {
|
|
// small leaf node
|
|
trie.Update(key[:], val[:])
|
|
} else if option == 1 {
|
|
// big leaf node
|
|
trie.Update(key[:], crypto.Keccak256(val[:]))
|
|
} else {
|
|
// test delete as well
|
|
trie.Delete(key[:])
|
|
}
|
|
}
|
|
|
|
// check the size of trie's hash map
|
|
trie.Hash()
|
|
|
|
nHashes := trie.HashMapSize()
|
|
nExpected := 1 + 16 + 256/3
|
|
|
|
assert.GreaterOrEqual(t, nHashes, nExpected*7/8)
|
|
assert.LessOrEqual(t, nHashes, nExpected*9/8)
|
|
}
|
|
|
|
func genRandomByteArrayOfLen(length uint) []byte {
|
|
array := make([]byte, length)
|
|
for i := uint(0); i < length; i++ {
|
|
array[i] = byte(rand.Intn(256))
|
|
}
|
|
return array
|
|
}
|
|
|
|
func getAddressForIndex(index int) [20]byte {
|
|
var address [20]byte
|
|
binary.BigEndian.PutUint32(address[:], uint32(index))
|
|
return address
|
|
}
|
|
|
|
func TestCodeNodeValid(t *testing.T) {
|
|
trie := newEmpty()
|
|
|
|
random := rand.New(rand.NewSource(0))
|
|
|
|
numberOfAccounts := 20
|
|
|
|
addresses := make([][20]byte, numberOfAccounts)
|
|
for i := 0; i < len(addresses); i++ {
|
|
addresses[i] = getAddressForIndex(i)
|
|
}
|
|
codeValues := make([][]byte, len(addresses))
|
|
for i := 0; i < len(addresses); i++ {
|
|
codeValues[i] = genRandomByteArrayOfLen(128)
|
|
codeHash := common.BytesToHash(crypto.Keccak256(codeValues[i]))
|
|
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
|
|
acc := accounts.NewAccount()
|
|
acc.Nonce = uint64(random.Int63())
|
|
acc.Balance = *balance
|
|
acc.Root = EmptyRoot
|
|
acc.CodeHash = codeHash
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(addresses[i][:]), &acc)
|
|
err := trie.UpdateAccountCode(crypto.Keccak256(addresses[i][:]), codeValues[i])
|
|
assert.Nil(t, err, "should successfully insert code")
|
|
}
|
|
|
|
for i := 0; i < len(addresses); i++ {
|
|
value, gotValue := trie.GetAccountCode(crypto.Keccak256(addresses[i][:]))
|
|
assert.True(t, gotValue, "should receive code value")
|
|
assert.True(t, bytes.Equal(value, codeValues[i]), "should receive the right code")
|
|
}
|
|
}
|
|
|
|
func TestCodeNodeUpdateNotExisting(t *testing.T) {
|
|
trie := newEmpty()
|
|
|
|
random := rand.New(rand.NewSource(0))
|
|
|
|
address := getAddressForIndex(0)
|
|
codeValue := genRandomByteArrayOfLen(128)
|
|
|
|
codeHash := common.BytesToHash(crypto.Keccak256(codeValue))
|
|
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
|
|
|
|
acc := accounts.NewAccount()
|
|
acc.Nonce = uint64(random.Int63())
|
|
acc.Balance = *balance
|
|
acc.Root = EmptyRoot
|
|
acc.CodeHash = codeHash
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
err := trie.UpdateAccountCode(crypto.Keccak256(address[:]), codeValue)
|
|
assert.Nil(t, err, "should successfully insert code")
|
|
|
|
nonExistingAddress := getAddressForIndex(9999)
|
|
codeValue2 := genRandomByteArrayOfLen(128)
|
|
|
|
err = trie.UpdateAccountCode(crypto.Keccak256(nonExistingAddress[:]), codeValue2)
|
|
assert.Error(t, err, "should return an error for non existing acc")
|
|
}
|
|
|
|
func TestCodeNodeGetNotExistingAccount(t *testing.T) {
|
|
trie := newEmpty()
|
|
|
|
random := rand.New(rand.NewSource(0))
|
|
|
|
address := getAddressForIndex(0)
|
|
codeValue := genRandomByteArrayOfLen(128)
|
|
|
|
codeHash := common.BytesToHash(crypto.Keccak256(codeValue))
|
|
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
|
|
|
|
acc := accounts.NewAccount()
|
|
acc.Nonce = uint64(random.Int63())
|
|
acc.Balance = *balance
|
|
acc.Root = EmptyRoot
|
|
acc.CodeHash = codeHash
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
err := trie.UpdateAccountCode(crypto.Keccak256(address[:]), codeValue)
|
|
assert.Nil(t, err, "should successfully insert code")
|
|
|
|
nonExistingAddress := getAddressForIndex(9999)
|
|
|
|
value, gotValue := trie.GetAccountCode(crypto.Keccak256(nonExistingAddress[:]))
|
|
assert.True(t, gotValue, "should indicate that account doesn't exist at all (not just hashed)")
|
|
assert.Nil(t, value, "the value should be nil")
|
|
}
|
|
|
|
func TestCodeNodeGetHashedAccount(t *testing.T) {
|
|
trie := newEmpty()
|
|
|
|
address := getAddressForIndex(0)
|
|
|
|
fakeAccount := genRandomByteArrayOfLen(50)
|
|
fakeAccountHash := common.BytesToHash(crypto.Keccak256(fakeAccount))
|
|
|
|
hex := keybytesToHex(crypto.Keccak256(address[:]))
|
|
|
|
_, trie.root = trie.insert(trie.root, hex, 0, hashNode(fakeAccountHash[:]))
|
|
|
|
value, gotValue := trie.GetAccountCode(crypto.Keccak256(address[:]))
|
|
assert.False(t, gotValue, "should indicate that account exists but hashed")
|
|
assert.Nil(t, value, "the value should be nil")
|
|
}
|
|
|
|
func TestCodeNodeGetExistingAccountNoCodeNotEmpty(t *testing.T) {
|
|
trie := newEmpty()
|
|
|
|
random := rand.New(rand.NewSource(0))
|
|
|
|
address := getAddressForIndex(0)
|
|
codeValue := genRandomByteArrayOfLen(128)
|
|
|
|
codeHash := common.BytesToHash(crypto.Keccak256(codeValue))
|
|
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
|
|
|
|
acc := accounts.NewAccount()
|
|
acc.Nonce = uint64(random.Int63())
|
|
acc.Balance = *balance
|
|
acc.Root = EmptyRoot
|
|
acc.CodeHash = codeHash
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
|
|
value, gotValue := trie.GetAccountCode(crypto.Keccak256(address[:]))
|
|
assert.False(t, gotValue, "should indicate that account exists with code but the code isn't in cache")
|
|
assert.Nil(t, value, "the value should be nil")
|
|
}
|
|
|
|
func TestCodeNodeGetExistingAccountEmptyCode(t *testing.T) {
|
|
trie := newEmpty()
|
|
|
|
random := rand.New(rand.NewSource(0))
|
|
|
|
address := getAddressForIndex(0)
|
|
|
|
codeHash := EmptyCodeHash
|
|
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
|
|
|
|
acc := accounts.NewAccount()
|
|
acc.Nonce = uint64(random.Int63())
|
|
acc.Balance = *balance
|
|
acc.Root = EmptyRoot
|
|
acc.CodeHash = codeHash
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
|
|
value, gotValue := trie.GetAccountCode(crypto.Keccak256(address[:]))
|
|
assert.True(t, gotValue, "should indicate that account exists with empty code")
|
|
assert.Nil(t, value, "the value should be nil")
|
|
}
|
|
|
|
func TestCodeNodeWrongHash(t *testing.T) {
|
|
trie := newEmpty()
|
|
|
|
random := rand.New(rand.NewSource(0))
|
|
|
|
address := getAddressForIndex(0)
|
|
|
|
codeValue1 := genRandomByteArrayOfLen(128)
|
|
codeHash1 := common.BytesToHash(crypto.Keccak256(codeValue1))
|
|
|
|
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
|
|
|
|
acc := accounts.NewAccount()
|
|
acc.Nonce = uint64(random.Int63())
|
|
acc.Balance = *balance
|
|
acc.Root = EmptyRoot
|
|
acc.CodeHash = codeHash1
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
|
|
codeValue2 := genRandomByteArrayOfLen(128)
|
|
err := trie.UpdateAccountCode(crypto.Keccak256(address[:]), codeValue2)
|
|
assert.Error(t, err, "should NOT be able to insert code with wrong hash")
|
|
}
|
|
|
|
func TestCodeNodeUpdateAccountAndCodeValidHash(t *testing.T) {
|
|
trie := newEmpty()
|
|
|
|
random := rand.New(rand.NewSource(0))
|
|
|
|
address := getAddressForIndex(0)
|
|
|
|
codeValue1 := genRandomByteArrayOfLen(128)
|
|
codeHash1 := common.BytesToHash(crypto.Keccak256(codeValue1))
|
|
|
|
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
|
|
|
|
acc := accounts.NewAccount()
|
|
acc.Nonce = uint64(random.Int63())
|
|
acc.Balance = *balance
|
|
acc.Root = EmptyRoot
|
|
acc.CodeHash = codeHash1
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
err := trie.UpdateAccountCode(crypto.Keccak256(address[:]), codeValue1)
|
|
assert.Nil(t, err, "should successfully insert code")
|
|
|
|
codeValue2 := genRandomByteArrayOfLen(128)
|
|
codeHash2 := common.BytesToHash(crypto.Keccak256(codeValue2))
|
|
|
|
acc.CodeHash = codeHash2
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
err = trie.UpdateAccountCode(crypto.Keccak256(address[:]), codeValue2)
|
|
assert.Nil(t, err, "should successfully insert code")
|
|
}
|
|
|
|
func TestCodeNodeUpdateAccountAndCodeInvalidHash(t *testing.T) {
|
|
trie := newEmpty()
|
|
|
|
random := rand.New(rand.NewSource(0))
|
|
|
|
address := getAddressForIndex(0)
|
|
|
|
codeValue1 := genRandomByteArrayOfLen(128)
|
|
codeHash1 := common.BytesToHash(crypto.Keccak256(codeValue1))
|
|
|
|
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
|
|
|
|
acc := accounts.NewAccount()
|
|
acc.Nonce = uint64(random.Int63())
|
|
acc.Balance = *balance
|
|
acc.Root = EmptyRoot
|
|
acc.CodeHash = codeHash1
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
err := trie.UpdateAccountCode(crypto.Keccak256(address[:]), codeValue1)
|
|
assert.Nil(t, err, "should successfully insert code")
|
|
|
|
codeValue2 := genRandomByteArrayOfLen(128)
|
|
codeHash2 := common.BytesToHash(crypto.Keccak256(codeValue2))
|
|
|
|
codeValue3 := genRandomByteArrayOfLen(128)
|
|
|
|
acc.CodeHash = codeHash2
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
err = trie.UpdateAccountCode(crypto.Keccak256(address[:]), codeValue3)
|
|
assert.Error(t, err, "should NOT be able to insert code with wrong hash")
|
|
}
|
|
|
|
func TestCodeNodeUpdateAccountChangeCodeHash(t *testing.T) {
|
|
trie := newEmpty()
|
|
|
|
random := rand.New(rand.NewSource(0))
|
|
|
|
address := getAddressForIndex(0)
|
|
|
|
codeValue1 := genRandomByteArrayOfLen(128)
|
|
codeHash1 := common.BytesToHash(crypto.Keccak256(codeValue1))
|
|
|
|
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
|
|
|
|
acc := accounts.NewAccount()
|
|
acc.Nonce = uint64(random.Int63())
|
|
acc.Balance = *balance
|
|
acc.Root = EmptyRoot
|
|
acc.CodeHash = codeHash1
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
err := trie.UpdateAccountCode(crypto.Keccak256(address[:]), codeValue1)
|
|
assert.Nil(t, err, "should successfully insert code")
|
|
|
|
codeValue2 := genRandomByteArrayOfLen(128)
|
|
codeHash2 := common.BytesToHash(crypto.Keccak256(codeValue2))
|
|
|
|
acc.CodeHash = codeHash2
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
value, gotValue := trie.GetAccountCode(crypto.Keccak256(address[:]))
|
|
assert.Nil(t, value, "the value should reset after the code change happen")
|
|
assert.False(t, gotValue, "should indicate that the code isn't in the cache")
|
|
}
|
|
|
|
func TestCodeNodeUpdateAccountNoChangeCodeHash(t *testing.T) {
|
|
trie := newEmpty()
|
|
|
|
random := rand.New(rand.NewSource(0))
|
|
|
|
address := getAddressForIndex(0)
|
|
|
|
codeValue1 := genRandomByteArrayOfLen(128)
|
|
codeHash1 := common.BytesToHash(crypto.Keccak256(codeValue1))
|
|
|
|
balance := new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
|
|
|
|
acc := accounts.NewAccount()
|
|
acc.Nonce = uint64(random.Int63())
|
|
acc.Balance = *balance
|
|
acc.Root = EmptyRoot
|
|
acc.CodeHash = codeHash1
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
err := trie.UpdateAccountCode(crypto.Keccak256(address[:]), codeValue1)
|
|
assert.Nil(t, err, "should successfully insert code")
|
|
|
|
acc.Nonce = uint64(random.Int63())
|
|
balance = new(big.Int).Rand(random, new(big.Int).Exp(common.Big2, common.Big256, nil))
|
|
acc.Balance = *balance
|
|
|
|
trie.UpdateAccount(crypto.Keccak256(address[:]), &acc)
|
|
value, gotValue := trie.GetAccountCode(crypto.Keccak256(address[:]))
|
|
assert.Equal(t, codeValue1, value, "the value should NOT reset after account's non codehash had changed")
|
|
assert.True(t, gotValue, "should indicate that the code is still in the cache")
|
|
}
|