3aead03aeb
* Write state diff to CSV (#2) * port statediff from9b7fd9af80/statediff/statediff.go; minor fixes * integrating state diff extracting, building, and persisting into geth processes * work towards persisting created statediffs in ipfs; based off github.com/vulcanize/eth-block-extractor * Add a state diff service * Remove diff extractor from blockchain * Update imports * Move statediff on/off check to geth cmd config * Update starting state diff service * Add debugging logs for creating diff * Add statediff extractor and builder tests and small refactoring * Start to write statediff to a CSV * Restructure statediff directory * Pull CSV publishing methods into their own file * Reformatting due to go fmt * Add gomega to vendor dir * Remove testing focuses * Update statediff tests to use golang test pkg instead of ginkgo - builder_test - extractor_test - publisher_test * Use hexutil.Encode instead of deprecated common.ToHex * Remove OldValue from DiffBigInt and DiffUint64 fields * Update builder test * Remove old storage value from updated accounts * Remove old values from created/deleted accounts * Update publisher to account for only storing current account values * Update service loop and fetching previous block * Update testing - remove statediff ginkgo test suite file - move mocks to their own dir * Updates per go fmt * Updates to tests * Pass statediff mode and path in through cli * Return filename from publisher * Remove some duplication in builder * Remove code field from state diff output this is the contract byte code, and it can still be obtained by querying the db by the codeHash * Consolidate acct diff structs for updated & updated/deleted accts * Include block number in csv filename * Clean up error logging * Cleanup formatting, spelling, etc * Address PR comments * Add contract address and storage value to csv * Refactor accumulating account row in csv publisher * Add DiffStorage struct * Add storage key to csv * Address PR comments * Fix publisher to include rows for accounts that don't have store updates * Update builder test after merging in release/1.8 * Update test contract to include storage on contract intialization - so that we're able to test that storage diffing works for created and deleted accounts (not just updated accounts). * Factor out a common trie iterator method in builder * Apply goimports to statediff * Apply gosimple changes to statediff * Gracefully exit geth command(#4) * Statediff for full node (#6) * Open a trie from the in-memory database * Use a node's LeafKey as an identifier instead of the address It was proving difficult to find look the address up from a given path with a full node (sometimes the value wouldn't exist in the disk db). So, instead, for now we are using the node's LeafKey with is a Keccak256 hash of the address, so if we know the address we can figure out which LeafKey it matches up to. * Make sure that statediff has been processed before pruning * Use blockchain stateCache.OpenTrie for storage diffs * Clean up log lines and remove unnecessary fields from builder * Apply go fmt changes * Add a sleep to the blockchain test * refactoring/reorganizing packages * refactoring statediff builder and types and adjusted to relay proofs and paths (still need to make this optional) * refactoring state diff service and adding api which allows for streaming state diff payloads over an rpc websocket subscription * make proofs and paths optional + compress service loop into single for loop (may be missing something here) * option to process intermediate nodes * make state diff rlp serializable * cli parameter to limit statediffing to select account addresses + test * review fixes and fixes for issues ran into in integration * review fixes; proper method signature for api; adjust service so that statediff processing is halted/paused until there is at least one subscriber listening for the results * adjust buffering to improve stability; doc.go; fix notifier err handling * relay receipts with the rest of the data + review fixes/changes * rpc method to get statediff at specific block; requires archival node or the block be within the pruning range * fix linter issues * include total difficulty to the payload * fix state diff builder: emit actual leaf nodes instead of value nodes; diff on the leaf not on the value; emit correct path for intermediate nodes * adjust statediff builder tests to changes and extend to test intermediate nodes; golint * add genesis block to test; handle block 0 in StateDiffAt * rlp files for mainnet blocks 0-3, for tests * builder test on mainnet blocks * common.BytesToHash(path) => crypto.Keaccak256(hash) in builder; BytesToHash produces same hash for e.g. []byte{} and []byte{\x00} - prefix \x00 steps are inconsequential to the hash result * complete tests for early mainnet blocks * diff type for representing deleted accounts * fix builder so that we handle account deletions properly and properly diff storage when an account is moved to a new path; update params * remove cli params; moving them to subscriber defined * remove unneeded bc methods * update service and api; statediffing params are now defined by user through api rather than by service provider by cli * update top level tests * add ability to watch specific storage slots (leaf keys) only * comments; explain logic * update mainnet blocks test * update api_test.go * storage leafkey filter test * cleanup chain maker * adjust chain maker for tests to add an empty account in block1 and switch to EIP-158 afterwards (now we just need to generate enough accounts until one causes the empty account to be touched and removed post-EIP-158 so we can simulate and test that process...); also added 2 new blocks where more contract storage is set and old slots are set to zero so they are removed so we can test that * found an account whose creation causes the empty account to be moved to a new path; this should count as 'touching; the empty account and cause it to be removed according to eip-158... but it doesn't * use new contract in unit tests that has self-destruct ability, so we can test eip-158 since simply moving an account to new path doesn't count as 'touchin' it * handle storage deletions * tests for eip-158 account removal and storage value deletions; there is one edge case left to test where we remove 1 account when only two exist such that the remaining account is moved up and replaces the root branch node * finish testing known edge cases * add endpoint to fetch all state and storage nodes at a given blockheight; useful for generating a recent atate cache/snapshot that we can diff forward from rather than needing to collect all diffs from genesis * test for state trie builder * if statediffing is on, lock tries in triedb until the statediffing service signals they are done using them * fix mock blockchain; golint; bump patch * increase maxRequestContentLength; bump patch * log the sizes of the state objects we are sending * CI build (#20) * CI: run build on PR and on push to master * CI: debug building geth * CI: fix coping file * CI: fix coping file v2 * CI: temporary upload file to release asset * CI: get release upload_url by tag, upload asset to current relase * CI: fix tag name * fix ci build on statediff_at_anyblock-1.9.11 branch * fix publishing assets in release * use context deadline for timeout in eth_call * collect and emit codehash=>code mappings for state objects * subscription endpoint for retrieving all the codehash=>code mappings that exist at provided height * Implement WriteStateDiffAt * Writes state diffs directly to postgres * Adds CLI flags to configure PG * Refactors builder output with callbacks * Copies refactored postgres handling code from ipld-eth-indexer * rename PostgresCIDWriter.{index->upsert}* * rm unused * output code & codehash iteratively * had to rf some types for this * prometheus metrics output * duplicate recent eth-indexer changes * migrations and metrics... * [wip] prom.Init() here? another CLI flag? * tidy & DRY * statediff WriteLoop service + CLI flag * [wip] update test mocks * todo - do something meaningful to test write loop * logging * use geth log * port tests to go testing * drop ginkgo/gomega * fix and cleanup tests * fail before defer statement * delete vendor/ dir * fixes after rebase onto 1.9.23 * fix API registration * use golang 1.15.5 version (#34) * bump version meta; add 0.0.11 branch to actions * bump version meta; update github actions workflows * statediff: refactor metrics * Remove redundant statediff/indexer/prom tooling and use existing prometheus integration. * "indexer" namespace for metrics * add reporting loop for db metrics * doc * metrics for statediff stats * metrics namespace/subsystem = statediff/{indexer,service} * statediff: use a worker pool (for direct writes) * fix test * fix chain event subscription * log tweaks * func name * unused import * intermediate chain event channel for metrics * update github actions; linting * add poststate and status to receipt ipld indexes * stateDiffFor endpoints for fetching or writing statediff object by blockhash; bump statediff version * fixes after rebase on to v1.10.1 * update github actions and version meta; go fmt * add leaf key to removed 'nodes' * include Postgres migrations and schema * service documentation * touching up * update github actions after rebase * fix connection leak (misplaced defer) and perform proper rollback on errs * improve error logging; handle PushBlock internal err * build docker image and publish it to Docker Hub on release * add access list tx to unit tests * MarshalBinary and UnmarshalBinary methods for receipt * fix error caused by 2718 by using MarshalBinary instead of EncodeRLP methods * ipld encoding/decoding tests * update TxModel; add AccessListElementModel * index tx type and access lists * add access list metrics * unit tests for tx_type and access list table * unit tests for receipt marshal/unmarshal binary methods * improve documentation of the encoding methods * fix issue identified in linting * update github actions and version meta after rebase * unit test that fails undeterministically on eip2930 txs, giving same error we are seeing in prod * Include genesis block state diff. * documentation on versioning, rebasing, releasing; bump version meta * Add geth and statediff unit test to CI. * Set pgpassword in env. * Added comments. * Add new major branch to github action. * Add support for Dynamic txn(EIP-1559). * Update version meta to 0.0.24 * Verify block base fee in test. * Fix base_fee type and add backward compatible test. * Remove type definition for AccessListElementModel * Change basefee to int64/bigint. * block and uncle reward in PoA network = 0 (#87) * in PoA networks there is no block and uncle rewards * bump meta version * (cherry picked from commitb64ca14689) * Use Ropsten to test block reward. * Add Makefile target to build static linux binaries. * Strip symbol tables from static binaries. * Fix block_fee to support NULL values. * bump version meta. * Add new major branch to github action. * rename doc.go to README.md * Create a seperate table for storing logs * Bump statediff version to 0.0.26. * add btree index to state/storage_cids.node_type; updated schema * Dedup receipt data. * Fix linter errors. * Address comments. * Bump statediff version to 0.0.27. * new cli flag for initializing db first time service is ran * only write Removed node ipld block (on db init) and reuse constant cid and mhkey * test new handling of Removed nodes; don't require init flag * log metrics * Add new major branch to github action. * Fix build. * Update golang version in CI. * Use ipld-eth-db in testing. * Remove migration from repo. * Add new major branch to github action. *Use `GetTd` instead of `GetTdByHash`6289137827* Add new major branch to github action. * Report DB metrics * batch inserts to public.blocks * v2 => v3 major refactor * fixes and cli integration for new options * update example command in readme * ashwin's fix for failing pgx unit test * update to use new schema; fix pgx driver * indexer that writes sql stmts out to a file * cli integration * fix unit tests * use node_id as PK/FK * misc fixes/adjustments * update README * cleanup; more unit tests * basefee is big.Int, it won't always fit in int64 * adjust for schema updates * finish unit tests * test harnest for arbitrary mainnet blocks and receipts * cache problematic block locally for quicker testing/easier CI testing * fix issue with log/logTrie processing * remove some unecessary hashing operations * handle edge case * add more 'bad blocks' to mainnet_tests * increase file write buffer size * increase buffer further * fix rct trie multicodec type * extend testing * log trie fk fix * bump statediff meta version; use db v0.3.0 in compose * skip file writing tests in CI, for now * prevent parallel execution of tests in different pkgs (suspect this is what causes our deadlock to show up only in CI test env) adjust write buffering * fix rct unit tests * fix README formatting * port retry on deadlock detection feature * new workflow on-'master' targets * update version meta * improve test coverage for logs * fix possible race condition * fix CI * check tx pool state at end of unit tests * better logging of rollbacks and dead lock retries
2324 lines
65 KiB
Go
2324 lines
65 KiB
Go
// Copyright 2019 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 statediff_test
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"math/big"
|
|
"os"
|
|
"sort"
|
|
"testing"
|
|
|
|
types2 "github.com/ethereum/go-ethereum/statediff/types"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
"github.com/ethereum/go-ethereum/statediff"
|
|
"github.com/ethereum/go-ethereum/statediff/test_helpers"
|
|
)
|
|
|
|
var (
|
|
contractLeafKey []byte
|
|
emptyDiffs = make([]types2.StateNode, 0)
|
|
emptyStorage = make([]types2.StorageNode, 0)
|
|
block0, block1, block2, block3, block4, block5, block6 *types.Block
|
|
builder statediff.Builder
|
|
minerAddress = common.HexToAddress("0x0")
|
|
minerLeafKey = test_helpers.AddressToLeafKey(minerAddress)
|
|
|
|
slot0 = common.HexToHash("0")
|
|
slot1 = common.HexToHash("1")
|
|
slot2 = common.HexToHash("2")
|
|
slot3 = common.HexToHash("3")
|
|
|
|
slot0StorageKey = crypto.Keccak256Hash(slot0[:])
|
|
slot1StorageKey = crypto.Keccak256Hash(slot1[:])
|
|
slot2StorageKey = crypto.Keccak256Hash(slot2[:])
|
|
slot3StorageKey = crypto.Keccak256Hash(slot3[:])
|
|
|
|
slot0StorageValue = common.Hex2Bytes("94703c4b2bd70c169f5717101caee543299fc946c7") // prefixed AccountAddr1
|
|
slot1StorageValue = common.Hex2Bytes("01")
|
|
slot2StorageValue = common.Hex2Bytes("09")
|
|
slot3StorageValue = common.Hex2Bytes("03")
|
|
|
|
slot0StorageLeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("390decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563"),
|
|
slot0StorageValue,
|
|
})
|
|
slot1StorageLeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("310e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6"),
|
|
slot1StorageValue,
|
|
})
|
|
slot2StorageLeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("305787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace"),
|
|
slot2StorageValue,
|
|
})
|
|
slot3StorageLeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("32575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b"),
|
|
slot3StorageValue,
|
|
})
|
|
slot0StorageLeafRootNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("20290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563"),
|
|
slot0StorageValue,
|
|
})
|
|
|
|
contractAccountAtBlock2, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 1,
|
|
Balance: big.NewInt(0),
|
|
CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
|
|
Root: crypto.Keccak256Hash(block2StorageBranchRootNode),
|
|
})
|
|
contractAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"),
|
|
contractAccountAtBlock2,
|
|
})
|
|
contractAccountAtBlock3, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 1,
|
|
Balance: big.NewInt(0),
|
|
CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
|
|
Root: crypto.Keccak256Hash(block3StorageBranchRootNode),
|
|
})
|
|
contractAccountAtBlock3LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"),
|
|
contractAccountAtBlock3,
|
|
})
|
|
contractAccountAtBlock4, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 1,
|
|
Balance: big.NewInt(0),
|
|
CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
|
|
Root: crypto.Keccak256Hash(block4StorageBranchRootNode),
|
|
})
|
|
contractAccountAtBlock4LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"),
|
|
contractAccountAtBlock4,
|
|
})
|
|
contractAccountAtBlock5, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 1,
|
|
Balance: big.NewInt(0),
|
|
CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
|
|
Root: crypto.Keccak256Hash(slot0StorageLeafRootNode),
|
|
})
|
|
contractAccountAtBlock5LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"),
|
|
contractAccountAtBlock5,
|
|
})
|
|
|
|
minerAccountAtBlock1, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 0,
|
|
Balance: big.NewInt(2000002625000000000),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
minerAccountAtBlock1LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3380c7b7ae81a58eb98d9c78de4a1fd7fd9535fc953ed2be602daaa41767312a"),
|
|
minerAccountAtBlock1,
|
|
})
|
|
minerAccountAtBlock2, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 0,
|
|
Balance: big.NewInt(4000111203461610525),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
minerAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3380c7b7ae81a58eb98d9c78de4a1fd7fd9535fc953ed2be602daaa41767312a"),
|
|
minerAccountAtBlock2,
|
|
})
|
|
|
|
account1AtBlock1, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 0,
|
|
Balance: test_helpers.Block1Account1Balance,
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
account1AtBlock1LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
|
|
account1AtBlock1,
|
|
})
|
|
account1AtBlock2, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 2,
|
|
Balance: big.NewInt(999555797000009000),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
account1AtBlock2LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
|
|
account1AtBlock2,
|
|
})
|
|
account1AtBlock5, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 2,
|
|
Balance: big.NewInt(2999566008847709960),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
account1AtBlock5LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
|
|
account1AtBlock5,
|
|
})
|
|
account1AtBlock6, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 3,
|
|
Balance: big.NewInt(2999537516847709960),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
account1AtBlock6LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
|
|
account1AtBlock6,
|
|
})
|
|
|
|
account2AtBlock2, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 0,
|
|
Balance: big.NewInt(1000),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
account2AtBlock2LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"),
|
|
account2AtBlock2,
|
|
})
|
|
account2AtBlock3, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 0,
|
|
Balance: big.NewInt(2000013574009435976),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
account2AtBlock3LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"),
|
|
account2AtBlock3,
|
|
})
|
|
account2AtBlock4, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 0,
|
|
Balance: big.NewInt(4000048088163070348),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
account2AtBlock4LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"),
|
|
account2AtBlock4,
|
|
})
|
|
account2AtBlock6, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 0,
|
|
Balance: big.NewInt(6000063293259748636),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
account2AtBlock6LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"),
|
|
account2AtBlock6,
|
|
})
|
|
|
|
bankAccountAtBlock0, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 0,
|
|
Balance: big.NewInt(test_helpers.TestBankFunds.Int64()),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
bankAccountAtBlock0LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("2000bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
|
|
bankAccountAtBlock0,
|
|
})
|
|
|
|
block1BankBalance = big.NewInt(test_helpers.TestBankFunds.Int64() - test_helpers.BalanceChange10000 - test_helpers.GasFees)
|
|
bankAccountAtBlock1, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 1,
|
|
Balance: block1BankBalance,
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
bankAccountAtBlock1LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
|
|
bankAccountAtBlock1,
|
|
})
|
|
|
|
block2BankBalance = block1BankBalance.Int64() - test_helpers.BalanceChange1Ether - test_helpers.GasFees
|
|
bankAccountAtBlock2, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 2,
|
|
Balance: big.NewInt(block2BankBalance),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
bankAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
|
|
bankAccountAtBlock2,
|
|
})
|
|
bankAccountAtBlock3, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 3,
|
|
Balance: big.NewInt(999914255999990000),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
bankAccountAtBlock3LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
|
|
bankAccountAtBlock3,
|
|
})
|
|
bankAccountAtBlock4, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 6,
|
|
Balance: big.NewInt(999826859999990000),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
bankAccountAtBlock4LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
|
|
bankAccountAtBlock4,
|
|
})
|
|
bankAccountAtBlock5, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 7,
|
|
Balance: big.NewInt(999805027999990000),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
bankAccountAtBlock5LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
|
|
bankAccountAtBlock5,
|
|
})
|
|
|
|
block1BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
crypto.Keccak256(bankAccountAtBlock1LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(minerAccountAtBlock1LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(account1AtBlock1LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
})
|
|
block2BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
crypto.Keccak256(bankAccountAtBlock2LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(minerAccountAtBlock2LeafNode),
|
|
crypto.Keccak256(contractAccountAtBlock2LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(account2AtBlock2LeafNode),
|
|
[]byte{},
|
|
crypto.Keccak256(account1AtBlock2LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
})
|
|
block3BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
crypto.Keccak256(bankAccountAtBlock3LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(minerAccountAtBlock2LeafNode),
|
|
crypto.Keccak256(contractAccountAtBlock3LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(account2AtBlock3LeafNode),
|
|
[]byte{},
|
|
crypto.Keccak256(account1AtBlock2LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
})
|
|
block4BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
crypto.Keccak256(bankAccountAtBlock4LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(minerAccountAtBlock2LeafNode),
|
|
crypto.Keccak256(contractAccountAtBlock4LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(account2AtBlock4LeafNode),
|
|
[]byte{},
|
|
crypto.Keccak256(account1AtBlock2LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
})
|
|
block5BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
crypto.Keccak256(bankAccountAtBlock5LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(minerAccountAtBlock2LeafNode),
|
|
crypto.Keccak256(contractAccountAtBlock5LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(account2AtBlock4LeafNode),
|
|
[]byte{},
|
|
crypto.Keccak256(account1AtBlock5LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
})
|
|
block6BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
crypto.Keccak256(bankAccountAtBlock5LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(minerAccountAtBlock2LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(account2AtBlock6LeafNode),
|
|
[]byte{},
|
|
crypto.Keccak256(account1AtBlock6LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
})
|
|
|
|
block2StorageBranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(slot0StorageLeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(slot1StorageLeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
})
|
|
block3StorageBranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(slot0StorageLeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(slot1StorageLeafNode),
|
|
crypto.Keccak256(slot3StorageLeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
})
|
|
block4StorageBranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(slot0StorageLeafNode),
|
|
[]byte{},
|
|
crypto.Keccak256(slot2StorageLeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
})
|
|
)
|
|
|
|
func init() {
|
|
if os.Getenv("MODE") != "statediff" {
|
|
fmt.Println("Skipping statediff test")
|
|
os.Exit(0)
|
|
}
|
|
}
|
|
|
|
func TestBuilder(t *testing.T) {
|
|
blocks, chain := test_helpers.MakeChain(3, test_helpers.Genesis, test_helpers.TestChainGen)
|
|
contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
|
|
defer chain.Stop()
|
|
block0 = test_helpers.Genesis
|
|
block1 = blocks[0]
|
|
block2 = blocks[1]
|
|
block3 = blocks[2]
|
|
params := statediff.Params{}
|
|
builder = statediff.NewBuilder(chain.StateCache())
|
|
|
|
var tests = []struct {
|
|
name string
|
|
startingArguments statediff.Args
|
|
expected *types2.StateObject
|
|
}{
|
|
{
|
|
"testEmptyDiff",
|
|
statediff.Args{
|
|
OldStateRoot: block0.Root(),
|
|
NewStateRoot: block0.Root(),
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
Nodes: emptyDiffs,
|
|
},
|
|
},
|
|
{
|
|
"testBlock0",
|
|
//10000 transferred from testBankAddress to account1Addr
|
|
statediff.Args{
|
|
OldStateRoot: test_helpers.NullHash,
|
|
NewStateRoot: block0.Root(),
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock0LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock1",
|
|
//10000 transferred from testBankAddress to account1Addr
|
|
statediff.Args{
|
|
OldStateRoot: block0.Root(),
|
|
NewStateRoot: block1.Root(),
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock1LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x05'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: minerLeafKey,
|
|
NodeValue: minerAccountAtBlock1LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock1LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock2",
|
|
// 1000 transferred from testBankAddress to account1Addr
|
|
// 1000 transferred from account1Addr to account2Addr
|
|
// account1addr creates a new contract
|
|
statediff.Args{
|
|
OldStateRoot: block1.Root(),
|
|
NewStateRoot: block2.Root(),
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x05'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: minerLeafKey,
|
|
NodeValue: minerAccountAtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock2LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{'\x02'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot0StorageKey.Bytes(),
|
|
NodeValue: slot0StorageLeafNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x0b'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot1StorageKey.Bytes(),
|
|
NodeValue: slot1StorageLeafNode,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account2LeafKey,
|
|
NodeValue: account2AtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
CodeAndCodeHashes: []types2.CodeAndCodeHash{
|
|
{
|
|
Hash: test_helpers.CodeHash,
|
|
Code: test_helpers.ByteCodeAfterDeployment,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock3",
|
|
//the contract's storage is changed
|
|
//and the block is mined by account 2
|
|
statediff.Args{
|
|
OldStateRoot: block2.Root(),
|
|
NewStateRoot: block3.Root(),
|
|
BlockNumber: block3.Number(),
|
|
BlockHash: block3.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block3.Number(),
|
|
BlockHash: block3.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock3LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock3LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot3StorageKey.Bytes(),
|
|
NodeValue: slot3StorageLeafNode,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account2LeafKey,
|
|
NodeValue: account2AtBlock3LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
diff, err := builder.BuildStateDiffObject(test.startingArguments, params)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
sort.Slice(receivedStateDiffRlp, func(i, j int) bool { return receivedStateDiffRlp[i] < receivedStateDiffRlp[j] })
|
|
sort.Slice(expectedStateDiffRlp, func(i, j int) bool { return expectedStateDiffRlp[i] < expectedStateDiffRlp[j] })
|
|
if !bytes.Equal(receivedStateDiffRlp, expectedStateDiffRlp) {
|
|
t.Logf("Test failed: %s", test.name)
|
|
t.Errorf("actual state diff: %+v\nexpected state diff: %+v", diff, test.expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBuilderWithIntermediateNodes(t *testing.T) {
|
|
blocks, chain := test_helpers.MakeChain(3, test_helpers.Genesis, test_helpers.TestChainGen)
|
|
contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
|
|
defer chain.Stop()
|
|
block0 = test_helpers.Genesis
|
|
block1 = blocks[0]
|
|
block2 = blocks[1]
|
|
block3 = blocks[2]
|
|
blocks = append([]*types.Block{block0}, blocks...)
|
|
params := statediff.Params{
|
|
IntermediateStateNodes: true,
|
|
IntermediateStorageNodes: true,
|
|
}
|
|
builder = statediff.NewBuilder(chain.StateCache())
|
|
|
|
var tests = []struct {
|
|
name string
|
|
startingArguments statediff.Args
|
|
expected *types2.StateObject
|
|
}{
|
|
{
|
|
"testEmptyDiff",
|
|
statediff.Args{
|
|
OldStateRoot: block0.Root(),
|
|
NewStateRoot: block0.Root(),
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
Nodes: emptyDiffs,
|
|
},
|
|
},
|
|
{
|
|
"testBlock0",
|
|
//10000 transferred from testBankAddress to account1Addr
|
|
statediff.Args{
|
|
OldStateRoot: test_helpers.NullHash,
|
|
NewStateRoot: block0.Root(),
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock0LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock1",
|
|
//10000 transferred from testBankAddress to account1Addr
|
|
statediff.Args{
|
|
OldStateRoot: block0.Root(),
|
|
NewStateRoot: block1.Root(),
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block1BranchRootNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock1LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x05'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: minerLeafKey,
|
|
NodeValue: minerAccountAtBlock1LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock1LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock2",
|
|
// 1000 transferred from testBankAddress to account1Addr
|
|
// 1000 transferred from account1Addr to account2Addr
|
|
// account1addr creates a new contract
|
|
statediff.Args{
|
|
OldStateRoot: block1.Root(),
|
|
NewStateRoot: block2.Root(),
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block2BranchRootNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x05'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: minerLeafKey,
|
|
NodeValue: minerAccountAtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock2LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block2StorageBranchRootNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x02'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot0StorageKey.Bytes(),
|
|
NodeValue: slot0StorageLeafNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x0b'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot1StorageKey.Bytes(),
|
|
NodeValue: slot1StorageLeafNode,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account2LeafKey,
|
|
NodeValue: account2AtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
CodeAndCodeHashes: []types2.CodeAndCodeHash{
|
|
{
|
|
Hash: test_helpers.CodeHash,
|
|
Code: test_helpers.ByteCodeAfterDeployment,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock3",
|
|
//the contract's storage is changed
|
|
//and the block is mined by account 2
|
|
statediff.Args{
|
|
OldStateRoot: block2.Root(),
|
|
NewStateRoot: block3.Root(),
|
|
BlockNumber: block3.Number(),
|
|
BlockHash: block3.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block3.Number(),
|
|
BlockHash: block3.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block3BranchRootNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock3LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock3LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block3StorageBranchRootNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot3StorageKey.Bytes(),
|
|
NodeValue: slot3StorageLeafNode,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account2LeafKey,
|
|
NodeValue: account2AtBlock3LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for i, test := range tests {
|
|
diff, err := builder.BuildStateDiffObject(test.startingArguments, params)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
sort.Slice(receivedStateDiffRlp, func(i, j int) bool { return receivedStateDiffRlp[i] < receivedStateDiffRlp[j] })
|
|
sort.Slice(expectedStateDiffRlp, func(i, j int) bool { return expectedStateDiffRlp[i] < expectedStateDiffRlp[j] })
|
|
if !bytes.Equal(receivedStateDiffRlp, expectedStateDiffRlp) {
|
|
t.Logf("Test failed: %s", test.name)
|
|
t.Errorf("actual state diff: %+v\r\n\r\n\r\nexpected state diff: %+v", diff, test.expected)
|
|
}
|
|
// Let's also confirm that our root state nodes form the state root hash in the headers
|
|
if i > 0 {
|
|
block := blocks[i-1]
|
|
expectedStateRoot := block.Root()
|
|
for _, node := range test.expected.Nodes {
|
|
if bytes.Equal(node.Path, []byte{}) {
|
|
stateRoot := crypto.Keccak256Hash(node.NodeValue)
|
|
if !bytes.Equal(expectedStateRoot.Bytes(), stateRoot.Bytes()) {
|
|
t.Logf("Test failed: %s", test.name)
|
|
t.Errorf("actual stateroot: %x\r\nexpected stateroot: %x", stateRoot.Bytes(), expectedStateRoot.Bytes())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBuilderWithWatchedAddressList(t *testing.T) {
|
|
blocks, chain := test_helpers.MakeChain(3, test_helpers.Genesis, test_helpers.TestChainGen)
|
|
contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
|
|
defer chain.Stop()
|
|
block0 = test_helpers.Genesis
|
|
block1 = blocks[0]
|
|
block2 = blocks[1]
|
|
block3 = blocks[2]
|
|
params := statediff.Params{
|
|
WatchedAddresses: []common.Address{test_helpers.Account1Addr, test_helpers.ContractAddr},
|
|
}
|
|
builder = statediff.NewBuilder(chain.StateCache())
|
|
|
|
var tests = []struct {
|
|
name string
|
|
startingArguments statediff.Args
|
|
expected *types2.StateObject
|
|
}{
|
|
{
|
|
"testEmptyDiff",
|
|
statediff.Args{
|
|
OldStateRoot: block0.Root(),
|
|
NewStateRoot: block0.Root(),
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
Nodes: emptyDiffs,
|
|
},
|
|
},
|
|
{
|
|
"testBlock0",
|
|
//10000 transferred from testBankAddress to account1Addr
|
|
statediff.Args{
|
|
OldStateRoot: test_helpers.NullHash,
|
|
NewStateRoot: block0.Root(),
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
Nodes: emptyDiffs,
|
|
},
|
|
},
|
|
{
|
|
"testBlock1",
|
|
//10000 transferred from testBankAddress to account1Addr
|
|
statediff.Args{
|
|
OldStateRoot: block0.Root(),
|
|
NewStateRoot: block1.Root(),
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock1LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock2",
|
|
//1000 transferred from testBankAddress to account1Addr
|
|
//1000 transferred from account1Addr to account2Addr
|
|
statediff.Args{
|
|
OldStateRoot: block1.Root(),
|
|
NewStateRoot: block2.Root(),
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock2LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{'\x02'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot0StorageKey.Bytes(),
|
|
NodeValue: slot0StorageLeafNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x0b'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot1StorageKey.Bytes(),
|
|
NodeValue: slot1StorageLeafNode,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
CodeAndCodeHashes: []types2.CodeAndCodeHash{
|
|
{
|
|
Hash: test_helpers.CodeHash,
|
|
Code: test_helpers.ByteCodeAfterDeployment,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock3",
|
|
//the contract's storage is changed
|
|
//and the block is mined by account 2
|
|
statediff.Args{
|
|
OldStateRoot: block2.Root(),
|
|
NewStateRoot: block3.Root(),
|
|
BlockNumber: block3.Number(),
|
|
BlockHash: block3.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block3.Number(),
|
|
BlockHash: block3.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock3LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot3StorageKey.Bytes(),
|
|
NodeValue: slot3StorageLeafNode,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
diff, err := builder.BuildStateDiffObject(test.startingArguments, params)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
sort.Slice(receivedStateDiffRlp, func(i, j int) bool { return receivedStateDiffRlp[i] < receivedStateDiffRlp[j] })
|
|
sort.Slice(expectedStateDiffRlp, func(i, j int) bool { return expectedStateDiffRlp[i] < expectedStateDiffRlp[j] })
|
|
if !bytes.Equal(receivedStateDiffRlp, expectedStateDiffRlp) {
|
|
t.Logf("Test failed: %s", test.name)
|
|
t.Errorf("actual state diff: %+v\nexpected state diff: %+v", diff, test.expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBuilderWithWatchedAddressAndStorageKeyList(t *testing.T) {
|
|
blocks, chain := test_helpers.MakeChain(3, test_helpers.Genesis, test_helpers.TestChainGen)
|
|
contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
|
|
defer chain.Stop()
|
|
block0 = test_helpers.Genesis
|
|
block1 = blocks[0]
|
|
block2 = blocks[1]
|
|
block3 = blocks[2]
|
|
params := statediff.Params{
|
|
WatchedAddresses: []common.Address{test_helpers.Account1Addr, test_helpers.ContractAddr},
|
|
WatchedStorageSlots: []common.Hash{slot1StorageKey},
|
|
}
|
|
builder = statediff.NewBuilder(chain.StateCache())
|
|
|
|
var tests = []struct {
|
|
name string
|
|
startingArguments statediff.Args
|
|
expected *types2.StateObject
|
|
}{
|
|
{
|
|
"testEmptyDiff",
|
|
statediff.Args{
|
|
OldStateRoot: block0.Root(),
|
|
NewStateRoot: block0.Root(),
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
Nodes: emptyDiffs,
|
|
},
|
|
},
|
|
{
|
|
"testBlock0",
|
|
//10000 transferred from testBankAddress to account1Addr
|
|
statediff.Args{
|
|
OldStateRoot: test_helpers.NullHash,
|
|
NewStateRoot: block0.Root(),
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block0.Number(),
|
|
BlockHash: block0.Hash(),
|
|
Nodes: emptyDiffs,
|
|
},
|
|
},
|
|
{
|
|
"testBlock1",
|
|
//10000 transferred from testBankAddress to account1Addr
|
|
statediff.Args{
|
|
OldStateRoot: block0.Root(),
|
|
NewStateRoot: block1.Root(),
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock1LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock2",
|
|
//1000 transferred from testBankAddress to account1Addr
|
|
//1000 transferred from account1Addr to account2Addr
|
|
statediff.Args{
|
|
OldStateRoot: block1.Root(),
|
|
NewStateRoot: block2.Root(),
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock2LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{'\x0b'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot1StorageKey.Bytes(),
|
|
NodeValue: slot1StorageLeafNode,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
CodeAndCodeHashes: []types2.CodeAndCodeHash{
|
|
{
|
|
Hash: test_helpers.CodeHash,
|
|
Code: test_helpers.ByteCodeAfterDeployment,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock3",
|
|
//the contract's storage is changed
|
|
//and the block is mined by account 2
|
|
statediff.Args{
|
|
OldStateRoot: block2.Root(),
|
|
NewStateRoot: block3.Root(),
|
|
BlockNumber: block3.Number(),
|
|
BlockHash: block3.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block3.Number(),
|
|
BlockHash: block3.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock3LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
diff, err := builder.BuildStateDiffObject(test.startingArguments, params)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
sort.Slice(receivedStateDiffRlp, func(i, j int) bool { return receivedStateDiffRlp[i] < receivedStateDiffRlp[j] })
|
|
sort.Slice(expectedStateDiffRlp, func(i, j int) bool { return expectedStateDiffRlp[i] < expectedStateDiffRlp[j] })
|
|
if !bytes.Equal(receivedStateDiffRlp, expectedStateDiffRlp) {
|
|
t.Logf("Test failed: %s", test.name)
|
|
t.Errorf("actual state diff: %+v\nexpected state diff: %+v", diff, test.expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBuilderWithRemovedAccountAndStorage(t *testing.T) {
|
|
blocks, chain := test_helpers.MakeChain(6, test_helpers.Genesis, test_helpers.TestChainGen)
|
|
contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
|
|
defer chain.Stop()
|
|
block3 = blocks[2]
|
|
block4 = blocks[3]
|
|
block5 = blocks[4]
|
|
block6 = blocks[5]
|
|
params := statediff.Params{
|
|
IntermediateStateNodes: true,
|
|
IntermediateStorageNodes: true,
|
|
}
|
|
builder = statediff.NewBuilder(chain.StateCache())
|
|
|
|
var tests = []struct {
|
|
name string
|
|
startingArguments statediff.Args
|
|
expected *types2.StateObject
|
|
}{
|
|
// blocks 0-3 are the same as in TestBuilderWithIntermediateNodes
|
|
{
|
|
"testBlock4",
|
|
statediff.Args{
|
|
OldStateRoot: block3.Root(),
|
|
NewStateRoot: block4.Root(),
|
|
BlockNumber: block4.Number(),
|
|
BlockHash: block4.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block4.Number(),
|
|
BlockHash: block4.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block4BranchRootNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock4LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock4LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block4StorageBranchRootNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x04'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot2StorageKey.Bytes(),
|
|
NodeValue: slot2StorageLeafNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x0b'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: slot1StorageKey.Bytes(),
|
|
NodeValue: []byte{},
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: slot3StorageKey.Bytes(),
|
|
NodeValue: []byte{},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account2LeafKey,
|
|
NodeValue: account2AtBlock4LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock5",
|
|
statediff.Args{
|
|
OldStateRoot: block4.Root(),
|
|
NewStateRoot: block5.Root(),
|
|
BlockNumber: block5.Number(),
|
|
BlockHash: block5.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block5.Number(),
|
|
BlockHash: block5.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block5BranchRootNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock5LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock5LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Leaf,
|
|
NodeValue: slot0StorageLeafRootNode,
|
|
LeafKey: slot0StorageKey.Bytes(),
|
|
},
|
|
{
|
|
Path: []byte{'\x02'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: slot0StorageKey.Bytes(),
|
|
NodeValue: []byte{},
|
|
},
|
|
{
|
|
Path: []byte{'\x04'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: slot2StorageKey.Bytes(),
|
|
NodeValue: []byte{},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock5LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock6",
|
|
statediff.Args{
|
|
OldStateRoot: block5.Root(),
|
|
NewStateRoot: block6.Root(),
|
|
BlockNumber: block6.Number(),
|
|
BlockHash: block6.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block6.Number(),
|
|
BlockHash: block6.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block6BranchRootNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: []byte{},
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account2LeafKey,
|
|
NodeValue: account2AtBlock6LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock6LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
diff, err := builder.BuildStateDiffObject(test.startingArguments, params)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
sort.Slice(receivedStateDiffRlp, func(i, j int) bool { return receivedStateDiffRlp[i] < receivedStateDiffRlp[j] })
|
|
sort.Slice(expectedStateDiffRlp, func(i, j int) bool { return expectedStateDiffRlp[i] < expectedStateDiffRlp[j] })
|
|
if !bytes.Equal(receivedStateDiffRlp, expectedStateDiffRlp) {
|
|
t.Logf("Test failed: %s", test.name)
|
|
t.Errorf("actual state diff: %+v\r\n\r\n\r\nexpected state diff: %+v", diff, test.expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBuilderWithRemovedAccountAndStorageWithoutIntermediateNodes(t *testing.T) {
|
|
blocks, chain := test_helpers.MakeChain(6, test_helpers.Genesis, test_helpers.TestChainGen)
|
|
contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
|
|
defer chain.Stop()
|
|
block3 = blocks[2]
|
|
block4 = blocks[3]
|
|
block5 = blocks[4]
|
|
block6 = blocks[5]
|
|
params := statediff.Params{
|
|
IntermediateStateNodes: false,
|
|
IntermediateStorageNodes: false,
|
|
}
|
|
builder = statediff.NewBuilder(chain.StateCache())
|
|
|
|
var tests = []struct {
|
|
name string
|
|
startingArguments statediff.Args
|
|
expected *types2.StateObject
|
|
}{
|
|
// blocks 0-3 are the same as in TestBuilderWithIntermediateNodes
|
|
{
|
|
"testBlock4",
|
|
statediff.Args{
|
|
OldStateRoot: block3.Root(),
|
|
NewStateRoot: block4.Root(),
|
|
BlockNumber: block4.Number(),
|
|
BlockHash: block4.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block4.Number(),
|
|
BlockHash: block4.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock4LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock4LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{'\x04'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot2StorageKey.Bytes(),
|
|
NodeValue: slot2StorageLeafNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x0b'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: slot1StorageKey.Bytes(),
|
|
NodeValue: []byte{},
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: slot3StorageKey.Bytes(),
|
|
NodeValue: []byte{},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account2LeafKey,
|
|
NodeValue: account2AtBlock4LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock5",
|
|
statediff.Args{
|
|
OldStateRoot: block4.Root(),
|
|
NewStateRoot: block5.Root(),
|
|
BlockNumber: block5.Number(),
|
|
BlockHash: block5.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block5.Number(),
|
|
BlockHash: block5.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock5LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock5LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot0StorageKey.Bytes(),
|
|
NodeValue: slot0StorageLeafRootNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x02'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: slot0StorageKey.Bytes(),
|
|
NodeValue: []byte{},
|
|
},
|
|
{
|
|
Path: []byte{'\x04'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: slot2StorageKey.Bytes(),
|
|
NodeValue: []byte{},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock5LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock6",
|
|
statediff.Args{
|
|
OldStateRoot: block5.Root(),
|
|
NewStateRoot: block6.Root(),
|
|
BlockNumber: block6.Number(),
|
|
BlockHash: block6.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block6.Number(),
|
|
BlockHash: block6.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: []byte{},
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account2LeafKey,
|
|
NodeValue: account2AtBlock6LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock6LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
diff, err := builder.BuildStateDiffObject(test.startingArguments, params)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
sort.Slice(receivedStateDiffRlp, func(i, j int) bool { return receivedStateDiffRlp[i] < receivedStateDiffRlp[j] })
|
|
sort.Slice(expectedStateDiffRlp, func(i, j int) bool { return expectedStateDiffRlp[i] < expectedStateDiffRlp[j] })
|
|
if !bytes.Equal(receivedStateDiffRlp, expectedStateDiffRlp) {
|
|
t.Logf("Test failed: %s", test.name)
|
|
t.Errorf("actual state diff: %+v\r\n\r\n\r\nexpected state diff: %+v", diff, test.expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
var (
|
|
slot00StorageValue = common.Hex2Bytes("9471562b71999873db5b286df957af199ec94617f7") // prefixed TestBankAddress
|
|
|
|
slot00StorageLeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("390decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563"),
|
|
slot00StorageValue,
|
|
})
|
|
|
|
contractAccountAtBlock01, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 1,
|
|
Balance: big.NewInt(0),
|
|
CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
|
|
Root: crypto.Keccak256Hash(block01StorageBranchRootNode),
|
|
})
|
|
contractAccountAtBlock01LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("3cb2583748c26e89ef19c2a8529b05a270f735553b4d44b6f2a1894987a71c8b"),
|
|
contractAccountAtBlock01,
|
|
})
|
|
|
|
bankAccountAtBlock01, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 1,
|
|
Balance: big.NewInt(3999629697375000000),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
bankAccountAtBlock01LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
|
|
bankAccountAtBlock01,
|
|
})
|
|
bankAccountAtBlock02, _ = rlp.EncodeToBytes(types.StateAccount{
|
|
Nonce: 2,
|
|
Balance: big.NewInt(5999607323457344852),
|
|
CodeHash: test_helpers.NullCodeHash.Bytes(),
|
|
Root: test_helpers.EmptyContractRoot,
|
|
})
|
|
bankAccountAtBlock02LeafNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
common.Hex2Bytes("2000bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
|
|
bankAccountAtBlock02,
|
|
})
|
|
|
|
block01BranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
crypto.Keccak256Hash(bankAccountAtBlock01LeafNode),
|
|
crypto.Keccak256Hash(contractAccountAtBlock01LeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
})
|
|
|
|
block01StorageBranchRootNode, _ = rlp.EncodeToBytes([]interface{}{
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(slot00StorageLeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
crypto.Keccak256(slot1StorageLeafNode),
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
[]byte{},
|
|
})
|
|
)
|
|
|
|
func TestBuilderWithMovedAccount(t *testing.T) {
|
|
blocks, chain := test_helpers.MakeChain(2, test_helpers.Genesis, test_helpers.TestSelfDestructChainGen)
|
|
contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
|
|
defer chain.Stop()
|
|
block0 = test_helpers.Genesis
|
|
block1 = blocks[0]
|
|
block2 = blocks[1]
|
|
params := statediff.Params{
|
|
IntermediateStateNodes: true,
|
|
IntermediateStorageNodes: true,
|
|
}
|
|
builder = statediff.NewBuilder(chain.StateCache())
|
|
|
|
var tests = []struct {
|
|
name string
|
|
startingArguments statediff.Args
|
|
expected *types2.StateObject
|
|
}{
|
|
{
|
|
"testBlock1",
|
|
statediff.Args{
|
|
OldStateRoot: block0.Root(),
|
|
NewStateRoot: block1.Root(),
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block01BranchRootNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock01LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x01'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock01LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block01StorageBranchRootNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x02'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot0StorageKey.Bytes(),
|
|
NodeValue: slot00StorageLeafNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x0b'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot1StorageKey.Bytes(),
|
|
NodeValue: slot1StorageLeafNode,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
CodeAndCodeHashes: []types2.CodeAndCodeHash{
|
|
{
|
|
Hash: test_helpers.CodeHash,
|
|
Code: test_helpers.ByteCodeAfterDeployment,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock2",
|
|
statediff.Args{
|
|
OldStateRoot: block1.Root(),
|
|
NewStateRoot: block2.Root(),
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock02LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x01'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: []byte{},
|
|
},
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: []byte{},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
diff, err := builder.BuildStateDiffObject(test.startingArguments, params)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
sort.Slice(receivedStateDiffRlp, func(i, j int) bool { return receivedStateDiffRlp[i] < receivedStateDiffRlp[j] })
|
|
sort.Slice(expectedStateDiffRlp, func(i, j int) bool { return expectedStateDiffRlp[i] < expectedStateDiffRlp[j] })
|
|
if !bytes.Equal(receivedStateDiffRlp, expectedStateDiffRlp) {
|
|
t.Logf("Test failed: %s", test.name)
|
|
t.Errorf("actual state diff: %+v\r\n\r\n\r\nexpected state diff: %+v", diff, test.expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBuilderWithMovedAccountOnlyLeafs(t *testing.T) {
|
|
blocks, chain := test_helpers.MakeChain(2, test_helpers.Genesis, test_helpers.TestSelfDestructChainGen)
|
|
contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
|
|
defer chain.Stop()
|
|
block0 = test_helpers.Genesis
|
|
block1 = blocks[0]
|
|
block2 = blocks[1]
|
|
params := statediff.Params{
|
|
IntermediateStateNodes: false,
|
|
IntermediateStorageNodes: false,
|
|
}
|
|
builder = statediff.NewBuilder(chain.StateCache())
|
|
|
|
var tests = []struct {
|
|
name string
|
|
startingArguments statediff.Args
|
|
expected *types2.StateObject
|
|
}{
|
|
{
|
|
"testBlock1",
|
|
statediff.Args{
|
|
OldStateRoot: block0.Root(),
|
|
NewStateRoot: block1.Root(),
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock01LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x01'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock01LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{'\x02'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot0StorageKey.Bytes(),
|
|
NodeValue: slot00StorageLeafNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x0b'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot1StorageKey.Bytes(),
|
|
NodeValue: slot1StorageLeafNode,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
CodeAndCodeHashes: []types2.CodeAndCodeHash{
|
|
{
|
|
Hash: test_helpers.CodeHash,
|
|
Code: test_helpers.ByteCodeAfterDeployment,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock2",
|
|
statediff.Args{
|
|
OldStateRoot: block1.Root(),
|
|
NewStateRoot: block2.Root(),
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
},
|
|
&types2.StateObject{
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock02LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x01'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: []byte{},
|
|
},
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Removed,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: []byte{},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
diff, err := builder.BuildStateDiffObject(test.startingArguments, params)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
receivedStateDiffRlp, err := rlp.EncodeToBytes(diff)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
expectedStateDiffRlp, err := rlp.EncodeToBytes(test.expected)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
sort.Slice(receivedStateDiffRlp, func(i, j int) bool { return receivedStateDiffRlp[i] < receivedStateDiffRlp[j] })
|
|
sort.Slice(expectedStateDiffRlp, func(i, j int) bool { return expectedStateDiffRlp[i] < expectedStateDiffRlp[j] })
|
|
if !bytes.Equal(receivedStateDiffRlp, expectedStateDiffRlp) {
|
|
t.Logf("Test failed: %s", test.name)
|
|
t.Errorf("actual state diff: %+v\r\n\r\n\r\nexpected state diff: %+v", diff, test.expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBuildStateTrie(t *testing.T) {
|
|
blocks, chain := test_helpers.MakeChain(3, test_helpers.Genesis, test_helpers.TestChainGen)
|
|
contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
|
|
defer chain.Stop()
|
|
block1 = blocks[0]
|
|
block2 = blocks[1]
|
|
block3 = blocks[2]
|
|
builder = statediff.NewBuilder(chain.StateCache())
|
|
|
|
var tests = []struct {
|
|
name string
|
|
block *types.Block
|
|
expected *types2.StateObject
|
|
}{
|
|
{
|
|
"testBlock1",
|
|
block1,
|
|
&types2.StateObject{
|
|
BlockNumber: block1.Number(),
|
|
BlockHash: block1.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block1BranchRootNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock1LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x05'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: minerLeafKey,
|
|
NodeValue: minerAccountAtBlock1LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock1LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock2",
|
|
block2,
|
|
&types2.StateObject{
|
|
BlockNumber: block2.Number(),
|
|
BlockHash: block2.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block2BranchRootNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x05'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: minerLeafKey,
|
|
NodeValue: minerAccountAtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock2LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block2StorageBranchRootNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x02'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot0StorageKey.Bytes(),
|
|
NodeValue: slot0StorageLeafNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x0b'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot1StorageKey.Bytes(),
|
|
NodeValue: slot1StorageLeafNode,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account2LeafKey,
|
|
NodeValue: account2AtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
CodeAndCodeHashes: []types2.CodeAndCodeHash{
|
|
{
|
|
Hash: test_helpers.CodeHash,
|
|
Code: test_helpers.ByteCodeAfterDeployment,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"testBlock3",
|
|
block3,
|
|
&types2.StateObject{
|
|
BlockNumber: block3.Number(),
|
|
BlockHash: block3.Hash(),
|
|
Nodes: []types2.StateNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block3BranchRootNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x00'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.BankLeafKey,
|
|
NodeValue: bankAccountAtBlock3LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x05'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: minerLeafKey,
|
|
NodeValue: minerAccountAtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x0e'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account1LeafKey,
|
|
NodeValue: account1AtBlock2LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
{
|
|
Path: []byte{'\x06'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: contractLeafKey,
|
|
NodeValue: contractAccountAtBlock3LeafNode,
|
|
StorageNodes: []types2.StorageNode{
|
|
{
|
|
Path: []byte{},
|
|
NodeType: types2.Branch,
|
|
NodeValue: block3StorageBranchRootNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x02'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot0StorageKey.Bytes(),
|
|
NodeValue: slot0StorageLeafNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x0b'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot1StorageKey.Bytes(),
|
|
NodeValue: slot1StorageLeafNode,
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: slot3StorageKey.Bytes(),
|
|
NodeValue: slot3StorageLeafNode,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Path: []byte{'\x0c'},
|
|
NodeType: types2.Leaf,
|
|
LeafKey: test_helpers.Account2LeafKey,
|
|
NodeValue: account2AtBlock3LeafNode,
|
|
StorageNodes: emptyStorage,
|
|
},
|
|
},
|
|
CodeAndCodeHashes: []types2.CodeAndCodeHash{
|
|
{
|
|
Hash: test_helpers.CodeHash,
|
|
Code: test_helpers.ByteCodeAfterDeployment,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
diff, err := builder.BuildStateTrieObject(test.block)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
receivedStateTrieRlp, err := rlp.EncodeToBytes(diff)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
expectedStateTrieRlp, err := rlp.EncodeToBytes(test.expected)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
sort.Slice(receivedStateTrieRlp, func(i, j int) bool { return receivedStateTrieRlp[i] < receivedStateTrieRlp[j] })
|
|
sort.Slice(expectedStateTrieRlp, func(i, j int) bool { return expectedStateTrieRlp[i] < expectedStateTrieRlp[j] })
|
|
if !bytes.Equal(receivedStateTrieRlp, expectedStateTrieRlp) {
|
|
t.Logf("Test failed: %s", test.name)
|
|
t.Errorf("actual state trie: %+v\r\n\r\n\r\nexpected state trie: %+v", diff, test.expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
pragma solidity ^0.5.10;
|
|
|
|
contract test {
|
|
address payable owner;
|
|
|
|
modifier onlyOwner {
|
|
require(
|
|
msg.sender == owner,
|
|
"Only owner can call this function."
|
|
);
|
|
_;
|
|
}
|
|
|
|
uint256[100] data;
|
|
|
|
constructor() public {
|
|
owner = msg.sender;
|
|
data = [1];
|
|
}
|
|
|
|
function Put(uint256 addr, uint256 value) public {
|
|
data[addr] = value;
|
|
}
|
|
|
|
function close() public onlyOwner { //onlyOwner is custom modifier
|
|
selfdestruct(owner); // `owner` is the owners address
|
|
}
|
|
}
|
|
*/
|