cerc-io/eth-statediff-service
16
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Fix rlp.EncodeToBytes arg and creating node iterators

Browse Source
This commit is contained in:
nabarun 2022-05-11 15:21:23 +05:30
parent 9a7ecf9ef3
commit 32724ff46c
4 changed files with 102 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
pkg/builder.go
View File

@ -42,7 +42,7 @@ import (
var (
nullHashBytes = common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000")
emptyNode, _ = rlp.EncodeToBytes([]byte{})
emptyNode, _ = rlp.EncodeToBytes(&[]byte{})
emptyContractRoot = crypto.Keccak256Hash(emptyNode)
nullCodeHash = crypto.Keccak256Hash([]byte{}).Bytes()
)
@ -218,16 +218,18 @@ func (sdb *builder) WriteStateDiffObject(args sdtypes.StateRoots, params sd.Para
// Load tries for old and new states
oldTrie, err := sdb.stateCache.OpenTrie(args.OldStateRoot)
if err != nil {
return fmt.Errorf("error creating trie for old state root: %v", err)
return fmt.Errorf("error creating trie for oldStateRoot: %v", err)
}
newTrie, err := sdb.stateCache.OpenTrie(args.NewStateRoot)
if err != nil {
return fmt.Errorf("error creating trie for new state root: %v", err)
return fmt.Errorf("error creating trie for newStateRoot: %v", err)
}
// Split old and new tries into corresponding subtrie iterators
oldIters := iter.SubtrieIterators(oldTrie, sdb.numWorkers)
newIters := iter.SubtrieIterators(newTrie, sdb.numWorkers)
oldIters1 := iter.SubtrieIterators(oldTrie, sdb.numWorkers)
oldIters2 := iter.SubtrieIterators(oldTrie, sdb.numWorkers)
newIters1 := iter.SubtrieIterators(newTrie, sdb.numWorkers)
newIters2 := iter.SubtrieIterators(newTrie, sdb.numWorkers)
// Create iterators ahead of time to avoid race condition in state.Trie access
// We do two state iterations per subtrie: one for new/updated nodes,
@ -235,8 +237,8 @@ func (sdb *builder) WriteStateDiffObject(args sdtypes.StateRoots, params sd.Para
var iterPairs [][]iterPair
for i := uint(0); i < sdb.numWorkers; i++ {
iterPairs = append(iterPairs, []iterPair{
{older: oldIters[i], newer: newIters[i]},
{older: oldIters[i], newer: newIters[i]},
{older: oldIters1[i], newer: newIters1[i]},
{older: oldIters2[i], newer: newIters2[i]},
})
}
@ -311,13 +313,13 @@ func (sdb *builder) buildStateDiff(args []iterPair, params sd.Params, output sdt
return fmt.Errorf("error collecting deletedOrUpdatedNodes: %v", err)
}
// collect and sort the leafkey keys for both account mappings into a slice
// collect and sort the leafkeys for both account mappings into a slice
createKeys := sortKeys(diffAccountsAtB)
deleteKeys := sortKeys(diffAccountsAtA)
// and then find the intersection of these keys
// these are the leafkeys for the accounts which exist at both A and B but are different
// this also mutates the passed in createKeys and deleteKeys, removing the intersection keys
// this also mutates the passed in createKeys and deleteKeys, removing in intersection keys
// and leaving the truly created or deleted keys in place
updatedKeys := findIntersection(createKeys, deleteKeys)
@ -346,7 +348,7 @@ func (sdb *builder) createdAndUpdatedState(iters iterPair, watchedAddressesLeafK
if it.Leaf() || bytes.Equal(nullHashBytes, it.Hash().Bytes()) {
continue
}
node, nodeElements, err := resolveNode(it, sdb.stateCache.TrieDB())
node, nodeElements, err := sdtrie.ResolveNode(it, sdb.stateCache.TrieDB())
if err != nil {
return nil, nil, err
}
@ -438,10 +440,11 @@ func (sdb *builder) deletedOrUpdatedState(iters iterPair, diffAccountsAtB Accoun
diffAccountAtA := make(AccountMap)
it, _ := trie.NewDifferenceIterator(iters.newer, iters.older)
for it.Next(true) {
// skip value nodes
if it.Leaf() || bytes.Equal(nullHashBytes, it.Hash().Bytes()) {
continue
}
node, nodeElements, err := resolveNode(it, sdb.stateCache.TrieDB())
node, nodeElements, err := sdtrie.ResolveNode(it, sdb.stateCache.TrieDB())
if err != nil {
return nil, err
}
@ -573,7 +576,7 @@ func (sdb *builder) buildAccountCreations(accounts AccountMap, intermediateStora
return fmt.Errorf("failed building eventual storage diffs for node %x\r\nerror: %v", val.Path, err)
}
diff.StorageNodes = storageDiffs
// emit codehash => code mappings for code
// emit codehash => code mappings for cod
codeHash := common.BytesToHash(val.Account.CodeHash)
code, err := sdb.stateCache.ContractCode(common.Hash{}, codeHash)
if err != nil {
@ -793,19 +796,15 @@ func (sdb *builder) createdAndUpdatedStorage(a, b trie.NodeIterator, intermediat
func (sdb *builder) deletedOrUpdatedStorage(a, b trie.NodeIterator, diffSlotsAtB, diffPathsAtB map[string]bool, intermediateNodes bool, output sdtypes.StorageNodeSink) error {
it, _ := trie.NewDifferenceIterator(b, a)
for it.Next(true) {
// skip value nodes
if it.Leaf() || bytes.Equal(nullHashBytes, it.Hash().Bytes()) {
continue
}
node, nodeElements, err := resolveNode(it, sdb.stateCache.TrieDB())
node, nodeElements, err := sdtrie.ResolveNode(it, sdb.stateCache.TrieDB())
if err != nil {
return err
}
// if this node path showed up in diffPathsAtB
// that means this node was updated at B and we already have the updated diff for it
// otherwise that means this node was deleted in B and we need to add a "removed" diff to represent that event
if _, ok := diffPathsAtB[common.Bytes2Hex(node.Path)]; ok {
continue
}
switch node.NodeType {
case sdtypes.Leaf:
partialPath := trie.CompactToHex(nodeElements[0].([]byte))

161
pkg/builder_test.go
View File

@ -66,233 +66,233 @@ var (
slot2StorageValue = common.Hex2Bytes("09")
slot3StorageValue = common.Hex2Bytes("03")
slot0StorageLeafNode, _ = rlp.EncodeToBytes([]interface{}{
slot0StorageLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("390decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563"),
slot0StorageValue,
})
slot1StorageLeafNode, _ = rlp.EncodeToBytes([]interface{}{
slot1StorageLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("310e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6"),
slot1StorageValue,
})
slot2StorageLeafNode, _ = rlp.EncodeToBytes([]interface{}{
slot2StorageLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("305787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace"),
slot2StorageValue,
})
slot3StorageLeafNode, _ = rlp.EncodeToBytes([]interface{}{
slot3StorageLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("32575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b"),
slot3StorageValue,
})
slot0StorageLeafRootNode, _ = rlp.EncodeToBytes([]interface{}{
slot0StorageLeafRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("20290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563"),
slot0StorageValue,
})
contractAccountAtBlock2, _ = rlp.EncodeToBytes(types.StateAccount{
contractAccountAtBlock2, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 1,
Balance: big.NewInt(0),
CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
Root: crypto.Keccak256Hash(block2StorageBranchRootNode),
})
contractAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes([]interface{}{
contractAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"),
contractAccountAtBlock2,
})
contractAccountAtBlock3, _ = rlp.EncodeToBytes(types.StateAccount{
contractAccountAtBlock3, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 1,
Balance: big.NewInt(0),
CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
Root: crypto.Keccak256Hash(block3StorageBranchRootNode),
})
contractAccountAtBlock3LeafNode, _ = rlp.EncodeToBytes([]interface{}{
contractAccountAtBlock3LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"),
contractAccountAtBlock3,
})
contractAccountAtBlock4, _ = rlp.EncodeToBytes(types.StateAccount{
contractAccountAtBlock4, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 1,
Balance: big.NewInt(0),
CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
Root: crypto.Keccak256Hash(block4StorageBranchRootNode),
})
contractAccountAtBlock4LeafNode, _ = rlp.EncodeToBytes([]interface{}{
contractAccountAtBlock4LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"),
contractAccountAtBlock4,
})
contractAccountAtBlock5, _ = rlp.EncodeToBytes(types.StateAccount{
contractAccountAtBlock5, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 1,
Balance: big.NewInt(0),
CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
Root: crypto.Keccak256Hash(slot0StorageLeafRootNode),
})
contractAccountAtBlock5LeafNode, _ = rlp.EncodeToBytes([]interface{}{
contractAccountAtBlock5LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"),
contractAccountAtBlock5,
})
minerAccountAtBlock1, _ = rlp.EncodeToBytes(types.StateAccount{
minerAccountAtBlock1, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 0,
Balance: big.NewInt(miningReward),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
minerAccountAtBlock1LeafNode, _ = rlp.EncodeToBytes([]interface{}{
minerAccountAtBlock1LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3380c7b7ae81a58eb98d9c78de4a1fd7fd9535fc953ed2be602daaa41767312a"),
minerAccountAtBlock1,
})
minerAccountAtBlock2, _ = rlp.EncodeToBytes(types.StateAccount{
minerAccountAtBlock2, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 0,
Balance: big.NewInt(miningReward + miningReward),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
minerAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes([]interface{}{
minerAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3380c7b7ae81a58eb98d9c78de4a1fd7fd9535fc953ed2be602daaa41767312a"),
minerAccountAtBlock2,
})
account1AtBlock1, _ = rlp.EncodeToBytes(types.StateAccount{
account1AtBlock1, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 0,
Balance: big.NewInt(balanceChange10000),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
account1AtBlock1LeafNode, _ = rlp.EncodeToBytes([]interface{}{
account1AtBlock1LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
account1AtBlock1,
})
account1AtBlock2, _ = rlp.EncodeToBytes(types.StateAccount{
account1AtBlock2, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 2,
Balance: big.NewInt(block1Account1Balance - balanceChange1000 + balanceChange1000),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
account1AtBlock2LeafNode, _ = rlp.EncodeToBytes([]interface{}{
account1AtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
account1AtBlock2,
})
account1AtBlock5, _ = rlp.EncodeToBytes(types.StateAccount{
account1AtBlock5, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 2,
Balance: big.NewInt(block1Account1Balance - balanceChange1000 + balanceChange1000 + miningReward),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
account1AtBlock5LeafNode, _ = rlp.EncodeToBytes([]interface{}{
account1AtBlock5LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
account1AtBlock5,
})
account1AtBlock6, _ = rlp.EncodeToBytes(types.StateAccount{
account1AtBlock6, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 3,
Balance: big.NewInt(block1Account1Balance - balanceChange1000 + balanceChange1000 + miningReward),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
account1AtBlock6LeafNode, _ = rlp.EncodeToBytes([]interface{}{
account1AtBlock6LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
account1AtBlock6,
})
account2AtBlock2, _ = rlp.EncodeToBytes(types.StateAccount{
account2AtBlock2, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 0,
Balance: big.NewInt(balanceChange1000),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
account2AtBlock2LeafNode, _ = rlp.EncodeToBytes([]interface{}{
account2AtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"),
account2AtBlock2,
})
account2AtBlock3, _ = rlp.EncodeToBytes(types.StateAccount{
account2AtBlock3, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 0,
Balance: big.NewInt(block2Account2Balance + miningReward),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
account2AtBlock3LeafNode, _ = rlp.EncodeToBytes([]interface{}{
account2AtBlock3LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"),
account2AtBlock3,
})
account2AtBlock4, _ = rlp.EncodeToBytes(types.StateAccount{
account2AtBlock4, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 0,
Balance: big.NewInt(block2Account2Balance + miningReward*2),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
account2AtBlock4LeafNode, _ = rlp.EncodeToBytes([]interface{}{
account2AtBlock4LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"),
account2AtBlock4,
})
account2AtBlock6, _ = rlp.EncodeToBytes(types.StateAccount{
account2AtBlock6, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 0,
Balance: big.NewInt(block2Account2Balance + miningReward*3),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
account2AtBlock6LeafNode, _ = rlp.EncodeToBytes([]interface{}{
account2AtBlock6LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"),
account2AtBlock6,
})
bankAccountAtBlock0, _ = rlp.EncodeToBytes(types.StateAccount{
bankAccountAtBlock0, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 0,
Balance: big.NewInt(testhelpers.TestBankFunds.Int64()),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
bankAccountAtBlock0LeafNode, _ = rlp.EncodeToBytes([]interface{}{
bankAccountAtBlock0LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("2000bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
bankAccountAtBlock0,
})
bankAccountAtBlock1, _ = rlp.EncodeToBytes(types.StateAccount{
bankAccountAtBlock1, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 1,
Balance: big.NewInt(testhelpers.TestBankFunds.Int64() - balanceChange10000),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
bankAccountAtBlock1LeafNode, _ = rlp.EncodeToBytes([]interface{}{
bankAccountAtBlock1LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
bankAccountAtBlock1,
})
bankAccountAtBlock2, _ = rlp.EncodeToBytes(types.StateAccount{
bankAccountAtBlock2, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 2,
Balance: big.NewInt(block1BankBalance - balanceChange1000),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
bankAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes([]interface{}{
bankAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
bankAccountAtBlock2,
})
bankAccountAtBlock3, _ = rlp.EncodeToBytes(types.StateAccount{
bankAccountAtBlock3, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 3,
Balance: big.NewInt(99989000),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
bankAccountAtBlock3LeafNode, _ = rlp.EncodeToBytes([]interface{}{
bankAccountAtBlock3LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
bankAccountAtBlock3,
})
bankAccountAtBlock4, _ = rlp.EncodeToBytes(types.StateAccount{
bankAccountAtBlock4, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 6,
Balance: big.NewInt(99989000),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
bankAccountAtBlock4LeafNode, _ = rlp.EncodeToBytes([]interface{}{
bankAccountAtBlock4LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
bankAccountAtBlock4,
})
bankAccountAtBlock5, _ = rlp.EncodeToBytes(types.StateAccount{
bankAccountAtBlock5, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 7,
Balance: big.NewInt(99989000),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
bankAccountAtBlock5LeafNode, _ = rlp.EncodeToBytes([]interface{}{
bankAccountAtBlock5LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
bankAccountAtBlock5,
})
block1BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
block1BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
crypto.Keccak256(bankAccountAtBlock1LeafNode),
[]byte{},
[]byte{},
@ -311,7 +311,7 @@ var (
[]byte{},
[]byte{},
})
block2BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
block2BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
crypto.Keccak256(bankAccountAtBlock2LeafNode),
[]byte{},
[]byte{},
@ -330,7 +330,7 @@ var (
[]byte{},
[]byte{},
})
block3BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
block3BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
crypto.Keccak256(bankAccountAtBlock3LeafNode),
[]byte{},
[]byte{},
@ -349,7 +349,7 @@ var (
[]byte{},
[]byte{},
})
block4BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
block4BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
crypto.Keccak256(bankAccountAtBlock4LeafNode),
[]byte{},
[]byte{},
@ -368,7 +368,7 @@ var (
[]byte{},
[]byte{},
})
block5BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
block5BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
crypto.Keccak256(bankAccountAtBlock5LeafNode),
[]byte{},
[]byte{},
@ -387,7 +387,7 @@ var (
[]byte{},
[]byte{},
})
block6BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
block6BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
crypto.Keccak256(bankAccountAtBlock5LeafNode),
[]byte{},
[]byte{},
@ -407,7 +407,7 @@ var (
[]byte{},
})
block2StorageBranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
block2StorageBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
[]byte{},
[]byte{},
crypto.Keccak256(slot0StorageLeafNode),
@ -426,7 +426,7 @@ var (
[]byte{},
[]byte{},
})
block3StorageBranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
block3StorageBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
[]byte{},
[]byte{},
crypto.Keccak256(slot0StorageLeafNode),
@ -445,7 +445,7 @@ var (
[]byte{},
[]byte{},
})
block4StorageBranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
block4StorageBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
[]byte{},
[]byte{},
crypto.Keccak256(slot0StorageLeafNode),
@ -681,7 +681,7 @@ func TestBuilder(t *testing.T) {
if err != nil {
t.Error(err)
}
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
receivedStateDiffRlp, err := rlp.EncodeToBytes(&diff)
if err != nil {
t.Error(err)
}
@ -946,11 +946,11 @@ func TestBuilderWithIntermediateNodes(t *testing.T) {
if err != nil {
t.Error(err)
}
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
receivedStateDiffRlp, err := rlp.EncodeToBytes(&diff)
if err != nil {
t.Error(err)
}
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
expectedStateDiffRlp, err := rlp.EncodeToBytes(&test.expected)
if err != nil {
t.Error(err)
}
@ -989,6 +989,7 @@ func TestBuilderWithWatchedAddressList(t *testing.T) {
params := statediff.Params{
WatchedAddresses: []common.Address{testhelpers.Account1Addr, testhelpers.ContractAddr},
}
params.ComputeWatchedAddressesLeafKeys()
var tests = []struct {
name string
@ -1137,11 +1138,11 @@ func TestBuilderWithWatchedAddressList(t *testing.T) {
if err != nil {
t.Error(err)
}
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
receivedStateDiffRlp, err := rlp.EncodeToBytes(&diff)
if err != nil {
t.Error(err)
}
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
expectedStateDiffRlp, err := rlp.EncodeToBytes(&test.expected)
if err != nil {
t.Error(err)
}
@ -1301,11 +1302,11 @@ func TestBuilderWithWatchedAddressAndStorageKeyList(t *testing.T) {
if err != nil {
t.Error(err)
}
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
receivedStateDiffRlp, err := rlp.EncodeToBytes(&diff)
if err != nil {
t.Error(err)
}
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
expectedStateDiffRlp, err := rlp.EncodeToBytes(&test.expected)
if err != nil {
t.Error(err)
}
@ -1515,11 +1516,11 @@ func TestBuilderWithRemovedAccountAndStorage(t *testing.T) {
if err != nil {
t.Error(err)
}
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
receivedStateDiffRlp, err := rlp.EncodeToBytes(&diff)
if err != nil {
t.Error(err)
}
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
expectedStateDiffRlp, err := rlp.EncodeToBytes(&test.expected)
if err != nil {
t.Error(err)
}
@ -1706,11 +1707,11 @@ func TestBuilderWithRemovedAccountAndStorageWithoutIntermediateNodes(t *testing.
if err != nil {
t.Error(err)
}
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
receivedStateDiffRlp, err := rlp.EncodeToBytes(&diff)
if err != nil {
t.Error(err)
}
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
expectedStateDiffRlp, err := rlp.EncodeToBytes(&test.expected)
if err != nil {
t.Error(err)
}
@ -1727,44 +1728,44 @@ func TestBuilderWithRemovedAccountAndStorageWithoutIntermediateNodes(t *testing.
var (
slot00StorageValue = common.Hex2Bytes("9471562b71999873db5b286df957af199ec94617f7") // prefixed TestBankAddress
slot00StorageLeafNode, _ = rlp.EncodeToBytes([]interface{}{
slot00StorageLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("390decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563"),
slot00StorageValue,
})
contractAccountAtBlock01, _ = rlp.EncodeToBytes(types.StateAccount{
contractAccountAtBlock01, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 1,
Balance: big.NewInt(0),
CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
Root: crypto.Keccak256Hash(block01StorageBranchRootNode),
})
contractAccountAtBlock01LeafNode, _ = rlp.EncodeToBytes([]interface{}{
contractAccountAtBlock01LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("3cb2583748c26e89ef19c2a8529b05a270f735553b4d44b6f2a1894987a71c8b"),
contractAccountAtBlock01,
})
bankAccountAtBlock01, _ = rlp.EncodeToBytes(types.StateAccount{
bankAccountAtBlock01, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 1,
Balance: big.NewInt(testhelpers.TestBankFunds.Int64() + miningReward),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
bankAccountAtBlock01LeafNode, _ = rlp.EncodeToBytes([]interface{}{
bankAccountAtBlock01LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
bankAccountAtBlock01,
})
bankAccountAtBlock02, _ = rlp.EncodeToBytes(types.StateAccount{
bankAccountAtBlock02, _ = rlp.EncodeToBytes(&types.StateAccount{
Nonce: 2,
Balance: big.NewInt(testhelpers.TestBankFunds.Int64() + miningReward*2),
CodeHash: testhelpers.NullCodeHash.Bytes(),
Root: testhelpers.EmptyContractRoot,
})
bankAccountAtBlock02LeafNode, _ = rlp.EncodeToBytes([]interface{}{
bankAccountAtBlock02LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
common.Hex2Bytes("2000bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
bankAccountAtBlock02,
})
block01BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
block01BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
crypto.Keccak256Hash(bankAccountAtBlock01LeafNode),
crypto.Keccak256Hash(contractAccountAtBlock01LeafNode),
[]byte{},
@ -1784,7 +1785,7 @@ var (
[]byte{},
})
block01StorageBranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
block01StorageBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
[]byte{},
[]byte{},
crypto.Keccak256(slot00StorageLeafNode),
@ -1924,11 +1925,11 @@ func TestBuilderWithMovedAccount(t *testing.T) {
if err != nil {
t.Error(err)
}
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
receivedStateDiffRlp, err := rlp.EncodeToBytes(&diff)
if err != nil {
t.Error(err)
}
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
expectedStateDiffRlp, err := rlp.EncodeToBytes(&test.expected)
if err != nil {
t.Error(err)
}
@ -2050,11 +2051,11 @@ func TestBuilderWithMovedAccountOnlyLeafs(t *testing.T) {
if err != nil {
t.Error(err)
}
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
receivedStateDiffRlp, err := rlp.EncodeToBytes(&diff)
if err != nil {
t.Error(err)
}
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
expectedStateDiffRlp, err := rlp.EncodeToBytes(&test.expected)
if err != nil {
t.Error(err)
}
@ -2281,11 +2282,11 @@ func TestBuildStateTrie(t *testing.T) {
if err != nil {
t.Error(err)
}
receivedStateTrieRlp, err := rlp.EncodeToBytes(diff)
receivedStateTrieRlp, err := rlp.EncodeToBytes(&diff)
if err != nil {
t.Error(err)
}
expectedStateTrieRlp, err := rlp.EncodeToBytes(test.expected)
expectedStateTrieRlp, err := rlp.EncodeToBytes(&test.expected)
if err != nil {
t.Error(err)
}

4
pkg/service.go
View File

@ -233,7 +233,7 @@ func (sds *Service) processStateDiff(currentBlock *types.Block, parentRoot commo
if err != nil {
return nil, err
}
stateDiffRlp, err := rlp.EncodeToBytes(stateDiff)
stateDiffRlp, err := rlp.EncodeToBytes(&stateDiff)
if err != nil {
return nil, err
}
@ -289,7 +289,7 @@ func (sds *Service) processStateTrie(block *types.Block, params sd.Params) (*sd.
if err != nil {
return nil, err
}
stateTrieRlp, err := rlp.EncodeToBytes(stateNodes)
stateTrieRlp, err := rlp.EncodeToBytes(&stateNodes)
if err != nil {
return nil, err
}

2
pkg/testhelpers/test_data.go
View File

@ -62,6 +62,6 @@ var (
CodeHash = common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127")
ContractAddr common.Address
EmptyRootNode, _ = rlp.EncodeToBytes([]byte{})
EmptyRootNode, _ = rlp.EncodeToBytes(&[]byte{})
EmptyContractRoot = crypto.Keccak256Hash(EmptyRootNode)
)