From 2ff4e950401baf0d74b2d610f575af3aed62ec7e Mon Sep 17 00:00:00 2001 From: i-norden Date: Sun, 9 Apr 2023 11:01:05 -0500 Subject: [PATCH 1/4] update pkgs to v5 --- pkg/api.go | 5 - pkg/builder.go | 31 +- pkg/builder_test.go | 3579 ++++++++++++++++++++++++------------------- pkg/helpers.go | 72 - pkg/rpc/check.go | 37 - pkg/service.go | 36 +- pkg/types.go | 14 - 7 files changed, 2055 insertions(+), 1719 deletions(-) delete mode 100644 pkg/helpers.go delete mode 100644 pkg/rpc/check.go diff --git a/pkg/api.go b/pkg/api.go index cf180d2..2e0b00a 100644 --- a/pkg/api.go +++ b/pkg/api.go @@ -45,11 +45,6 @@ func (api *PublicStateDiffAPI) StateDiffAt(ctx context.Context, blockNumber uint return api.sds.StateDiffAt(blockNumber, params) } -// StateTrieAt returns a state trie payload at the specific blockheight -func (api *PublicStateDiffAPI) StateTrieAt(ctx context.Context, blockNumber uint64, params sd.Params) (*sd.Payload, error) { - return api.sds.StateTrieAt(blockNumber, params) -} - // WriteStateDiffAt writes a state diff object directly to DB at the specific blockheight func (api *PublicStateDiffAPI) WriteStateDiffAt(ctx context.Context, blockNumber uint64, params sd.Params) error { return api.sds.WriteStateDiffAt(blockNumber, params) diff --git a/pkg/builder.go b/pkg/builder.go index 33fe5df..936ad45 100644 --- a/pkg/builder.go +++ b/pkg/builder.go @@ -55,24 +55,24 @@ func NewBuilder(stateCache state.Database, workers uint) (sd.Builder, error) { // BuildStateDiffObject builds a statediff object from two blocks and the provided parameters func (sdb *builder) BuildStateDiffObject(args sd.Args, params sd.Params) (sdtypes.StateObject, error) { - var stateNodes []sdtypes.StateNode - var codeAndCodeHashes []sdtypes.CodeAndCodeHash + var stateNodes []sdtypes.StateLeafNode + var codeAndCodeHashes []sdtypes.IPLD err := sdb.WriteStateDiffObject( args, - params, sd.StateNodeAppender(&stateNodes), sd.CodeMappingAppender(&codeAndCodeHashes)) + params, sd.StateNodeAppender(&stateNodes), sd.IPLDMappingAppender(&codeAndCodeHashes)) if err != nil { return sdtypes.StateObject{}, err } return sdtypes.StateObject{ - BlockHash: args.BlockHash, - BlockNumber: args.BlockNumber, - Nodes: stateNodes, - CodeAndCodeHashes: codeAndCodeHashes, + BlockHash: args.BlockHash, + BlockNumber: args.BlockNumber, + Nodes: stateNodes, + IPLDs: codeAndCodeHashes, }, nil } // WriteStateDiffObject writes a statediff object to output callback -func (sdb *builder) WriteStateDiffObject(args sd.Args, params sd.Params, output sdtypes.StateNodeSink, codeOutput sdtypes.CodeSink) error { +func (sdb *builder) WriteStateDiffObject(args sd.Args, params sd.Params, output sdtypes.StateNodeSink, codeOutput sdtypes.IPLDSink) error { // Load tries for old and new states oldTrie, err := sdb.StateCache.OpenTrie(args.OldStateRoot) if err != nil { @@ -101,12 +101,12 @@ func (sdb *builder) WriteStateDiffObject(args sd.Args, params sd.Params, output } // Dispatch workers to process trie data; sync and collect results here via channels - nodeChan := make(chan sdtypes.StateNode) - codeChan := make(chan sdtypes.CodeAndCodeHash) + nodeChan := make(chan sdtypes.StateLeafNode) + codeChan := make(chan sdtypes.IPLD) go func() { - nodeSender := func(node sdtypes.StateNode) error { nodeChan <- node; return nil } - codeSender := func(code sdtypes.CodeAndCodeHash) error { codeChan <- code; return nil } + nodeSender := func(node sdtypes.StateLeafNode) error { nodeChan <- node; return nil } + ipldSender := func(code sdtypes.IPLD) error { codeChan <- code; return nil } var wg sync.WaitGroup for w := uint(0); w < sdb.numWorkers; w++ { @@ -115,12 +115,7 @@ func (sdb *builder) WriteStateDiffObject(args sd.Args, params sd.Params, output defer wg.Done() var err error logger := log.New("hash", args.BlockHash.Hex(), "number", args.BlockNumber) - if !params.IntermediateStateNodes { - err = sdb.BuildStateDiffWithoutIntermediateStateNodes(iterPairs[worker], params, nodeSender, codeSender, logger) - } else { - err = sdb.BuildStateDiffWithIntermediateStateNodes(iterPairs[worker], params, nodeSender, codeSender, logger) - } - + err = sdb.BuildStateDiffWithIntermediateStateNodes(iterPairs[worker], params, nodeSender, ipldSender, logger) if err != nil { logrus.Errorf("buildStateDiff error for worker %d, params %+v", worker, params) } diff --git a/pkg/builder_test.go b/pkg/builder_test.go index b6843be..7221dac 100644 --- a/pkg/builder_test.go +++ b/pkg/builder_test.go @@ -18,7 +18,10 @@ package statediff_test import ( "bytes" + "encoding/json" + "fmt" "math/big" + "os" "sort" "testing" @@ -26,28 +29,26 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/rlp" - sd "github.com/ethereum/go-ethereum/statediff" + "github.com/ethereum/go-ethereum/statediff" + ipld2 "github.com/ethereum/go-ethereum/statediff/indexer/ipld" + "github.com/ethereum/go-ethereum/statediff/indexer/shared" "github.com/ethereum/go-ethereum/statediff/test_helpers" - sdtypes "github.com/ethereum/go-ethereum/statediff/types" - - pkg "github.com/cerc-io/eth-statediff-service/pkg" + types2 "github.com/ethereum/go-ethereum/statediff/types" ) var ( contractLeafKey []byte - emptyDiffs = make([]sdtypes.StateNode, 0) - emptyStorage = make([]sdtypes.StorageNode, 0) + emptyDiffs = make([]types2.StateLeafNode, 0) + emptyStorage = make([]types2.StorageLeafNode, 0) block0, block1, block2, block3, block4, block5, block6 *types.Block - builder sd.Builder - miningReward = int64(2000000000000000000) + builder statediff.Builder minerAddress = common.HexToAddress("0x0") minerLeafKey = test_helpers.AddressToLeafKey(minerAddress) - workerCounts = []uint{0, 1, 2, 4, 8} - slot0 = common.HexToHash("0") - slot1 = common.HexToHash("1") - slot2 = common.HexToHash("2") - slot3 = common.HexToHash("3") + slot0 = common.BigToHash(big.NewInt(0)) + slot1 = common.BigToHash(big.NewInt(1)) + slot2 = common.BigToHash(big.NewInt(2)) + slot3 = common.BigToHash(big.NewInt(3)) slot0StorageKey = crypto.Keccak256Hash(slot0[:]) slot1StorageKey = crypto.Keccak256Hash(slot1[:]) @@ -75,214 +76,230 @@ var ( common.Hex2Bytes("32575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b"), slot3StorageValue, }) - - contractAccountAtBlock2, _ = rlp.EncodeToBytes(&types.StateAccount{ + contractAccountAtBlock2 = &types.StateAccount{ Nonce: 1, Balance: big.NewInt(0), CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(), Root: crypto.Keccak256Hash(block2StorageBranchRootNode), - }) + } + contractAccountAtBlock2RLP, _ = rlp.EncodeToBytes(contractAccountAtBlock2) contractAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"), - contractAccountAtBlock2, + contractAccountAtBlock2RLP, }) - contractAccountAtBlock3, _ = rlp.EncodeToBytes(&types.StateAccount{ + contractAccountAtBlock3 = &types.StateAccount{ Nonce: 1, Balance: big.NewInt(0), CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(), Root: crypto.Keccak256Hash(block3StorageBranchRootNode), - }) + } + contractAccountAtBlock3RLP, _ = rlp.EncodeToBytes(contractAccountAtBlock3) contractAccountAtBlock3LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"), - contractAccountAtBlock3, + contractAccountAtBlock3RLP, }) - contractAccountAtBlock4, _ = rlp.EncodeToBytes(&types.StateAccount{ + contractAccountAtBlock4 = &types.StateAccount{ Nonce: 1, Balance: big.NewInt(0), CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(), Root: crypto.Keccak256Hash(block4StorageBranchRootNode), - }) + } + contractAccountAtBlock4RLP, _ = rlp.EncodeToBytes(contractAccountAtBlock4) contractAccountAtBlock4LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"), - contractAccountAtBlock4, + contractAccountAtBlock4RLP, }) - contractAccountAtBlock5, _ = rlp.EncodeToBytes(&types.StateAccount{ + contractAccountAtBlock5 = &types.StateAccount{ Nonce: 1, Balance: big.NewInt(0), CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(), Root: crypto.Keccak256Hash(block5StorageBranchRootNode), - }) + } + contractAccountAtBlock5RLP, _ = rlp.EncodeToBytes(contractAccountAtBlock5) contractAccountAtBlock5LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"), - contractAccountAtBlock5, + contractAccountAtBlock5RLP, }) - - minerAccountAtBlock1, _ = rlp.EncodeToBytes(&types.StateAccount{ + minerAccountAtBlock1 = &types.StateAccount{ Nonce: 0, Balance: big.NewInt(2000002625000000000), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + minerAccountAtBlock1RLP, _ = rlp.EncodeToBytes(minerAccountAtBlock1) minerAccountAtBlock1LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3380c7b7ae81a58eb98d9c78de4a1fd7fd9535fc953ed2be602daaa41767312a"), - minerAccountAtBlock1, + minerAccountAtBlock1RLP, }) - minerAccountAtBlock2, _ = rlp.EncodeToBytes(&types.StateAccount{ + minerAccountAtBlock2 = &types.StateAccount{ Nonce: 0, Balance: big.NewInt(4000111203461610525), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + minerAccountAtBlock2RLP, _ = rlp.EncodeToBytes(minerAccountAtBlock2) minerAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3380c7b7ae81a58eb98d9c78de4a1fd7fd9535fc953ed2be602daaa41767312a"), - minerAccountAtBlock2, + minerAccountAtBlock2RLP, }) - account1AtBlock1, _ = rlp.EncodeToBytes(&types.StateAccount{ + account1AtBlock1 = &types.StateAccount{ Nonce: 0, Balance: test_helpers.Block1Account1Balance, CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + account1AtBlock1RLP, _ = rlp.EncodeToBytes(account1AtBlock1) account1AtBlock1LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"), - account1AtBlock1, + account1AtBlock1RLP, }) - account1AtBlock2, _ = rlp.EncodeToBytes(&types.StateAccount{ + account1AtBlock2 = &types.StateAccount{ Nonce: 2, Balance: big.NewInt(999555797000009000), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + account1AtBlock2RLP, _ = rlp.EncodeToBytes(account1AtBlock2) account1AtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"), - account1AtBlock2, + account1AtBlock2RLP, }) - account1AtBlock5, _ = rlp.EncodeToBytes(&types.StateAccount{ + account1AtBlock5 = &types.StateAccount{ Nonce: 2, Balance: big.NewInt(2999586469962854280), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + account1AtBlock5RLP, _ = rlp.EncodeToBytes(account1AtBlock5) account1AtBlock5LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"), - account1AtBlock5, + account1AtBlock5RLP, }) - account1AtBlock6, _ = rlp.EncodeToBytes(&types.StateAccount{ + account1AtBlock6 = &types.StateAccount{ Nonce: 3, Balance: big.NewInt(2999557977962854280), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + account1AtBlock6RLP, _ = rlp.EncodeToBytes(account1AtBlock6) account1AtBlock6LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"), - account1AtBlock6, + account1AtBlock6RLP, }) - - account2AtBlock2, _ = rlp.EncodeToBytes(&types.StateAccount{ + account2AtBlock2 = &types.StateAccount{ Nonce: 0, Balance: big.NewInt(1000), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + account2AtBlock2RLP, _ = rlp.EncodeToBytes(account2AtBlock2) account2AtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"), - account2AtBlock2, + account2AtBlock2RLP, }) - account2AtBlock3, _ = rlp.EncodeToBytes(&types.StateAccount{ + account2AtBlock3 = &types.StateAccount{ Nonce: 0, Balance: big.NewInt(2000013574009435976), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + account2AtBlock3RLP, _ = rlp.EncodeToBytes(account2AtBlock3) account2AtBlock3LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"), - account2AtBlock3, + account2AtBlock3RLP, }) - account2AtBlock4, _ = rlp.EncodeToBytes(&types.StateAccount{ + account2AtBlock4 = &types.StateAccount{ Nonce: 0, Balance: big.NewInt(4000048088163070348), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + account2AtBlock4RLP, _ = rlp.EncodeToBytes(account2AtBlock4) account2AtBlock4LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"), - account2AtBlock4, + account2AtBlock4RLP, }) - account2AtBlock6, _ = rlp.EncodeToBytes(&types.StateAccount{ + account2AtBlock6 = &types.StateAccount{ Nonce: 0, Balance: big.NewInt(6000063258066544204), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + account2AtBlock6RLP, _ = rlp.EncodeToBytes(account2AtBlock6) account2AtBlock6LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"), - account2AtBlock6, + account2AtBlock6RLP, }) - - bankAccountAtBlock0, _ = rlp.EncodeToBytes(&types.StateAccount{ + bankAccountAtBlock0 = &types.StateAccount{ Nonce: 0, Balance: big.NewInt(test_helpers.TestBankFunds.Int64()), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + bankAccountAtBlock0RLP, _ = rlp.EncodeToBytes(bankAccountAtBlock0) bankAccountAtBlock0LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("2000bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"), - bankAccountAtBlock0, + bankAccountAtBlock0RLP, }) - block1BankBalance = big.NewInt(test_helpers.TestBankFunds.Int64() - test_helpers.BalanceChange10000 - test_helpers.GasFees) - bankAccountAtBlock1, _ = rlp.EncodeToBytes(&types.StateAccount{ + block1BankBalance = big.NewInt(test_helpers.TestBankFunds.Int64() - test_helpers.BalanceChange10000 - test_helpers.GasFees) + bankAccountAtBlock1 = &types.StateAccount{ Nonce: 1, Balance: block1BankBalance, CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + bankAccountAtBlock1RLP, _ = rlp.EncodeToBytes(bankAccountAtBlock1) bankAccountAtBlock1LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"), - bankAccountAtBlock1, + bankAccountAtBlock1RLP, }) - block2BankBalance = block1BankBalance.Int64() - test_helpers.BalanceChange1Ether - test_helpers.GasFees - bankAccountAtBlock2, _ = rlp.EncodeToBytes(&types.StateAccount{ + block2BankBalance = block1BankBalance.Int64() - test_helpers.BalanceChange1Ether - test_helpers.GasFees + bankAccountAtBlock2 = &types.StateAccount{ Nonce: 2, Balance: big.NewInt(block2BankBalance), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + bankAccountAtBlock2RLP, _ = rlp.EncodeToBytes(bankAccountAtBlock2) bankAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"), - bankAccountAtBlock2, + bankAccountAtBlock2RLP, }) - bankAccountAtBlock3, _ = rlp.EncodeToBytes(&types.StateAccount{ + bankAccountAtBlock3 = &types.StateAccount{ Nonce: 3, Balance: big.NewInt(999914255999990000), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + bankAccountAtBlock3RLP, _ = rlp.EncodeToBytes(bankAccountAtBlock3) bankAccountAtBlock3LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"), - bankAccountAtBlock3, + bankAccountAtBlock3RLP, }) - bankAccountAtBlock4, _ = rlp.EncodeToBytes(&types.StateAccount{ + bankAccountAtBlock4 = &types.StateAccount{ Nonce: 6, Balance: big.NewInt(999826859999990000), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + bankAccountAtBlock4RLP, _ = rlp.EncodeToBytes(&bankAccountAtBlock4) bankAccountAtBlock4LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"), - bankAccountAtBlock4, + bankAccountAtBlock4RLP, }) - bankAccountAtBlock5, _ = rlp.EncodeToBytes(&types.StateAccount{ + bankAccountAtBlock5 = &types.StateAccount{ Nonce: 8, Balance: big.NewInt(999761283999990000), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + bankAccountAtBlock5RLP, _ = rlp.EncodeToBytes(bankAccountAtBlock5) bankAccountAtBlock5LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"), - bankAccountAtBlock5, + bankAccountAtBlock5RLP, }) block1BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{ @@ -478,6 +495,13 @@ var ( }) ) +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) @@ -486,22 +510,23 @@ func TestBuilder(t *testing.T) { block1 = blocks[0] block2 = blocks[1] block3 = blocks[2] - params := sd.Params{} + params := statediff.Params{} + builder = statediff.NewBuilder(chain.StateCache()) var tests = []struct { name string - startingArguments sd.Args - expected *sdtypes.StateObject + startingArguments statediff.Args + expected *types2.StateObject }{ { "testEmptyDiff", - sd.Args{ + statediff.Args{ OldStateRoot: block0.Root(), NewStateRoot: block0.Root(), BlockNumber: block0.Number(), BlockHash: block0.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block0.Number(), BlockHash: block0.Hash(), Nodes: emptyDiffs, @@ -510,22 +535,33 @@ func TestBuilder(t *testing.T) { { "testBlock0", //10000 transferred from testBankAddress to account1Addr - sd.Args{ + statediff.Args{ OldStateRoot: test_helpers.NullHash, NewStateRoot: block0.Root(), BlockNumber: block0.Number(), BlockHash: block0.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block0.Number(), BlockHash: block0.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock0LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: bankAccountAtBlock0, + LeafKey: test_helpers.BankLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock0LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock0LeafNode)).String(), + Content: bankAccountAtBlock0LeafNode, }, }, }, @@ -533,36 +569,69 @@ func TestBuilder(t *testing.T) { { "testBlock1", //10000 transferred from testBankAddress to account1Addr - sd.Args{ + statediff.Args{ OldStateRoot: block0.Root(), NewStateRoot: block1.Root(), BlockNumber: block1.Number(), BlockHash: block1.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block1.Number(), BlockHash: block1.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock1LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: bankAccountAtBlock1, + LeafKey: test_helpers.BankLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock1LeafNode)).String()}, + StorageDiff: emptyStorage, }, { - Path: []byte{'\x05'}, - NodeType: sdtypes.Leaf, - LeafKey: minerLeafKey, - NodeValue: minerAccountAtBlock1LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: minerAccountAtBlock1, + LeafKey: minerLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock1LeafNode)).String()}, + StorageDiff: emptyStorage, }, { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock1LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account1AtBlock1, + LeafKey: test_helpers.Account1LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock1LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block1BranchRootNode)).String(), + Content: block1BranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock1LeafNode)).String(), + Content: bankAccountAtBlock1LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock1LeafNode)).String(), + Content: minerAccountAtBlock1LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock1LeafNode)).String(), + Content: account1AtBlock1LeafNode, }, }, }, @@ -572,69 +641,130 @@ func TestBuilder(t *testing.T) { // 1000 transferred from testBankAddress to account1Addr // 1000 transferred from account1Addr to account2Addr // account1addr creates a new contract - sd.Args{ + statediff.Args{ OldStateRoot: block1.Root(), NewStateRoot: block2.Root(), BlockNumber: block2.Number(), BlockHash: block2.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block2.Number(), BlockHash: block2.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock2LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: bankAccountAtBlock2, + LeafKey: test_helpers.BankLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock2LeafNode)).String()}, + StorageDiff: emptyStorage, }, { - Path: []byte{'\x05'}, - NodeType: sdtypes.Leaf, - LeafKey: minerLeafKey, - NodeValue: minerAccountAtBlock2LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: minerAccountAtBlock2, + LeafKey: minerLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock2LeafNode)).String()}, + StorageDiff: emptyStorage, }, { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock2LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account1AtBlock2, + LeafKey: test_helpers.Account1LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock2LeafNode)).String()}, + StorageDiff: emptyStorage, }, { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock2LeafNode, - StorageNodes: []sdtypes.StorageNode{ + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock2, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2LeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ { - Path: []byte{'\x02'}, - NodeType: sdtypes.Leaf, - LeafKey: slot0StorageKey.Bytes(), - NodeValue: slot0StorageLeafNode, + Removed: false, + Value: slot0StorageValue, + LeafKey: slot0StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(), }, { - Path: []byte{'\x0b'}, - NodeType: sdtypes.Leaf, - LeafKey: slot1StorageKey.Bytes(), - NodeValue: slot1StorageLeafNode, + Removed: false, + Value: slot1StorageValue, + LeafKey: slot1StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(), }, }, }, { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account2LeafKey, - NodeValue: account2AtBlock2LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account2AtBlock2, + LeafKey: test_helpers.Account2LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account2AtBlock2LeafNode)).String()}, + StorageDiff: emptyStorage, }, }, - CodeAndCodeHashes: []sdtypes.CodeAndCodeHash{ + IPLDs: []types2.IPLD{ { - Hash: test_helpers.CodeHash, - Code: test_helpers.ByteCodeAfterDeployment, + CID: ipld2.Keccak256ToCid(ipld2.RawBinary, test_helpers.CodeHash.Bytes()).String(), + Content: test_helpers.ByteCodeAfterDeployment, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block2BranchRootNode)).String(), + Content: block2BranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock2LeafNode)).String(), + Content: bankAccountAtBlock2LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock2LeafNode)).String(), + Content: minerAccountAtBlock2LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock2LeafNode)).String(), + Content: account1AtBlock2LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2LeafNode)).String(), + Content: contractAccountAtBlock2LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block2StorageBranchRootNode)).String(), + Content: block2StorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(), + Content: slot0StorageLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(), + Content: slot1StorageLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account2AtBlock2LeafNode)).String(), + Content: account2AtBlock2LeafNode, }, }, }, @@ -643,350 +773,130 @@ func TestBuilder(t *testing.T) { "testBlock3", //the contract's storage is changed //and the block is mined by account 2 - sd.Args{ + statediff.Args{ OldStateRoot: block2.Root(), NewStateRoot: block3.Root(), BlockNumber: block3.Number(), BlockHash: block3.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block3.Number(), BlockHash: block3.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock3LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: bankAccountAtBlock3, + LeafKey: test_helpers.BankLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock3LeafNode)).String()}, + StorageDiff: emptyStorage, }, { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock3LeafNode, - StorageNodes: []sdtypes.StorageNode{ + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock3, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3LeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: slot3StorageLeafNode, + Removed: false, + Value: slot3StorageValue, + LeafKey: slot3StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(), }, }, }, { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account2LeafKey, - NodeValue: account2AtBlock3LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account2AtBlock3, + LeafKey: test_helpers.Account2LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account2AtBlock3LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block3BranchRootNode)).String(), + Content: block3BranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock3LeafNode)).String(), + Content: bankAccountAtBlock3LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3LeafNode)).String(), + Content: contractAccountAtBlock3LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block3StorageBranchRootNode)).String(), + Content: block3StorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(), + Content: slot3StorageLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account2AtBlock3LeafNode)).String(), + Content: account2AtBlock3LeafNode, }, }, }, }, } - for _, workers := range workerCounts { - builder, _ = pkg.NewBuilder(chain.StateCache(), workers) - for _, test := range tests { - diff, err := builder.BuildStateDiffObject(test.startingArguments, params) + 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) { + actual, err := json.Marshal(diff) if err != nil { t.Error(err) } - receivedStateDiffRlp, err := rlp.EncodeToBytes(&diff) + expected, err := json.Marshal(test.expected) 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) - } + t.Logf("Test failed: %s", test.name) + t.Errorf("actual state diff: %s\r\n\r\n\r\nexpected state diff: %s", actual, 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 := sd.Params{ - IntermediateStateNodes: true, - IntermediateStorageNodes: true, + // Let's also confirm that our root state nodes form the state root hash in the headers + if !bytes.Equal(block0.Root().Bytes(), crypto.Keccak256(bankAccountAtBlock0LeafNode)) { + t.Errorf("block0 expected root %x does not match actual root %x", block0.Root().Bytes(), crypto.Keccak256(bankAccountAtBlock0LeafNode)) } - - var tests = []struct { - name string - startingArguments sd.Args - expected *sdtypes.StateObject - }{ - { - "testEmptyDiff", - sd.Args{ - OldStateRoot: block0.Root(), - NewStateRoot: block0.Root(), - BlockNumber: block0.Number(), - BlockHash: block0.Hash(), - }, - &sdtypes.StateObject{ - BlockNumber: block0.Number(), - BlockHash: block0.Hash(), - Nodes: emptyDiffs, - }, - }, - { - "testBlock0", - //10000 transferred from testBankAddress to account1Addr - sd.Args{ - OldStateRoot: test_helpers.NullHash, - NewStateRoot: block0.Root(), - BlockNumber: block0.Number(), - BlockHash: block0.Hash(), - }, - &sdtypes.StateObject{ - BlockNumber: block0.Number(), - BlockHash: block0.Hash(), - Nodes: []sdtypes.StateNode{ - { - Path: []byte{}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock0LeafNode, - StorageNodes: emptyStorage, - }, - }, - }, - }, - { - "testBlock1", - //10000 transferred from testBankAddress to account1Addr - sd.Args{ - OldStateRoot: block0.Root(), - NewStateRoot: block1.Root(), - BlockNumber: block1.Number(), - BlockHash: block1.Hash(), - }, - &sdtypes.StateObject{ - BlockNumber: block1.Number(), - BlockHash: block1.Hash(), - Nodes: []sdtypes.StateNode{ - { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block1BranchRootNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock1LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x05'}, - NodeType: sdtypes.Leaf, - LeafKey: minerLeafKey, - NodeValue: minerAccountAtBlock1LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x0e'}, - NodeType: sdtypes.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 - sd.Args{ - OldStateRoot: block1.Root(), - NewStateRoot: block2.Root(), - BlockNumber: block2.Number(), - BlockHash: block2.Hash(), - }, - &sdtypes.StateObject{ - BlockNumber: block2.Number(), - BlockHash: block2.Hash(), - Nodes: []sdtypes.StateNode{ - { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block2BranchRootNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock2LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x05'}, - NodeType: sdtypes.Leaf, - LeafKey: minerLeafKey, - NodeValue: minerAccountAtBlock2LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock2LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock2LeafNode, - StorageNodes: []sdtypes.StorageNode{ - { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block2StorageBranchRootNode, - }, - { - Path: []byte{'\x02'}, - NodeType: sdtypes.Leaf, - LeafKey: slot0StorageKey.Bytes(), - NodeValue: slot0StorageLeafNode, - }, - { - Path: []byte{'\x0b'}, - NodeType: sdtypes.Leaf, - LeafKey: slot1StorageKey.Bytes(), - NodeValue: slot1StorageLeafNode, - }, - }, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account2LeafKey, - NodeValue: account2AtBlock2LeafNode, - StorageNodes: emptyStorage, - }, - }, - CodeAndCodeHashes: []sdtypes.CodeAndCodeHash{ - { - Hash: test_helpers.CodeHash, - Code: test_helpers.ByteCodeAfterDeployment, - }, - }, - }, - }, - { - "testBlock3", - //the contract's storage is changed - //and the block is mined by account 2 - sd.Args{ - OldStateRoot: block2.Root(), - NewStateRoot: block3.Root(), - BlockNumber: block3.Number(), - BlockHash: block3.Hash(), - }, - &sdtypes.StateObject{ - BlockNumber: block3.Number(), - BlockHash: block3.Hash(), - Nodes: []sdtypes.StateNode{ - { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block3BranchRootNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock3LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock3LeafNode, - StorageNodes: []sdtypes.StorageNode{ - { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block3StorageBranchRootNode, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: slot3StorageLeafNode, - }, - }, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account2LeafKey, - NodeValue: account2AtBlock3LeafNode, - StorageNodes: emptyStorage, - }, - }, - }, - }, + if !bytes.Equal(block1.Root().Bytes(), crypto.Keccak256(block1BranchRootNode)) { + t.Errorf("block1 expected root %x does not match actual root %x", block1.Root().Bytes(), crypto.Keccak256(block1BranchRootNode)) } - - for _, workers := range workerCounts { - builder, _ = pkg.NewBuilder(chain.StateCache(), workers) - 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()) - } - } - } - } - } + if !bytes.Equal(block2.Root().Bytes(), crypto.Keccak256(block2BranchRootNode)) { + t.Errorf("block2 expected root %x does not match actual root %x", block2.Root().Bytes(), crypto.Keccak256(block2BranchRootNode)) + } + if !bytes.Equal(block3.Root().Bytes(), crypto.Keccak256(block3BranchRootNode)) { + t.Errorf("block3 expected root %x does not match actual root %x", block3.Root().Bytes(), crypto.Keccak256(block3BranchRootNode)) } } @@ -998,27 +908,26 @@ func TestBuilderWithWatchedAddressList(t *testing.T) { block1 = blocks[0] block2 = blocks[1] block3 = blocks[2] - params := sd.Params{ - IntermediateStateNodes: true, - IntermediateStorageNodes: true, - WatchedAddresses: []common.Address{test_helpers.Account1Addr, test_helpers.ContractAddr}, + params := statediff.Params{ + WatchedAddresses: []common.Address{test_helpers.Account1Addr, test_helpers.ContractAddr}, } params.ComputeWatchedAddressesLeafPaths() + builder = statediff.NewBuilder(chain.StateCache()) var tests = []struct { name string - startingArguments sd.Args - expected *sdtypes.StateObject + startingArguments statediff.Args + expected *types2.StateObject }{ { "testEmptyDiff", - sd.Args{ + statediff.Args{ OldStateRoot: block0.Root(), NewStateRoot: block0.Root(), BlockNumber: block0.Number(), BlockHash: block0.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block0.Number(), BlockHash: block0.Hash(), Nodes: emptyDiffs, @@ -1027,13 +936,13 @@ func TestBuilderWithWatchedAddressList(t *testing.T) { { "testBlock0", //10000 transferred from testBankAddress to account1Addr - sd.Args{ + statediff.Args{ OldStateRoot: test_helpers.NullHash, NewStateRoot: block0.Root(), BlockNumber: block0.Number(), BlockHash: block0.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block0.Number(), BlockHash: block0.Hash(), Nodes: emptyDiffs, @@ -1042,28 +951,37 @@ func TestBuilderWithWatchedAddressList(t *testing.T) { { "testBlock1", //10000 transferred from testBankAddress to account1Addr - sd.Args{ + statediff.Args{ OldStateRoot: block0.Root(), NewStateRoot: block1.Root(), BlockNumber: block1.Number(), BlockHash: block1.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block1.Number(), BlockHash: block1.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block1BranchRootNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account1AtBlock1, + LeafKey: test_helpers.Account1LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock1LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block1BranchRootNode)).String(), + Content: block1BranchRootNode, }, { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock1LeafNode, - StorageNodes: emptyStorage, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock1LeafNode)).String(), + Content: account1AtBlock1LeafNode, }, }, }, @@ -1072,59 +990,82 @@ func TestBuilderWithWatchedAddressList(t *testing.T) { "testBlock2", //1000 transferred from testBankAddress to account1Addr //1000 transferred from account1Addr to account2Addr - sd.Args{ + statediff.Args{ OldStateRoot: block1.Root(), NewStateRoot: block2.Root(), BlockNumber: block2.Number(), BlockHash: block2.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block2.Number(), BlockHash: block2.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block2BranchRootNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock2LeafNode, - StorageNodes: []sdtypes.StorageNode{ + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock2, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2LeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block2StorageBranchRootNode, + Removed: false, + Value: slot0StorageValue, + LeafKey: slot0StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(), }, { - Path: []byte{'\x02'}, - NodeType: sdtypes.Leaf, - LeafKey: slot0StorageKey.Bytes(), - NodeValue: slot0StorageLeafNode, - }, - { - Path: []byte{'\x0b'}, - NodeType: sdtypes.Leaf, - LeafKey: slot1StorageKey.Bytes(), - NodeValue: slot1StorageLeafNode, + Removed: false, + Value: slot1StorageValue, + LeafKey: slot1StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(), }, }, }, { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock2LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account1AtBlock2, + LeafKey: test_helpers.Account1LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock2LeafNode)).String()}, + StorageDiff: emptyStorage, }, }, - CodeAndCodeHashes: []sdtypes.CodeAndCodeHash{ + IPLDs: []types2.IPLD{ { - Hash: test_helpers.CodeHash, - Code: test_helpers.ByteCodeAfterDeployment, + CID: ipld2.Keccak256ToCid(ipld2.RawBinary, test_helpers.CodeHash.Bytes()).String(), + Content: test_helpers.ByteCodeAfterDeployment, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block2BranchRootNode)).String(), + Content: block2BranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2LeafNode)).String(), + Content: contractAccountAtBlock2LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block2StorageBranchRootNode)).String(), + Content: block2StorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(), + Content: slot0StorageLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(), + Content: slot1StorageLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock2LeafNode)).String(), + Content: account1AtBlock2LeafNode, }, }, }, @@ -1133,68 +1074,98 @@ func TestBuilderWithWatchedAddressList(t *testing.T) { "testBlock3", //the contract's storage is changed //and the block is mined by account 2 - sd.Args{ + statediff.Args{ OldStateRoot: block2.Root(), NewStateRoot: block3.Root(), BlockNumber: block3.Number(), BlockHash: block3.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block3.Number(), BlockHash: block3.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block3BranchRootNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock3LeafNode, - StorageNodes: []sdtypes.StorageNode{ + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock3, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3LeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block3StorageBranchRootNode, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: slot3StorageLeafNode, + Removed: false, + Value: slot3StorageValue, + LeafKey: slot3StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(), }, }, }, }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block3BranchRootNode)).String(), + Content: block3BranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3LeafNode)).String(), + Content: contractAccountAtBlock3LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block3StorageBranchRootNode)).String(), + Content: block3StorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(), + Content: slot3StorageLeafNode, + }, + }, }, }, } - for _, workers := range workerCounts { - builder, _ = pkg.NewBuilder(chain.StateCache(), workers) - 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) - } + 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) { + actual, err := json.Marshal(diff) + if err != nil { + t.Error(err) + } + expected, err := json.Marshal(test.expected) + if err != nil { + t.Error(err) + } + t.Logf("Test failed: %s", test.name) + t.Errorf("actual state diff: %s\r\n\r\n\r\nexpected state diff: %s", actual, expected) + } + } + // Let's also confirm that our root state nodes form the state root hash in the headers + if !bytes.Equal(block0.Root().Bytes(), crypto.Keccak256(bankAccountAtBlock0LeafNode)) { + t.Errorf("block0 expected root %x does not match actual root %x", block0.Root().Bytes(), crypto.Keccak256(bankAccountAtBlock0LeafNode)) + } + if !bytes.Equal(block1.Root().Bytes(), crypto.Keccak256(block1BranchRootNode)) { + t.Errorf("block1 expected root %x does not match actual root %x", block1.Root().Bytes(), crypto.Keccak256(block1BranchRootNode)) + } + if !bytes.Equal(block2.Root().Bytes(), crypto.Keccak256(block2BranchRootNode)) { + t.Errorf("block2 expected root %x does not match actual root %x", block2.Root().Bytes(), crypto.Keccak256(block2BranchRootNode)) + } + if !bytes.Equal(block3.Root().Bytes(), crypto.Keccak256(block3BranchRootNode)) { + t.Errorf("block3 expected root %x does not match actual root %x", block3.Root().Bytes(), crypto.Keccak256(block3BranchRootNode)) } } @@ -1206,429 +1177,318 @@ func TestBuilderWithRemovedAccountAndStorage(t *testing.T) { block4 = blocks[3] block5 = blocks[4] block6 = blocks[5] - params := sd.Params{ - IntermediateStateNodes: true, - IntermediateStorageNodes: true, - } + params := statediff.Params{} + builder = statediff.NewBuilder(chain.StateCache()) var tests = []struct { name string - startingArguments sd.Args - expected *sdtypes.StateObject + startingArguments statediff.Args + expected *types2.StateObject }{ // blocks 0-3 are the same as in TestBuilderWithIntermediateNodes { "testBlock4", - sd.Args{ + statediff.Args{ OldStateRoot: block3.Root(), NewStateRoot: block4.Root(), BlockNumber: block4.Number(), BlockHash: block4.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block4.Number(), BlockHash: block4.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block4BranchRootNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: bankAccountAtBlock4, + LeafKey: test_helpers.BankLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock4LeafNode)).String()}, + StorageDiff: emptyStorage, }, { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock4LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock4LeafNode, - StorageNodes: []sdtypes.StorageNode{ + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock4, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock4LeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block4StorageBranchRootNode, + Removed: false, + Value: slot2StorageValue, + LeafKey: slot2StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot2StorageLeafNode)).String(), }, { - Path: []byte{'\x04'}, - NodeType: sdtypes.Leaf, - LeafKey: slot2StorageKey.Bytes(), - NodeValue: slot2StorageLeafNode, + Removed: true, + LeafKey: slot1StorageKey.Bytes(), + CID: shared.RemovedNodeStorageCID, + Value: []byte{}, }, { - Path: []byte{'\x0b'}, - NodeType: sdtypes.Removed, - LeafKey: slot1StorageKey.Bytes(), - NodeValue: []byte{}, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Removed, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: []byte{}, + Removed: true, + LeafKey: slot3StorageKey.Bytes(), + CID: shared.RemovedNodeStorageCID, + Value: []byte{}, }, }, }, { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account2LeafKey, - NodeValue: account2AtBlock4LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account2AtBlock4, + LeafKey: test_helpers.Account2LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account2AtBlock4LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block4BranchRootNode)).String(), + Content: block4BranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock4LeafNode)).String(), + Content: bankAccountAtBlock4LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock4LeafNode)).String(), + Content: contractAccountAtBlock4LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block4StorageBranchRootNode)).String(), + Content: block4StorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot2StorageLeafNode)).String(), + Content: slot2StorageLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account2AtBlock4LeafNode)).String(), + Content: account2AtBlock4LeafNode, }, }, }, }, { "testBlock5", - sd.Args{ + statediff.Args{ OldStateRoot: block4.Root(), NewStateRoot: block5.Root(), BlockNumber: block5.Number(), BlockHash: block5.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block5.Number(), BlockHash: block5.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block5BranchRootNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: bankAccountAtBlock5, + LeafKey: test_helpers.BankLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock5LeafNode)).String()}, + StorageDiff: emptyStorage, }, { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock5LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock5LeafNode, - StorageNodes: []sdtypes.StorageNode{ + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock5, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock5LeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block5StorageBranchRootNode, + Removed: false, + Value: slot3StorageValue, + LeafKey: slot3StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(), }, { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: slot3StorageLeafNode, - }, - { - Path: []byte{'\x04'}, - NodeType: sdtypes.Removed, - LeafKey: slot2StorageKey.Bytes(), - NodeValue: []byte{}, + Removed: true, + LeafKey: slot2StorageKey.Bytes(), + CID: shared.RemovedNodeStorageCID, + Value: []byte{}, }, }, }, { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock5LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account1AtBlock5, + LeafKey: test_helpers.Account1LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock5LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block5BranchRootNode)).String(), + Content: block5BranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock5LeafNode)).String(), + Content: bankAccountAtBlock5LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock5LeafNode)).String(), + Content: contractAccountAtBlock5LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block5StorageBranchRootNode)).String(), + Content: block5StorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(), + Content: slot3StorageLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock5LeafNode)).String(), + Content: account1AtBlock5LeafNode, }, }, }, }, { "testBlock6", - sd.Args{ + statediff.Args{ OldStateRoot: block5.Root(), NewStateRoot: block6.Root(), BlockNumber: block6.Number(), BlockHash: block6.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block6.Number(), BlockHash: block6.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block6BranchRootNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Removed, - LeafKey: contractLeafKey, - NodeValue: []byte{}, - StorageNodes: []sdtypes.StorageNode{ + Removed: true, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: nil, + LeafKey: contractLeafKey, + CID: shared.RemovedNodeStateCID}, + StorageDiff: []types2.StorageLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Removed, - NodeValue: []byte{}, + Removed: true, + LeafKey: slot0StorageKey.Bytes(), + CID: shared.RemovedNodeStorageCID, + Value: []byte{}, }, { - Path: []byte{'\x02'}, - NodeType: sdtypes.Removed, - LeafKey: slot0StorageKey.Bytes(), - NodeValue: []byte{}, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Removed, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: []byte{}, + Removed: true, + LeafKey: slot3StorageKey.Bytes(), + CID: shared.RemovedNodeStorageCID, + Value: []byte{}, }, }, }, { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account2LeafKey, - NodeValue: account2AtBlock6LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account2AtBlock6, + LeafKey: test_helpers.Account2LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account2AtBlock6LeafNode)).String()}, + StorageDiff: emptyStorage, }, { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock6LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account1AtBlock6, + LeafKey: test_helpers.Account1LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock6LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block6BranchRootNode)).String(), + Content: block6BranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account2AtBlock6LeafNode)).String(), + Content: account2AtBlock6LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock6LeafNode)).String(), + Content: account1AtBlock6LeafNode, }, }, }, }, } - for _, workers := range workerCounts { - builder, _ = pkg.NewBuilder(chain.StateCache(), workers) - for index, test := range tests { - if index != 1 { - continue - } - diff, err := builder.BuildStateDiffObject(test.startingArguments, params) + 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) { + actual, err := json.Marshal(diff) if err != nil { t.Error(err) } - receivedStateDiffRlp, err := rlp.EncodeToBytes(&diff) + expected, err := json.Marshal(test.expected) 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) - } + t.Logf("Test failed: %s", test.name) + t.Errorf("actual state diff: %s\r\n\r\n\r\nexpected state diff: %s", actual, 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 := sd.Params{ - IntermediateStateNodes: false, - IntermediateStorageNodes: false, + // Let's also confirm that our root state nodes form the state root hash in the headers + if !bytes.Equal(block4.Root().Bytes(), crypto.Keccak256(block4BranchRootNode)) { + t.Errorf("block4 expected root %x does not match actual root %x", block4.Root().Bytes(), crypto.Keccak256(block4BranchRootNode)) } - - var tests = []struct { - name string - startingArguments sd.Args - expected *sdtypes.StateObject - }{ - // blocks 0-3 are the same as in TestBuilderWithIntermediateNodes - { - "testBlock4", - sd.Args{ - OldStateRoot: block3.Root(), - NewStateRoot: block4.Root(), - BlockNumber: block4.Number(), - BlockHash: block4.Hash(), - }, - &sdtypes.StateObject{ - BlockNumber: block4.Number(), - BlockHash: block4.Hash(), - Nodes: []sdtypes.StateNode{ - { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock4LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock4LeafNode, - StorageNodes: []sdtypes.StorageNode{ - { - Path: []byte{'\x04'}, - NodeType: sdtypes.Leaf, - LeafKey: slot2StorageKey.Bytes(), - NodeValue: slot2StorageLeafNode, - }, - { - Path: []byte{'\x0b'}, - NodeType: sdtypes.Removed, - LeafKey: slot1StorageKey.Bytes(), - NodeValue: []byte{}, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Removed, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: []byte{}, - }, - }, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account2LeafKey, - NodeValue: account2AtBlock4LeafNode, - StorageNodes: emptyStorage, - }, - }, - }, - }, - { - "testBlock5", - sd.Args{ - OldStateRoot: block4.Root(), - NewStateRoot: block5.Root(), - BlockNumber: block5.Number(), - BlockHash: block5.Hash(), - }, - &sdtypes.StateObject{ - BlockNumber: block5.Number(), - BlockHash: block5.Hash(), - Nodes: []sdtypes.StateNode{ - { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock5LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock5LeafNode, - StorageNodes: []sdtypes.StorageNode{ - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: slot3StorageLeafNode, - }, - { - Path: []byte{'\x04'}, - NodeType: sdtypes.Removed, - LeafKey: slot2StorageKey.Bytes(), - NodeValue: []byte{}, - }, - }, - }, - { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock5LeafNode, - StorageNodes: emptyStorage, - }, - }, - }, - }, - { - "testBlock6", - sd.Args{ - OldStateRoot: block5.Root(), - NewStateRoot: block6.Root(), - BlockNumber: block6.Number(), - BlockHash: block6.Hash(), - }, - &sdtypes.StateObject{ - BlockNumber: block6.Number(), - BlockHash: block6.Hash(), - Nodes: []sdtypes.StateNode{ - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Removed, - LeafKey: contractLeafKey, - NodeValue: []byte{}, - StorageNodes: []sdtypes.StorageNode{ - { - Path: []byte{'\x02'}, - NodeType: sdtypes.Removed, - LeafKey: slot0StorageKey.Bytes(), - NodeValue: []byte{}, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Removed, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: []byte{}, - }, - }, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account2LeafKey, - NodeValue: account2AtBlock6LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock6LeafNode, - StorageNodes: emptyStorage, - }, - }, - }, - }, + if !bytes.Equal(block5.Root().Bytes(), crypto.Keccak256(block5BranchRootNode)) { + t.Errorf("block5 expected root %x does not match actual root %x", block5.Root().Bytes(), crypto.Keccak256(block5BranchRootNode)) } - - for _, workers := range workerCounts { - builder, _ = pkg.NewBuilder(chain.StateCache(), workers) - 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) - } - } + if !bytes.Equal(block6.Root().Bytes(), crypto.Keccak256(block6BranchRootNode)) { + t.Errorf("block6 expected root %x does not match actual root %x", block6.Root().Bytes(), crypto.Keccak256(block6BranchRootNode)) } } @@ -1640,133 +1500,185 @@ func TestBuilderWithRemovedNonWatchedAccount(t *testing.T) { block4 = blocks[3] block5 = blocks[4] block6 = blocks[5] - params := sd.Params{ - IntermediateStateNodes: true, - IntermediateStorageNodes: true, - WatchedAddresses: []common.Address{test_helpers.Account1Addr, test_helpers.Account2Addr}, + params := statediff.Params{ + WatchedAddresses: []common.Address{test_helpers.Account1Addr, test_helpers.Account2Addr}, } params.ComputeWatchedAddressesLeafPaths() + builder = statediff.NewBuilder(chain.StateCache()) var tests = []struct { name string - startingArguments sd.Args - expected *sdtypes.StateObject + startingArguments statediff.Args + expected *types2.StateObject }{ { "testBlock4", - sd.Args{ + statediff.Args{ OldStateRoot: block3.Root(), NewStateRoot: block4.Root(), BlockNumber: block4.Number(), BlockHash: block4.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block4.Number(), BlockHash: block4.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block4BranchRootNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account2AtBlock4, + LeafKey: test_helpers.Account2LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account2AtBlock4LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block4BranchRootNode)).String(), + Content: block4BranchRootNode, }, { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account2LeafKey, - NodeValue: account2AtBlock4LeafNode, - StorageNodes: emptyStorage, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account2AtBlock4LeafNode)).String(), + Content: account2AtBlock4LeafNode, }, }, }, }, { "testBlock5", - sd.Args{ + statediff.Args{ OldStateRoot: block4.Root(), NewStateRoot: block5.Root(), BlockNumber: block5.Number(), BlockHash: block5.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block5.Number(), BlockHash: block5.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block5BranchRootNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account1AtBlock5, + LeafKey: test_helpers.Account1LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock5LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block5BranchRootNode)).String(), + Content: block5BranchRootNode, }, { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock5LeafNode, - StorageNodes: emptyStorage, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock5LeafNode)).String(), + Content: account1AtBlock5LeafNode, }, }, }, }, { "testBlock6", - sd.Args{ + statediff.Args{ OldStateRoot: block5.Root(), NewStateRoot: block6.Root(), BlockNumber: block6.Number(), BlockHash: block6.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block6.Number(), BlockHash: block6.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block6BranchRootNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account2AtBlock6, + LeafKey: test_helpers.Account2LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account2AtBlock6LeafNode)).String()}, + StorageDiff: emptyStorage, }, { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account2LeafKey, - NodeValue: account2AtBlock6LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account1AtBlock6, + LeafKey: test_helpers.Account1LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock6LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block6BranchRootNode)).String(), + Content: block6BranchRootNode, }, { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock6LeafNode, - StorageNodes: emptyStorage, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account2AtBlock6LeafNode)).String(), + Content: account2AtBlock6LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock6LeafNode)).String(), + Content: account1AtBlock6LeafNode, }, }, }, }, } - for _, workers := range workerCounts { - builder, _ = pkg.NewBuilder(chain.StateCache(), workers) - 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) - } + 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) { + actual, err := json.Marshal(diff) + if err != nil { + t.Error(err) + } + expected, err := json.Marshal(test.expected) + if err != nil { + t.Error(err) + } + t.Logf("Test failed: %s", test.name) + t.Errorf("actual state diff: %s\r\n\r\n\r\nexpected state diff: %s", actual, expected) + } + } + // Let's also confirm that our root state nodes form the state root hash in the headers + if !bytes.Equal(block4.Root().Bytes(), crypto.Keccak256(block4BranchRootNode)) { + t.Errorf("block4 expected root %x does not match actual root %x", block4.Root().Bytes(), crypto.Keccak256(block4BranchRootNode)) + } + if !bytes.Equal(block5.Root().Bytes(), crypto.Keccak256(block5BranchRootNode)) { + t.Errorf("block5 expected root %x does not match actual root %x", block5.Root().Bytes(), crypto.Keccak256(block5BranchRootNode)) + } + if !bytes.Equal(block6.Root().Bytes(), crypto.Keccak256(block6BranchRootNode)) { + t.Errorf("block6 expected root %x does not match actual root %x", block6.Root().Bytes(), crypto.Keccak256(block6BranchRootNode)) } } @@ -1778,200 +1690,258 @@ func TestBuilderWithRemovedWatchedAccount(t *testing.T) { block4 = blocks[3] block5 = blocks[4] block6 = blocks[5] - params := sd.Params{ - IntermediateStateNodes: true, - IntermediateStorageNodes: true, - WatchedAddresses: []common.Address{test_helpers.Account1Addr, test_helpers.ContractAddr}, + params := statediff.Params{ + WatchedAddresses: []common.Address{test_helpers.Account1Addr, test_helpers.ContractAddr}, } params.ComputeWatchedAddressesLeafPaths() + builder = statediff.NewBuilder(chain.StateCache()) var tests = []struct { name string - startingArguments sd.Args - expected *sdtypes.StateObject + startingArguments statediff.Args + expected *types2.StateObject }{ { "testBlock4", - sd.Args{ + statediff.Args{ OldStateRoot: block3.Root(), NewStateRoot: block4.Root(), BlockNumber: block4.Number(), BlockHash: block4.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block4.Number(), BlockHash: block4.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block4BranchRootNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock4LeafNode, - StorageNodes: []sdtypes.StorageNode{ + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock4, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock4LeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block4StorageBranchRootNode, + Removed: false, + LeafKey: slot2StorageKey.Bytes(), + Value: slot2StorageValue, + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot2StorageLeafNode)).String(), }, { - Path: []byte{'\x04'}, - NodeType: sdtypes.Leaf, - LeafKey: slot2StorageKey.Bytes(), - NodeValue: slot2StorageLeafNode, + Removed: true, + LeafKey: slot1StorageKey.Bytes(), + CID: shared.RemovedNodeStorageCID, + Value: []byte{}, }, { - Path: []byte{'\x0b'}, - NodeType: sdtypes.Removed, - LeafKey: slot1StorageKey.Bytes(), - NodeValue: []byte{}, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Removed, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: []byte{}, + Removed: true, + LeafKey: slot3StorageKey.Bytes(), + CID: shared.RemovedNodeStorageCID, + Value: []byte{}, }, }, }, }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block4BranchRootNode)).String(), + Content: block4BranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock4LeafNode)).String(), + Content: contractAccountAtBlock4LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block4StorageBranchRootNode)).String(), + Content: block4StorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot2StorageLeafNode)).String(), + Content: slot2StorageLeafNode, + }, + }, }, }, { "testBlock5", - sd.Args{ + statediff.Args{ OldStateRoot: block4.Root(), NewStateRoot: block5.Root(), BlockNumber: block5.Number(), BlockHash: block5.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block5.Number(), BlockHash: block5.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block5BranchRootNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock5LeafNode, - StorageNodes: []sdtypes.StorageNode{ + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock5, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock5LeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block5StorageBranchRootNode, + Removed: false, + LeafKey: slot3StorageKey.Bytes(), + Value: slot3StorageValue, + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(), }, { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: slot3StorageLeafNode, - }, - { - Path: []byte{'\x04'}, - NodeType: sdtypes.Removed, - LeafKey: slot2StorageKey.Bytes(), - NodeValue: []byte{}, + Removed: true, + LeafKey: slot2StorageKey.Bytes(), + CID: shared.RemovedNodeStorageCID, + Value: []byte{}, }, }, }, { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock5LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account1AtBlock5, + LeafKey: test_helpers.Account1LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock5LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block5BranchRootNode)).String(), + Content: block5BranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock5LeafNode)).String(), + Content: contractAccountAtBlock5LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block5StorageBranchRootNode)).String(), + Content: block5StorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(), + Content: slot3StorageLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock5LeafNode)).String(), + Content: account1AtBlock5LeafNode, }, }, }, }, { "testBlock6", - sd.Args{ + statediff.Args{ OldStateRoot: block5.Root(), NewStateRoot: block6.Root(), BlockNumber: block6.Number(), BlockHash: block6.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block6.Number(), BlockHash: block6.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block6BranchRootNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Removed, - LeafKey: contractLeafKey, - NodeValue: []byte{}, - StorageNodes: []sdtypes.StorageNode{ + Removed: true, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: nil, + LeafKey: contractLeafKey, + CID: shared.RemovedNodeStateCID}, + StorageDiff: []types2.StorageLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Removed, - NodeValue: []byte{}, + Removed: true, + LeafKey: slot0StorageKey.Bytes(), + CID: shared.RemovedNodeStorageCID, + Value: []byte{}, }, { - Path: []byte{'\x02'}, - NodeType: sdtypes.Removed, - LeafKey: slot0StorageKey.Bytes(), - NodeValue: []byte{}, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Removed, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: []byte{}, + Removed: true, + LeafKey: slot3StorageKey.Bytes(), + CID: shared.RemovedNodeStorageCID, + Value: []byte{}, }, }, }, { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock6LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account1AtBlock6, + LeafKey: test_helpers.Account1LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock6LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block6BranchRootNode)).String(), + Content: block6BranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock6LeafNode)).String(), + Content: account1AtBlock6LeafNode, }, }, }, }, } - for _, workers := range workerCounts { - builder, _ = pkg.NewBuilder(chain.StateCache(), workers) - 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) - } + 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) { + actual, err := json.Marshal(diff) + if err != nil { + t.Error(err) + } + expected, err := json.Marshal(test.expected) + if err != nil { + t.Error(err) + } + t.Logf("Test failed: %s", test.name) + t.Errorf("actual state diff: %s\r\n\r\n\r\nexpected state diff: %s", actual, expected) + } + } + // Let's also confirm that our root state nodes form the state root hash in the headers + if !bytes.Equal(block4.Root().Bytes(), crypto.Keccak256(block4BranchRootNode)) { + t.Errorf("block4 expected root %x does not match actual root %x", block4.Root().Bytes(), crypto.Keccak256(block4BranchRootNode)) + } + if !bytes.Equal(block5.Root().Bytes(), crypto.Keccak256(block5BranchRootNode)) { + t.Errorf("block5 expected root %x does not match actual root %x", block5.Root().Bytes(), crypto.Keccak256(block5BranchRootNode)) + } + if !bytes.Equal(block6.Root().Bytes(), crypto.Keccak256(block6BranchRootNode)) { + t.Errorf("block6 expected root %x does not match actual root %x", block6.Root().Bytes(), crypto.Keccak256(block6BranchRootNode)) } } @@ -1983,36 +1953,39 @@ var ( slot00StorageValue, }) - contractAccountAtBlock01, _ = rlp.EncodeToBytes(&types.StateAccount{ + contractAccountAtBlock01 = &types.StateAccount{ Nonce: 1, Balance: big.NewInt(0), CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(), Root: crypto.Keccak256Hash(block01StorageBranchRootNode), - }) + } + contractAccountAtBlock01RLP, _ = rlp.EncodeToBytes(contractAccountAtBlock01) contractAccountAtBlock01LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("3cb2583748c26e89ef19c2a8529b05a270f735553b4d44b6f2a1894987a71c8b"), - contractAccountAtBlock01, + contractAccountAtBlock01RLP, }) - bankAccountAtBlock01, _ = rlp.EncodeToBytes(&types.StateAccount{ + bankAccountAtBlock01 = &types.StateAccount{ Nonce: 1, Balance: big.NewInt(3999629697375000000), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + bankAccountAtBlock01RLP, _ = rlp.EncodeToBytes(bankAccountAtBlock01) bankAccountAtBlock01LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"), - bankAccountAtBlock01, + bankAccountAtBlock01RLP, }) - bankAccountAtBlock02, _ = rlp.EncodeToBytes(&types.StateAccount{ + bankAccountAtBlock02 = &types.StateAccount{ Nonce: 2, Balance: big.NewInt(5999607323457344852), CodeHash: test_helpers.NullCodeHash.Bytes(), Root: test_helpers.EmptyContractRoot, - }) + } + bankAccountAtBlock02RLP, _ = rlp.EncodeToBytes(bankAccountAtBlock02) bankAccountAtBlock02LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ common.Hex2Bytes("2000bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"), - bankAccountAtBlock02, + bankAccountAtBlock02RLP, }) block01BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{ @@ -2063,490 +2036,150 @@ func TestBuilderWithMovedAccount(t *testing.T) { block0 = test_helpers.Genesis block1 = blocks[0] block2 = blocks[1] - params := sd.Params{ - IntermediateStateNodes: true, - IntermediateStorageNodes: true, - } + params := statediff.Params{} + builder = statediff.NewBuilder(chain.StateCache()) var tests = []struct { name string - startingArguments sd.Args - expected *sdtypes.StateObject + startingArguments statediff.Args + expected *types2.StateObject }{ { "testBlock1", - sd.Args{ + statediff.Args{ OldStateRoot: block0.Root(), NewStateRoot: block1.Root(), BlockNumber: block1.Number(), BlockHash: block1.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block1.Number(), BlockHash: block1.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block01BranchRootNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: bankAccountAtBlock01, + LeafKey: test_helpers.BankLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock01LeafNode)).String()}, + StorageDiff: emptyStorage, }, { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock01LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x01'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock01LeafNode, - StorageNodes: []sdtypes.StorageNode{ + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock01, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock01LeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block01StorageBranchRootNode, + Removed: false, + LeafKey: slot0StorageKey.Bytes(), + Value: slot00StorageValue, + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot00StorageLeafNode)).String(), }, { - Path: []byte{'\x02'}, - NodeType: sdtypes.Leaf, - LeafKey: slot0StorageKey.Bytes(), - NodeValue: slot00StorageLeafNode, - }, - { - Path: []byte{'\x0b'}, - NodeType: sdtypes.Leaf, - LeafKey: slot1StorageKey.Bytes(), - NodeValue: slot1StorageLeafNode, + Removed: false, + LeafKey: slot1StorageKey.Bytes(), + Value: slot1StorageValue, + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(), }, }, }, }, - CodeAndCodeHashes: []sdtypes.CodeAndCodeHash{ + IPLDs: []types2.IPLD{ { - Hash: test_helpers.CodeHash, - Code: test_helpers.ByteCodeAfterDeployment, + CID: ipld2.Keccak256ToCid(ipld2.RawBinary, test_helpers.CodeHash.Bytes()).String(), + Content: test_helpers.ByteCodeAfterDeployment, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block01BranchRootNode)).String(), + Content: block01BranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock01LeafNode)).String(), + Content: bankAccountAtBlock01LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock01LeafNode)).String(), + Content: contractAccountAtBlock01LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block01StorageBranchRootNode)).String(), + Content: block01StorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot00StorageLeafNode)).String(), + Content: slot00StorageLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(), + Content: slot1StorageLeafNode, }, }, }, }, { "testBlock2", - sd.Args{ + statediff.Args{ OldStateRoot: block1.Root(), NewStateRoot: block2.Root(), BlockNumber: block2.Number(), BlockHash: block2.Hash(), }, - &sdtypes.StateObject{ + &types2.StateObject{ BlockNumber: block2.Number(), BlockHash: block2.Hash(), - Nodes: []sdtypes.StateNode{ + Nodes: []types2.StateLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock02LeafNode, - StorageNodes: emptyStorage, + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: bankAccountAtBlock02, + LeafKey: test_helpers.BankLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock02LeafNode)).String()}, + StorageDiff: emptyStorage, }, { - Path: []byte{'\x01'}, - NodeType: sdtypes.Removed, - LeafKey: contractLeafKey, - NodeValue: []byte{}, - StorageNodes: []sdtypes.StorageNode{ + Removed: true, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: nil, + LeafKey: contractLeafKey, + CID: shared.RemovedNodeStateCID}, + StorageDiff: []types2.StorageLeafNode{ { - Path: []byte{}, - NodeType: sdtypes.Removed, + Removed: true, + LeafKey: slot0StorageKey.Bytes(), + CID: shared.RemovedNodeStorageCID, + Value: []byte{}, }, { - Path: []byte{'\x02'}, - NodeType: sdtypes.Removed, - LeafKey: slot0StorageKey.Bytes(), - }, - { - Path: []byte{'\x0b'}, - NodeType: sdtypes.Removed, - LeafKey: slot1StorageKey.Bytes(), - }, - }, - }, - { - Path: []byte{'\x00'}, - NodeType: sdtypes.Removed, - NodeValue: []byte{}, - }, - }, - }, - }, - } - - for _, workers := range workerCounts { - builder, _ = pkg.NewBuilder(chain.StateCache(), workers) - 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 := sd.Params{ - IntermediateStateNodes: false, - IntermediateStorageNodes: false, - } - - var tests = []struct { - name string - startingArguments sd.Args - expected *sdtypes.StateObject - }{ - { - "testBlock1", - sd.Args{ - OldStateRoot: block0.Root(), - NewStateRoot: block1.Root(), - BlockNumber: block1.Number(), - BlockHash: block1.Hash(), - }, - &sdtypes.StateObject{ - BlockNumber: block1.Number(), - BlockHash: block1.Hash(), - Nodes: []sdtypes.StateNode{ - { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock01LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x01'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock01LeafNode, - StorageNodes: []sdtypes.StorageNode{ - { - Path: []byte{'\x02'}, - NodeType: sdtypes.Leaf, - LeafKey: slot0StorageKey.Bytes(), - NodeValue: slot00StorageLeafNode, - }, - { - Path: []byte{'\x0b'}, - NodeType: sdtypes.Leaf, - LeafKey: slot1StorageKey.Bytes(), - NodeValue: slot1StorageLeafNode, + Removed: true, + LeafKey: slot1StorageKey.Bytes(), + CID: shared.RemovedNodeStorageCID, + Value: []byte{}, }, }, }, }, - CodeAndCodeHashes: []sdtypes.CodeAndCodeHash{ + IPLDs: []types2.IPLD{ { - Hash: test_helpers.CodeHash, - Code: test_helpers.ByteCodeAfterDeployment, - }, - }, - }, - }, - { - "testBlock2", - sd.Args{ - OldStateRoot: block1.Root(), - NewStateRoot: block2.Root(), - BlockNumber: block2.Number(), - BlockHash: block2.Hash(), - }, - &sdtypes.StateObject{ - BlockNumber: block2.Number(), - BlockHash: block2.Hash(), - Nodes: []sdtypes.StateNode{ - { - Path: []byte{}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock02LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x01'}, - NodeType: sdtypes.Removed, - LeafKey: contractLeafKey, - NodeValue: []byte{}, - StorageNodes: []sdtypes.StorageNode{ - { - Path: []byte{'\x02'}, - NodeType: sdtypes.Removed, - LeafKey: slot0StorageKey.Bytes(), - }, - { - Path: []byte{'\x0b'}, - NodeType: sdtypes.Removed, - LeafKey: slot1StorageKey.Bytes(), - }, - }, - }, - { - Path: []byte{'\x00'}, - NodeType: sdtypes.Removed, - NodeValue: []byte{}, - }, - }, - }, - }, - } - - for _, workers := range workerCounts { - builder, _ = pkg.NewBuilder(chain.StateCache(), workers) - 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] - - var tests = []struct { - name string - block *types.Block - expected *sdtypes.StateObject - }{ - { - "testBlock1", - block1, - &sdtypes.StateObject{ - BlockNumber: block1.Number(), - BlockHash: block1.Hash(), - Nodes: []sdtypes.StateNode{ - { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block1BranchRootNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock1LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x05'}, - NodeType: sdtypes.Leaf, - LeafKey: minerLeafKey, - NodeValue: minerAccountAtBlock1LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock1LeafNode, - StorageNodes: emptyStorage, - }, - }, - }, - }, - { - "testBlock2", - block2, - &sdtypes.StateObject{ - BlockNumber: block2.Number(), - BlockHash: block2.Hash(), - Nodes: []sdtypes.StateNode{ - { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block2BranchRootNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock2LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x05'}, - NodeType: sdtypes.Leaf, - LeafKey: minerLeafKey, - NodeValue: minerAccountAtBlock2LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock2LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock2LeafNode, - StorageNodes: []sdtypes.StorageNode{ - { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block2StorageBranchRootNode, - }, - { - Path: []byte{'\x02'}, - NodeType: sdtypes.Leaf, - LeafKey: slot0StorageKey.Bytes(), - NodeValue: slot0StorageLeafNode, - }, - { - Path: []byte{'\x0b'}, - NodeType: sdtypes.Leaf, - LeafKey: slot1StorageKey.Bytes(), - NodeValue: slot1StorageLeafNode, - }, - }, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account2LeafKey, - NodeValue: account2AtBlock2LeafNode, - StorageNodes: emptyStorage, - }, - }, - CodeAndCodeHashes: []sdtypes.CodeAndCodeHash{ - { - Hash: test_helpers.CodeHash, - Code: test_helpers.ByteCodeAfterDeployment, - }, - }, - }, - }, - { - "testBlock3", - block3, - &sdtypes.StateObject{ - BlockNumber: block3.Number(), - BlockHash: block3.Hash(), - Nodes: []sdtypes.StateNode{ - { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block3BranchRootNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x00'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.BankLeafKey, - NodeValue: bankAccountAtBlock3LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x05'}, - NodeType: sdtypes.Leaf, - LeafKey: minerLeafKey, - NodeValue: minerAccountAtBlock2LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x0e'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account1LeafKey, - NodeValue: account1AtBlock2LeafNode, - StorageNodes: emptyStorage, - }, - { - Path: []byte{'\x06'}, - NodeType: sdtypes.Leaf, - LeafKey: contractLeafKey, - NodeValue: contractAccountAtBlock3LeafNode, - StorageNodes: []sdtypes.StorageNode{ - { - Path: []byte{}, - NodeType: sdtypes.Branch, - NodeValue: block3StorageBranchRootNode, - }, - { - Path: []byte{'\x02'}, - NodeType: sdtypes.Leaf, - LeafKey: slot0StorageKey.Bytes(), - NodeValue: slot0StorageLeafNode, - }, - { - Path: []byte{'\x0b'}, - NodeType: sdtypes.Leaf, - LeafKey: slot1StorageKey.Bytes(), - NodeValue: slot1StorageLeafNode, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: slot3StorageKey.Bytes(), - NodeValue: slot3StorageLeafNode, - }, - }, - }, - { - Path: []byte{'\x0c'}, - NodeType: sdtypes.Leaf, - LeafKey: test_helpers.Account2LeafKey, - NodeValue: account2AtBlock3LeafNode, - StorageNodes: emptyStorage, - }, - }, - CodeAndCodeHashes: []sdtypes.CodeAndCodeHash{ - { - Hash: test_helpers.CodeHash, - Code: test_helpers.ByteCodeAfterDeployment, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock02LeafNode)).String(), + Content: bankAccountAtBlock02LeafNode, }, }, }, @@ -2554,25 +2187,41 @@ func TestBuildStateTrie(t *testing.T) { } for _, test := range tests { - diff, err := builder.BuildStateTrieObject(test.block) + diff, err := builder.BuildStateDiffObject(test.startingArguments, params) if err != nil { t.Error(err) } - receivedStateTrieRlp, err := rlp.EncodeToBytes(&diff) + receivedStateDiffRlp, err := rlp.EncodeToBytes(&diff) if err != nil { t.Error(err) } - expectedStateTrieRlp, err := rlp.EncodeToBytes(test.expected) + expectedStateDiffRlp, 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) { + + 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) { + actual, err := json.Marshal(diff) + if err != nil { + t.Error(err) + } + expected, err := json.Marshal(test.expected) + if err != nil { + t.Error(err) + } 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) + t.Errorf("actual state diff: %s\r\n\r\n\r\nexpected state diff: %s", actual, expected) } } + // Let's also confirm that our root state nodes form the state root hash in the headers + if !bytes.Equal(block1.Root().Bytes(), crypto.Keccak256(block01BranchRootNode)) { + t.Errorf("block01 expected root %x does not match actual root %x", block1.Root().Bytes(), crypto.Keccak256(block01BranchRootNode)) + } + if !bytes.Equal(block2.Root().Bytes(), crypto.Keccak256(bankAccountAtBlock02LeafNode)) { + t.Errorf("block02 expected root %x does not match actual root %x", block2.Root().Bytes(), crypto.Keccak256(bankAccountAtBlock02LeafNode)) + } } /* @@ -2605,3 +2254,853 @@ contract test { } } */ + +var ( + b = big.NewInt(0).Sub(test_helpers.TestBIGBankFunds, test_helpers.BalanceChangeBIG) + block1BankBigBalance = big.NewInt(0).Sub(b, big.NewInt(test_helpers.GasFees2)) + bankAccountAtBlock1b = &types.StateAccount{ + Nonce: 1, + Balance: block1BankBigBalance, + CodeHash: test_helpers.NullCodeHash.Bytes(), + Root: test_helpers.EmptyContractRoot, + } + bankAccountAtBlock1bRLP, _ = rlp.EncodeToBytes(bankAccountAtBlock1b) + bankAccountAtBlock1bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ + common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"), + bankAccountAtBlock1bRLP, + }) + + account1AtBlock1b = &types.StateAccount{ + Nonce: 0, + Balance: test_helpers.Block1bAccount1Balance, + CodeHash: test_helpers.NullCodeHash.Bytes(), + Root: test_helpers.EmptyContractRoot, + } + account1AtBlock1bRLP, _ = rlp.EncodeToBytes(account1AtBlock1b) + account1AtBlock1bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ + common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"), + account1AtBlock1bRLP, + }) + + account1AtBlock2bBalance, _ = big.NewInt(0).SetString("1999999999999999999999999761539571000000000", 10) + account1AtBlock2b = &types.StateAccount{ + Nonce: 1, + Balance: account1AtBlock2bBalance, + CodeHash: test_helpers.NullCodeHash.Bytes(), + Root: test_helpers.EmptyContractRoot, + } + account1AtBlock2bRLP, _ = rlp.EncodeToBytes(account1AtBlock2b) + account1AtBlock2bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ + common.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"), + account1AtBlock2bRLP, + }) + + minerAccountAtBlock2b = &types.StateAccount{ + Nonce: 0, + Balance: big.NewInt(4055891787808414571), + CodeHash: test_helpers.NullCodeHash.Bytes(), + Root: test_helpers.EmptyContractRoot, + } + minerAccountAtBlock2bRLP, _ = rlp.EncodeToBytes(minerAccountAtBlock2b) + minerAccountAtBlock2bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ + common.Hex2Bytes("3380c7b7ae81a58eb98d9c78de4a1fd7fd9535fc953ed2be602daaa41767312a"), + minerAccountAtBlock2bRLP, + }) + + contractAccountAtBlock2b = &types.StateAccount{ + Nonce: 1, + Balance: big.NewInt(0), + CodeHash: test_helpers.CodeHashForInternalizedLeafNode.Bytes(), + Root: crypto.Keccak256Hash(block2StorageBranchRootNode), + } + contractAccountAtBlock2bRLP, _ = rlp.EncodeToBytes(contractAccountAtBlock2b) + contractAccountAtBlock2bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ + common.Hex2Bytes("3d7e14f1723fa19b5d6d9f8b86b49acefbc9c400bf4ed686c10d6b6467fc5b3a"), + contractAccountAtBlock2bRLP, + }) + + bankAccountAtBlock3bBalance, _ = big.NewInt(0).SetString("18000000000000000000000001999920365757724976", 10) + bankAccountAtBlock3b = &types.StateAccount{ + Nonce: 3, + Balance: bankAccountAtBlock3bBalance, + CodeHash: test_helpers.NullCodeHash.Bytes(), + Root: test_helpers.EmptyContractRoot, + } + bankAccountAtBlock3bRLP, _ = rlp.EncodeToBytes(bankAccountAtBlock3b) + bankAccountAtBlock3bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ + common.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"), + bankAccountAtBlock3bRLP, + }) + + contractAccountAtBlock3b = &types.StateAccount{ + Nonce: 1, + Balance: big.NewInt(0), + CodeHash: test_helpers.CodeHashForInternalizedLeafNode.Bytes(), + Root: crypto.Keccak256Hash(block3bStorageBranchRootNode), + } + contractAccountAtBlock3bRLP, _ = rlp.EncodeToBytes(contractAccountAtBlock3b) + contractAccountAtBlock3bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{ + common.Hex2Bytes("3d7e14f1723fa19b5d6d9f8b86b49acefbc9c400bf4ed686c10d6b6467fc5b3a"), + contractAccountAtBlock3bRLP, + }) + + slot40364 = common.BigToHash(big.NewInt(40364)) + slot105566 = common.BigToHash(big.NewInt(105566)) + + slot40364StorageValue = common.Hex2Bytes("01") + slot105566StorageValue = common.Hex2Bytes("02") + + slot40364StorageKey = crypto.Keccak256Hash(slot40364[:]) + slot105566StorageKey = crypto.Keccak256Hash(slot105566[:]) + + slot40364StorageInternalLeafNode = []interface{}{ + common.Hex2Bytes("3077bbc951a04529defc15da8c06e427cde0d7a1499c50975bbe8aab"), + slot40364StorageValue, + } + slot105566StorageInternalLeafNode = []interface{}{ + common.Hex2Bytes("3c62586c18bf1ecfda161ced374b7a894630e2db426814c24e5d42af"), + slot105566StorageValue, + } + + block3bStorageBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{ + []byte{}, + []byte{}, + crypto.Keccak256(slot0StorageLeafNode), + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + crypto.Keccak256(slot1StorageLeafNode), + []byte{}, + []byte{}, + []byte{}, + crypto.Keccak256(block3bStorageExtensionNode), + []byte{}, + }) + + block3bStorageExtensionNode, _ = rlp.EncodeToBytes(&[]interface{}{ + common.Hex2Bytes("1291631c"), + crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves), + }) + + block3bStorageBranchNodeWithInternalLeaves, _ = rlp.EncodeToBytes(&[]interface{}{ + slot105566StorageInternalLeafNode, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + slot40364StorageInternalLeafNode, + []byte{}, + []byte{}, + []byte{}, + }) + + block1bBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{ + crypto.Keccak256(bankAccountAtBlock1bLeafNode), + []byte{}, + []byte{}, + []byte{}, + []byte{}, + crypto.Keccak256(minerAccountAtBlock1LeafNode), + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + crypto.Keccak256(account1AtBlock1bLeafNode), + []byte{}, + []byte{}, + }) + + block2bBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{ + crypto.Keccak256(bankAccountAtBlock1bLeafNode), + []byte{}, + []byte{}, + []byte{}, + []byte{}, + crypto.Keccak256(minerAccountAtBlock2bLeafNode), + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + crypto.Keccak256(account1AtBlock2bLeafNode), + crypto.Keccak256(contractAccountAtBlock2bLeafNode), + []byte{}, + }) + + block3bBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{ + crypto.Keccak256(bankAccountAtBlock3bLeafNode), + []byte{}, + []byte{}, + []byte{}, + []byte{}, + crypto.Keccak256(minerAccountAtBlock2bLeafNode), + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + []byte{}, + crypto.Keccak256(account1AtBlock2bLeafNode), + crypto.Keccak256(contractAccountAtBlock3bLeafNode), + []byte{}, + }) +) + +func TestBuilderWithInternalizedLeafNode(t *testing.T) { + blocks, chain := test_helpers.MakeChain(3, test_helpers.GenesisForInternalLeafNodeTest, test_helpers.TestChainGenWithInternalLeafNode) + 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.StateLeafNode{ + { + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: bankAccountAtBlock0, + LeafKey: test_helpers.BankLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock0LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock0LeafNode)).String(), + Content: bankAccountAtBlock0LeafNode, + }, + }, + }, + }, + { + "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.StateLeafNode{ + { + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: bankAccountAtBlock1b, + LeafKey: test_helpers.BankLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock1bLeafNode)).String()}, + StorageDiff: emptyStorage, + }, + { + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: minerAccountAtBlock1, + LeafKey: minerLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock1LeafNode)).String()}, + StorageDiff: emptyStorage, + }, + { + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account1AtBlock1b, + LeafKey: test_helpers.Account1LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock1bLeafNode)).String()}, + StorageDiff: emptyStorage, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block1bBranchRootNode)).String(), + Content: block1bBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock1bLeafNode)).String(), + Content: bankAccountAtBlock1bLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock1LeafNode)).String(), + Content: minerAccountAtBlock1LeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock1bLeafNode)).String(), + Content: account1AtBlock1bLeafNode, + }, + }, + }, + }, + { + "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.StateLeafNode{ + { + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: minerAccountAtBlock2b, + LeafKey: minerLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock2bLeafNode)).String()}, + StorageDiff: emptyStorage, + }, + { + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: account1AtBlock2b, + LeafKey: test_helpers.Account1LeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock2bLeafNode)).String()}, + StorageDiff: emptyStorage, + }, + { + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock2b, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2bLeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ + { + Removed: false, + Value: slot0StorageValue, + LeafKey: slot0StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(), + }, + { + Removed: false, + Value: slot1StorageValue, + LeafKey: slot1StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(), + }, + }, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.RawBinary, test_helpers.CodeHashForInternalizedLeafNode.Bytes()).String(), + Content: test_helpers.ByteCodeAfterDeploymentForInternalLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block2bBranchRootNode)).String(), + Content: block2bBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock2bLeafNode)).String(), + Content: minerAccountAtBlock2bLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(account1AtBlock2bLeafNode)).String(), + Content: account1AtBlock2bLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2bLeafNode)).String(), + Content: contractAccountAtBlock2bLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block2StorageBranchRootNode)).String(), + Content: block2StorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(), + Content: slot0StorageLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(), + Content: slot1StorageLeafNode, + }, + }, + }, + }, + { + "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.StateLeafNode{ + { + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: bankAccountAtBlock3b, + LeafKey: test_helpers.BankLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock3bLeafNode)).String()}, + StorageDiff: emptyStorage, + }, + { + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock3b, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3bLeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ + { + Removed: false, + Value: slot105566StorageValue, + LeafKey: slot105566StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves)).String(), + }, + { + Removed: false, + Value: slot40364StorageValue, + LeafKey: slot40364StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves)).String(), + }, + }, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block3bBranchRootNode)).String(), + Content: block3bBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock3bLeafNode)).String(), + Content: bankAccountAtBlock3bLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3bLeafNode)).String(), + Content: contractAccountAtBlock3bLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchRootNode)).String(), + Content: block3bStorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block3bStorageExtensionNode)).String(), + Content: block3bStorageExtensionNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves)).String(), + Content: block3bStorageBranchNodeWithInternalLeaves, + }, + }, + }, + }, + } + + 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) { + actual, err := json.Marshal(diff) + if err != nil { + t.Error(err) + } + expected, err := json.Marshal(test.expected) + if err != nil { + t.Error(err) + } + t.Logf("Test failed: %s", test.name) + t.Errorf("actual state diff: %s\r\n\r\n\r\nexpected state diff: %s", actual, expected) + } + } + // Let's also confirm that our root state nodes form the state root hash in the headers + if !bytes.Equal(block1.Root().Bytes(), crypto.Keccak256(block1bBranchRootNode)) { + t.Errorf("block1 expected root %x does not match actual root %x", block1.Root().Bytes(), crypto.Keccak256(block1bBranchRootNode)) + } + if !bytes.Equal(block2.Root().Bytes(), crypto.Keccak256(block2bBranchRootNode)) { + t.Errorf("block2 expected root %x does not match actual root %x", block2.Root().Bytes(), crypto.Keccak256(block2bBranchRootNode)) + } + if !bytes.Equal(block3.Root().Bytes(), crypto.Keccak256(block3bBranchRootNode)) { + t.Errorf("block3 expected root %x does not match actual root %x", block3.Root().Bytes(), crypto.Keccak256(block3bBranchRootNode)) + } +} + +func TestBuilderWithInternalizedLeafNodeAndWatchedAddress(t *testing.T) { + blocks, chain := test_helpers.MakeChain(3, test_helpers.GenesisForInternalLeafNodeTest, test_helpers.TestChainGenWithInternalLeafNode) + 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.ContractAddr, + }, + } + params.ComputeWatchedAddressesLeafPaths() + 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.StateLeafNode{}, + IPLDs: []types2.IPLD{}, // there's some kind of weird behavior where if our root node is a leaf node + // even though it is along the path to the watched leaf (necessarily, as it is the root) it doesn't get included + // unconsequential, but kinda odd. + }, + }, + { + "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.StateLeafNode{}, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block1bBranchRootNode)).String(), + Content: block1bBranchRootNode, + }, + }, + }, + }, + { + "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.StateLeafNode{ + { + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock2b, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2bLeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ + { + Removed: false, + Value: slot0StorageValue, + LeafKey: slot0StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(), + }, + { + Removed: false, + Value: slot1StorageValue, + LeafKey: slot1StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(), + }, + }, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.RawBinary, test_helpers.CodeHashForInternalizedLeafNode.Bytes()).String(), + Content: test_helpers.ByteCodeAfterDeploymentForInternalLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block2bBranchRootNode)).String(), + Content: block2bBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2bLeafNode)).String(), + Content: contractAccountAtBlock2bLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block2StorageBranchRootNode)).String(), + Content: block2StorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(), + Content: slot0StorageLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(), + Content: slot1StorageLeafNode, + }, + }, + }, + }, + { + "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.StateLeafNode{ + { + Removed: false, + AccountWrapper: struct { + Account *types.StateAccount + LeafKey []byte + CID string + }{ + Account: contractAccountAtBlock3b, + LeafKey: contractLeafKey, + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3bLeafNode)).String()}, + StorageDiff: []types2.StorageLeafNode{ + { + Removed: false, + Value: slot105566StorageValue, + LeafKey: slot105566StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves)).String(), + }, + { + Removed: false, + Value: slot40364StorageValue, + LeafKey: slot40364StorageKey.Bytes(), + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves)).String(), + }, + }, + }, + }, + IPLDs: []types2.IPLD{ + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(block3bBranchRootNode)).String(), + Content: block3bBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3bLeafNode)).String(), + Content: contractAccountAtBlock3bLeafNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchRootNode)).String(), + Content: block3bStorageBranchRootNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block3bStorageExtensionNode)).String(), + Content: block3bStorageExtensionNode, + }, + { + CID: ipld2.Keccak256ToCid(ipld2.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves)).String(), + Content: block3bStorageBranchNodeWithInternalLeaves, + }, + }, + }, + }, + } + + 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) { + actual, err := json.Marshal(diff) + if err != nil { + t.Error(err) + } + expected, err := json.Marshal(test.expected) + if err != nil { + t.Error(err) + } + t.Logf("Test failed: %s", test.name) + t.Errorf("actual state diff: %s\r\n\r\n\r\nexpected state diff: %s", actual, expected) + } + } + // Let's also confirm that our root state nodes form the state root hash in the headers + if !bytes.Equal(block1.Root().Bytes(), crypto.Keccak256(block1bBranchRootNode)) { + t.Errorf("block1 expected root %x does not match actual root %x", block1.Root().Bytes(), crypto.Keccak256(block1bBranchRootNode)) + } + if !bytes.Equal(block2.Root().Bytes(), crypto.Keccak256(block2bBranchRootNode)) { + t.Errorf("block2 expected root %x does not match actual root %x", block2.Root().Bytes(), crypto.Keccak256(block2bBranchRootNode)) + } + if !bytes.Equal(block3.Root().Bytes(), crypto.Keccak256(block3bBranchRootNode)) { + t.Errorf("block3 expected root %x does not match actual root %x", block3.Root().Bytes(), crypto.Keccak256(block3bBranchRootNode)) + } +} + +/* +pragma solidity ^0.5.10; + +contract test { + address payable owner; + + modifier onlyOwner { + require( + msg.sender == owner, + "Only owner can call this function." + ); + _; + } + + uint256[105566] 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 + } +} +*/ diff --git a/pkg/helpers.go b/pkg/helpers.go deleted file mode 100644 index ae0d1b0..0000000 --- a/pkg/helpers.go +++ /dev/null @@ -1,72 +0,0 @@ -// 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 . - -// Contains a batch of utility type declarations used by the tests. As the node -// operates on unique types, a lot of them are needed to check various features. - -package statediff - -import ( - "sort" - "strings" -) - -func sortKeys(data AccountMap) []string { - keys := make([]string, 0, len(data)) - for key := range data { - keys = append(keys, key) - } - sort.Strings(keys) - - return keys -} - -// findIntersection finds the set of strings from both arrays that are equivalent -// a and b must first be sorted -// this is used to find which keys have been both "deleted" and "created" i.e. they were updated -func findIntersection(a, b []string) []string { - lenA := len(a) - lenB := len(b) - iOfA, iOfB := 0, 0 - updates := make([]string, 0) - if iOfA >= lenA || iOfB >= lenB { - return updates - } - for { - switch strings.Compare(a[iOfA], b[iOfB]) { - // -1 when a[iOfA] < b[iOfB] - case -1: - iOfA++ - if iOfA >= lenA { - return updates - } - // 0 when a[iOfA] == b[iOfB] - case 0: - updates = append(updates, a[iOfA]) - iOfA++ - iOfB++ - if iOfA >= lenA || iOfB >= lenB { - return updates - } - // 1 when a[iOfA] > b[iOfB] - case 1: - iOfB++ - if iOfB >= lenB { - return updates - } - } - } -} diff --git a/pkg/rpc/check.go b/pkg/rpc/check.go deleted file mode 100644 index 0921568..0000000 --- a/pkg/rpc/check.go +++ /dev/null @@ -1,37 +0,0 @@ -// VulcanizeDB -// Copyright © 2020 Vulcanize - -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Affero General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// This program 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 Affero General Public License for more details. - -// You should have received a copy of the GNU Affero General Public License -// along with this program. If not, see . - -package rpc - -import "github.com/ethereum/go-ethereum/rpc" - -// checkModuleAvailability check that all names given in modules are actually -// available API services. -func checkModuleAvailability(modules []string, apis []rpc.API) (bad, available []string) { - availableSet := make(map[string]struct{}) - for _, api := range apis { - if _, ok := availableSet[api.Namespace]; !ok { - availableSet[api.Namespace] = struct{}{} - available = append(available, api.Namespace) - } - } - for _, name := range modules { - if _, ok := availableSet[name]; !ok { - bad = append(bad, name) - } - } - return bad, available -} diff --git a/pkg/service.go b/pkg/service.go index b179001..bde2a9d 100644 --- a/pkg/service.go +++ b/pkg/service.go @@ -53,8 +53,6 @@ type StateDiffService interface { StateDiffAt(blockNumber uint64, params sd.Params) (*sd.Payload, error) // StateDiffFor method to get state diff object at specific block StateDiffFor(blockHash common.Hash, params sd.Params) (*sd.Payload, error) - // StateTrieAt method to get state trie object at specific block - StateTrieAt(blockNumber uint64, params sd.Params) (*sd.Payload, error) // WriteStateDiffAt method to write state diff object directly to DB WriteStateDiffAt(blockNumber uint64, params sd.Params) error // WriteStateDiffFor method to get state trie object at specific block @@ -344,34 +342,6 @@ func (sds *Service) newPayload(stateObject []byte, block *types.Block, params sd return payload, nil } -// StateTrieAt returns a state trie object payload at the specified blockheight -// This operation cannot be performed back past the point of db pruning; it requires an archival node for historical data -func (sds *Service) StateTrieAt(blockNumber uint64, params sd.Params) (*sd.Payload, error) { - currentBlock, err := sds.lvlDBReader.GetBlockByNumber(blockNumber) - if err != nil { - return nil, err - } - logrus.Infof("sending state trie at block %d", blockNumber) - - // compute leaf paths of watched addresses in the params - params.ComputeWatchedAddressesLeafPaths() - - return sds.processStateTrie(currentBlock, params) -} - -func (sds *Service) processStateTrie(block *types.Block, params sd.Params) (*sd.Payload, error) { - stateNodes, err := sds.Builder.BuildStateTrieObject(block) - if err != nil { - return nil, err - } - stateTrieRlp, err := rlp.EncodeToBytes(&stateNodes) - if err != nil { - return nil, err - } - logrus.Infof("state trie object at block %d is %d bytes in length", block.Number().Uint64(), len(stateTrieRlp)) - return sds.newPayload(stateTrieRlp, block, params) -} - // Start is used to begin the service func (sds *Service) Start() error { logrus.Info("starting statediff service") @@ -461,11 +431,11 @@ func (sds *Service) writeStateDiff(block *types.Block, parentRoot common.Hash, p return err } // defer handling of commit/rollback for any return case - output := func(node sdtypes.StateNode) error { + output := func(node sdtypes.StateLeafNode) error { return sds.indexer.PushStateNode(tx, node, block.Hash().String()) } - codeOutput := func(c sdtypes.CodeAndCodeHash) error { - return sds.indexer.PushCodeAndCodeHash(tx, c) + codeOutput := func(c sdtypes.IPLD) error { + return sds.indexer.PushIPLD(tx, c) } prom.SetTimeMetric(prom.T_BLOCK_PROCESSING, time.Now().Sub(t)) t = time.Now() diff --git a/pkg/types.go b/pkg/types.go index 3aad530..0a7e89e 100644 --- a/pkg/types.go +++ b/pkg/types.go @@ -20,23 +20,9 @@ package statediff import ( - "github.com/ethereum/go-ethereum/core/types" sd "github.com/ethereum/go-ethereum/statediff" - sdTypes "github.com/ethereum/go-ethereum/statediff/types" ) -// AccountMap is a mapping of hex encoded path => account wrapper -type AccountMap map[string]accountWrapper - -// accountWrapper is used to temporary associate the unpacked node with its raw values -type accountWrapper struct { - Account *types.StateAccount - NodeType sdTypes.NodeType - Path []byte - NodeValue []byte - LeafKey []byte -} - // RangeRequest holds range quest work params type RangeRequest struct { Start, Stop uint64 From f3379e33ddc4eda99edb22c34190d5c68cc04648 Mon Sep 17 00:00:00 2001 From: i-norden Date: Sun, 9 Apr 2023 11:01:12 -0500 Subject: [PATCH 2/4] update cmd to v5 --- cmd/env.go | 20 ++++++++------------ cmd/root.go | 4 ---- cmd/serve.go | 3 ++- cmd/util.go | 10 ++++------ 4 files changed, 14 insertions(+), 23 deletions(-) diff --git a/cmd/env.go b/cmd/env.go index 4fe244c..766378b 100644 --- a/cmd/env.go +++ b/cmd/env.go @@ -49,16 +49,14 @@ const ( PROM_HTTP_PORT = "PROM_HTTP_PORT" PROM_DB_STATS = "PROM_DB_STATS" - PRERUN_ONLY = "PRERUN_ONLY" - PRERUN_PARALLEL = "PRERUN_PARALLEL" - PRERUN_RANGE_START = "PRERUN_RANGE_START" - PRERUN_RANGE_STOP = "PRERUN_RANGE_STOP" - PRERUN_INTERMEDIATE_STATE_NODES = "PRERUN_INTERMEDIATE_STATE_NODES" - PRERUN_INTERMEDIATE_STORAGE_NODES = "PRERUN_INTERMEDIATE_STORAGE_NODES" - PRERUN_INCLUDE_BLOCK = "PRERUN_INCLUDE_BLOCK" - PRERUN_INCLUDE_RECEIPTS = "PRERUN_INCLUDE_RECEIPTS" - PRERUN_INCLUDE_TD = "PRERUN_INCLUDE_TD" - PRERUN_INCLUDE_CODE = "PRERUN_INCLUDE_CODE" + PRERUN_ONLY = "PRERUN_ONLY" + PRERUN_PARALLEL = "PRERUN_PARALLEL" + PRERUN_RANGE_START = "PRERUN_RANGE_START" + PRERUN_RANGE_STOP = "PRERUN_RANGE_STOP" + PRERUN_INCLUDE_BLOCK = "PRERUN_INCLUDE_BLOCK" + PRERUN_INCLUDE_RECEIPTS = "PRERUN_INCLUDE_RECEIPTS" + PRERUN_INCLUDE_TD = "PRERUN_INCLUDE_TD" + PRERUN_INCLUDE_CODE = "PRERUN_INCLUDE_CODE" LOG_LEVEL = "LOG_LEVEL" LOG_FILE_PATH = "LOG_FILE_PATH" @@ -141,8 +139,6 @@ func init() { viper.BindEnv("prerun.parallel", PRERUN_PARALLEL) viper.BindEnv("prerun.start", PRERUN_RANGE_START) viper.BindEnv("prerun.stop", PRERUN_RANGE_STOP) - viper.BindEnv("prerun.params.intermediateStateNodes", PRERUN_INTERMEDIATE_STATE_NODES) - viper.BindEnv("prerun.params.intermediateStorageNodes", PRERUN_INTERMEDIATE_STORAGE_NODES) viper.BindEnv("prerun.params.includeBlock", PRERUN_INCLUDE_BLOCK) viper.BindEnv("prerun.params.includeReceipts", PRERUN_INCLUDE_RECEIPTS) viper.BindEnv("prerun.params.includeTD", PRERUN_INCLUDE_TD) diff --git a/cmd/root.go b/cmd/root.go index ae60671..e957938 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -163,8 +163,6 @@ func init() { rootCmd.PersistentFlags().Bool("prerun-only", false, "only process pre-configured ranges; exit afterwards") rootCmd.PersistentFlags().Int("prerun-start", 0, "start height for a prerun range") rootCmd.PersistentFlags().Int("prerun-stop", 0, "stop height for a prerun range") - rootCmd.PersistentFlags().Bool("prerun-intermediate-state-nodes", true, "include intermediate state nodes in state diff") - rootCmd.PersistentFlags().Bool("prerun-intermediate-storage-nodes", true, "include intermediate storage nodes in state diff") rootCmd.PersistentFlags().Bool("prerun-include-block", true, "include block data in the statediff payload") rootCmd.PersistentFlags().Bool("prerun-include-receipts", true, "include receipts in the statediff payload") rootCmd.PersistentFlags().Bool("prerun-include-td", true, "include td in the statediff payload") @@ -224,8 +222,6 @@ func init() { viper.BindPFlag("prerun.parallel", rootCmd.PersistentFlags().Lookup("prerun-parallel")) viper.BindPFlag("prerun.start", rootCmd.PersistentFlags().Lookup("prerun-start")) viper.BindPFlag("prerun.stop", rootCmd.PersistentFlags().Lookup("prerun-stop")) - viper.BindPFlag("prerun.params.intermediateStateNodes", rootCmd.PersistentFlags().Lookup("prerun-intermediate-state-nodes")) - viper.BindPFlag("prerun.params.intermediateStorageNodes", rootCmd.PersistentFlags().Lookup("prerun-intermediate-storage-nodes")) viper.BindPFlag("prerun.params.includeBlock", rootCmd.PersistentFlags().Lookup("prerun-include-block")) viper.BindPFlag("prerun.params.includeReceipts", rootCmd.PersistentFlags().Lookup("prerun-include-receipts")) viper.BindPFlag("prerun.params.includeTD", rootCmd.PersistentFlags().Lookup("prerun-include-td")) diff --git a/cmd/serve.go b/cmd/serve.go index 6ba7b7d..6f725e2 100644 --- a/cmd/serve.go +++ b/cmd/serve.go @@ -22,6 +22,7 @@ import ( "os/signal" "runtime" "sync" + "syscall" "github.com/ethereum/go-ethereum/rpc" "github.com/sirupsen/logrus" @@ -113,7 +114,7 @@ func serve() { // clean shutdown shutdown := make(chan os.Signal) - signal.Notify(shutdown, os.Interrupt) + signal.Notify(shutdown, syscall.SIGINT) <-shutdown logWithCommand.Info("Received interrupt signal, shutting down") statediffService.Stop() diff --git a/cmd/util.go b/cmd/util.go index a906a64..9586f3b 100644 --- a/cmd/util.go +++ b/cmd/util.go @@ -50,12 +50,10 @@ func setupPreRunRanges() []sd.RangeRequest { return nil } preRunParams := statediff.Params{ - IntermediateStateNodes: viper.GetBool("prerun.params.intermediateStateNodes"), - IntermediateStorageNodes: viper.GetBool("prerun.params.intermediateStorageNodes"), - IncludeBlock: viper.GetBool("prerun.params.includeBlock"), - IncludeReceipts: viper.GetBool("prerun.params.includeReceipts"), - IncludeTD: viper.GetBool("prerun.params.includeTD"), - IncludeCode: viper.GetBool("prerun.params.includeCode"), + IncludeBlock: viper.GetBool("prerun.params.includeBlock"), + IncludeReceipts: viper.GetBool("prerun.params.includeReceipts"), + IncludeTD: viper.GetBool("prerun.params.includeTD"), + IncludeCode: viper.GetBool("prerun.params.includeCode"), } var addrStrs []string viper.UnmarshalKey("prerun.params.watchedAddresses", &addrStrs) From 07bd8757521c8ec692f330635b6f8ea7502501ca Mon Sep 17 00:00:00 2001 From: i-norden Date: Sun, 9 Apr 2023 11:01:23 -0500 Subject: [PATCH 3/4] update tomls and README --- README.md | 2 -- environments/config.toml | 2 -- environments/example.toml | 2 -- 3 files changed, 6 deletions(-) diff --git a/README.md b/README.md index 79ec4d9..58d1592 100644 --- a/README.md +++ b/README.md @@ -61,8 +61,6 @@ An example config file: # statediffing params for prerun [prerun.params] - intermediateStateNodes = true # PRERUN_INTERMEDIATE_STATE_NODES - intermediateStorageNodes = true # PRERUN_INTERMEDIATE_STORAGE_NODES includeBlock = true # PRERUN_INCLUDE_BLOCK includeReceipts = true # PRERUN_INCLUDE_RECEIPTS includeTD = true # PRERUN_INCLUDE_TD diff --git a/environments/config.toml b/environments/config.toml index 3a5dd94..fa7e1b8 100644 --- a/environments/config.toml +++ b/environments/config.toml @@ -17,8 +17,6 @@ only = true ranges = [] [prerun.params] - intermediateStateNodes = true - intermediateStorageNodes = true includeBlock = true includeReceipts = true includeTD = true diff --git a/environments/example.toml b/environments/example.toml index a0e85e5..957047a 100644 --- a/environments/example.toml +++ b/environments/example.toml @@ -20,8 +20,6 @@ [0, 1000] ] [prerun.params] - intermediateStateNodes = true - intermediateStorageNodes = true includeBlock = true includeReceipts = true includeTD = true From 4ddd3d0e203bdf91a0763f56edf970de6494268c Mon Sep 17 00:00:00 2001 From: i-norden Date: Sun, 9 Apr 2023 11:01:31 -0500 Subject: [PATCH 4/4] go mod tidy --- go.mod | 18 ++------------- go.sum | 70 +++++----------------------------------------------------- 2 files changed, 7 insertions(+), 81 deletions(-) diff --git a/go.mod b/go.mod index dd69ca4..ebfe2f5 100644 --- a/go.mod +++ b/go.mod @@ -44,7 +44,6 @@ require ( github.com/gorilla/websocket v1.4.2 // indirect github.com/graph-gophers/graphql-go v1.3.0 // indirect github.com/hashicorp/go-bexpr v0.1.10 // indirect - github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect github.com/hashicorp/hcl v1.0.0 // indirect github.com/holiman/bloomfilter/v2 v2.0.3 // indirect github.com/holiman/uint256 v1.2.0 // indirect @@ -53,17 +52,7 @@ require ( github.com/influxdata/influxdb v1.8.3 // indirect github.com/influxdata/influxdb-client-go/v2 v2.4.0 // indirect github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 // indirect - github.com/ipfs/bbloom v0.0.4 // indirect - github.com/ipfs/go-block-format v0.0.3 // indirect github.com/ipfs/go-cid v0.2.0 // indirect - github.com/ipfs/go-datastore v0.5.1 // indirect - github.com/ipfs/go-ipfs-blockstore v1.2.0 // indirect - github.com/ipfs/go-ipfs-ds-help v1.1.0 // indirect - github.com/ipfs/go-ipfs-util v0.0.2 // indirect - github.com/ipfs/go-ipld-format v0.4.0 // indirect - github.com/ipfs/go-log v1.0.5 // indirect - github.com/ipfs/go-log/v2 v2.1.3 // indirect - github.com/ipfs/go-metrics-interface v0.0.1 // indirect github.com/jackc/chunkreader/v2 v2.0.1 // indirect github.com/jackc/pgconn v1.10.0 // indirect github.com/jackc/pgio v1.0.0 // indirect @@ -74,7 +63,6 @@ require ( github.com/jackc/pgx/v4 v4.13.0 // indirect github.com/jackc/puddle v1.1.3 // indirect github.com/jackpal/go-nat-pmp v1.0.2 // indirect - github.com/jbenet/goprocess v0.1.4 // indirect github.com/klauspost/compress v1.15.15 // indirect github.com/klauspost/cpuid/v2 v2.0.9 // indirect github.com/kr/pretty v0.3.1 // indirect @@ -108,6 +96,7 @@ require ( github.com/rs/cors v1.7.0 // indirect github.com/russross/blackfriday/v2 v2.1.0 // indirect github.com/shirou/gopsutil v3.21.11+incompatible // indirect + github.com/shopspring/decimal v1.2.0 // indirect github.com/spaolacci/murmur3 v1.1.0 // indirect github.com/spf13/afero v1.6.0 // indirect github.com/spf13/cast v1.4.1 // indirect @@ -123,9 +112,6 @@ require ( github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa // indirect github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect github.com/yusufpapurcu/wmi v1.2.2 // indirect - go.uber.org/atomic v1.7.0 // indirect - go.uber.org/multierr v1.6.0 // indirect - go.uber.org/zap v1.17.0 // indirect golang.org/x/crypto v0.6.0 // indirect golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect golang.org/x/net v0.6.0 // indirect @@ -140,4 +126,4 @@ require ( lukechampine.com/blake3 v1.1.6 // indirect ) -replace github.com/ethereum/go-ethereum v1.11.5 => github.com/cerc-io/go-ethereum v1.11.5-statediff-4.3.9-alpha +replace github.com/ethereum/go-ethereum v1.11.5 => github.com/cerc-io/go-ethereum v1.11.5-statediff-5.0.1-alpha diff --git a/go.sum b/go.sum index 2443753..c49b93b 100644 --- a/go.sum +++ b/go.sum @@ -96,8 +96,8 @@ github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOF github.com/c-bata/go-prompt v0.2.2/go.mod h1:VzqtzE2ksDBcdln8G7mk2RX9QyGjH+OVqOCSiVIqS34= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= -github.com/cerc-io/go-ethereum v1.11.5-statediff-4.3.9-alpha h1:nzy/bUmzq8ImRIxchClNoO7Bytom8ETDuOFHzuHFBXs= -github.com/cerc-io/go-ethereum v1.11.5-statediff-4.3.9-alpha/go.mod h1:Q4LXiMcJCctVW1uoIuF59VRCW1W+zrc5GkewoARwAmk= +github.com/cerc-io/go-ethereum v1.11.5-statediff-5.0.1-alpha h1:x9muuG0Z2W/UAkwAq+0SXhYG9MCP6SJlGEfFNQa6JPI= +github.com/cerc-io/go-ethereum v1.11.5-statediff-5.0.1-alpha/go.mod h1:DIk2wFexjyzvyjuzSOtBEIAPRNZTnLXNbIHEyq1Igek= github.com/cerc-io/leveldb-ethdb-rpc v1.1.13 h1:XM+e/JLKjNoYc4Xj7DJNNlFI4+3HpqZ9VkVlrWBlwHg= github.com/cerc-io/leveldb-ethdb-rpc v1.1.13/go.mod h1:ZNa5ySrKJ0ZLsJ0nSNaQ+11PkX29Juy9+omMgP6mw1c= github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= @@ -236,8 +236,8 @@ github.com/go-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34 github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk= github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= +github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE= github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= -github.com/go-sql-driver/mysql v1.7.0 h1:ueSltNNllEqE3qcWBTD0iQd3IpL/6U+mJxLkazJ7YPc= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw= github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4= @@ -256,7 +256,6 @@ github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a/go.mod h1:gf4bu3Q8 github.com/gogo/googleapis v1.4.1/go.mod h1:2lpHqI5OcWCtVElxXnPt+s8oJvMpySlOyM6xDCrzib4= github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= -github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= @@ -342,7 +341,6 @@ github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLe github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= -github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= @@ -358,8 +356,6 @@ github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/ad github.com/graph-gophers/graphql-go v1.3.0 h1:Eb9x/q6MFpCLz7jBCiP/WTxjSDrYLR1QY41SORZyNJ0= github.com/graph-gophers/graphql-go v1.3.0/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= -github.com/gxed/hashland/keccakpg v0.0.1/go.mod h1:kRzw3HkwxFU1mpmPP8v1WyQzwdGfmKFJ6tItnhQ67kU= -github.com/gxed/hashland/murmur3 v0.0.1/go.mod h1:KjXop02n4/ckmZSnY2+HKcLud/tcmvhST0bie/0lS48= github.com/hashicorp/consul/api v1.11.0/go.mod h1:XjsvQN+RJGWI2TWy1/kqaE16HrR2J/FWgkYjdZQsX9M= github.com/hashicorp/consul/sdk v0.8.0/go.mod h1:GBvyrGALthsZObzUGsfgHZQDXjg4lOjagTIwIR1vPms= github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= @@ -385,8 +381,6 @@ github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= -github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d h1:dg1dEPuWpEqDnvIw251EVy4zlP8gWbsGj4BsUKCRpYs= -github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= @@ -425,40 +419,8 @@ github.com/influxdata/promql/v2 v2.12.0/go.mod h1:fxOPu+DY0bqCTCECchSRtWfc+0X19y github.com/influxdata/roaring v0.4.13-0.20180809181101-fc520f41fab6/go.mod h1:bSgUQ7q5ZLSO+bKBGqJiCBGAl+9DxyW63zLTujjUlOE= github.com/influxdata/tdigest v0.0.0-20181121200506-bf2b5ad3c0a9/go.mod h1:Js0mqiSBE6Ffsg94weZZ2c+v/ciT8QRHFOap7EKDrR0= github.com/influxdata/usage-client v0.0.0-20160829180054-6d3895376368/go.mod h1:Wbbw6tYNvwa5dlB6304Sd+82Z3f7PmVZHVKU637d4po= -github.com/ipfs/bbloom v0.0.4 h1:Gi+8EGJ2y5qiD5FbsbpX/TMNcJw8gSqr7eyjHa4Fhvs= -github.com/ipfs/bbloom v0.0.4/go.mod h1:cS9YprKXpoZ9lT0n/Mw/a6/aFV6DTjTLYHeA+gyqMG0= -github.com/ipfs/go-block-format v0.0.2/go.mod h1:AWR46JfpcObNfg3ok2JHDUfdiHRgWhJgCQF+KIgOPJY= -github.com/ipfs/go-block-format v0.0.3 h1:r8t66QstRp/pd/or4dpnbVfXT5Gt7lOqRvC+/dDTpMc= -github.com/ipfs/go-block-format v0.0.3/go.mod h1:4LmD4ZUw0mhO+JSKdpWwrzATiEfM7WWgQ8H5l6P8MVk= -github.com/ipfs/go-cid v0.0.1/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM= -github.com/ipfs/go-cid v0.0.2/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM= -github.com/ipfs/go-cid v0.0.5/go.mod h1:plgt+Y5MnOey4vO4UlUazGqdbEXuFYitED67FexhXog= -github.com/ipfs/go-cid v0.0.7/go.mod h1:6Ux9z5e+HpkQdckYoX1PG/6xqKspzlEIR5SDmgqgC/I= github.com/ipfs/go-cid v0.2.0 h1:01JTiihFq9en9Vz0lc0VDWvZe/uBonGpzo4THP0vcQ0= github.com/ipfs/go-cid v0.2.0/go.mod h1:P+HXFDF4CVhaVayiEb4wkAy7zBHxBwsJyt0Y5U6MLro= -github.com/ipfs/go-datastore v0.5.0/go.mod h1:9zhEApYMTl17C8YDp7JmU7sQZi2/wqiYh73hakZ90Bk= -github.com/ipfs/go-datastore v0.5.1 h1:WkRhLuISI+XPD0uk3OskB0fYFSyqK8Ob5ZYew9Qa1nQ= -github.com/ipfs/go-datastore v0.5.1/go.mod h1:9zhEApYMTl17C8YDp7JmU7sQZi2/wqiYh73hakZ90Bk= -github.com/ipfs/go-detect-race v0.0.1 h1:qX/xay2W3E4Q1U7d9lNs1sU9nvguX0a7319XbyQ6cOk= -github.com/ipfs/go-detect-race v0.0.1/go.mod h1:8BNT7shDZPo99Q74BpGMK+4D8Mn4j46UU0LZ723meps= -github.com/ipfs/go-ipfs-blockstore v1.2.0 h1:n3WTeJ4LdICWs/0VSfjHrlqpPpl6MZ+ySd3j8qz0ykw= -github.com/ipfs/go-ipfs-blockstore v1.2.0/go.mod h1:eh8eTFLiINYNSNawfZOC7HOxNTxpB1PFuA5E1m/7exE= -github.com/ipfs/go-ipfs-delay v0.0.0-20181109222059-70721b86a9a8/go.mod h1:8SP1YXK1M1kXuc4KJZINY3TQQ03J2rwBG9QfXmbRPrw= -github.com/ipfs/go-ipfs-ds-help v1.1.0 h1:yLE2w9RAsl31LtfMt91tRZcrx+e61O5mDxFRR994w4Q= -github.com/ipfs/go-ipfs-ds-help v1.1.0/go.mod h1:YR5+6EaebOhfcqVCyqemItCLthrpVNot+rsOU/5IatU= -github.com/ipfs/go-ipfs-util v0.0.1/go.mod h1:spsl5z8KUnrve+73pOhSVZND1SIxPW5RyBCNzQxlJBc= -github.com/ipfs/go-ipfs-util v0.0.2 h1:59Sswnk1MFaiq+VcaknX7aYEyGyGDAA73ilhEK2POp8= -github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdrtMecczcsQ= -github.com/ipfs/go-ipld-format v0.3.0/go.mod h1:co/SdBE8h99968X0hViiw1MNlh6fvxxnHpvVLnH7jSM= -github.com/ipfs/go-ipld-format v0.4.0 h1:yqJSaJftjmjc9jEOFYlpkwOLVKv68OD27jFLlSghBlQ= -github.com/ipfs/go-ipld-format v0.4.0/go.mod h1:co/SdBE8h99968X0hViiw1MNlh6fvxxnHpvVLnH7jSM= -github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= -github.com/ipfs/go-log v1.0.5 h1:2dOuUCB1Z7uoczMWgAyDck5JLb72zHzrMnGnCNNbvY8= -github.com/ipfs/go-log v1.0.5/go.mod h1:j0b8ZoR+7+R99LD9jZ6+AJsrzkPbSXbZfGakb5JPtIo= -github.com/ipfs/go-log/v2 v2.1.3 h1:1iS3IU7aXRlbgUpN8yTTpJ53NXYjAe37vcI5+5nYrzk= -github.com/ipfs/go-log/v2 v2.1.3/go.mod h1:/8d0SH3Su5Ooc31QlL1WysJhvyOTDCjcCZ9Axpmri6g= -github.com/ipfs/go-metrics-interface v0.0.1 h1:j+cpbjYvu4R8zbleSs36gvB7jR+wsL2fGD6n0jO4kdg= -github.com/ipfs/go-metrics-interface v0.0.1/go.mod h1:6s6euYU4zowdslK0GKHmqaIZ3j/b/tL7HTWtJ4VPgWY= github.com/iris-contrib/blackfriday v2.0.0+incompatible/go.mod h1:UzZ2bDEoaSGPbkg6SAB4att1aAwTmVIx/5gCVqeyUdI= github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0= github.com/iris-contrib/jade v1.1.3/go.mod h1:H/geBymxJhShH5kecoiOCSssPX7QWYH7UaeZTSWddIk= @@ -527,9 +489,6 @@ github.com/jackc/puddle v1.1.3 h1:JnPg/5Q9xVJGfjsO5CPUOjnJps1JaRUm8I9FXVCFK94= github.com/jackc/puddle v1.1.3/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= -github.com/jbenet/go-cienv v0.1.0/go.mod h1:TqNnHUmJgXau0nCzC7kXWeotg3J9W34CUv5Djy1+FlA= -github.com/jbenet/goprocess v0.1.4 h1:DRGOFReOMqqDNXwW70QkacFW0YN9QnwLV0Vqk+3oU0o= -github.com/jbenet/goprocess v0.1.4/go.mod h1:5yspPrukOVuOLORacaBi858NqyClJPQxYZlqdZVfqY4= github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= github.com/jinzhu/now v1.1.1/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= github.com/jmoiron/sqlx v1.3.1/go.mod h1:2BljVx/86SuTyjE+aPYlHCTNvZrnJXghYGpNiXLBMCQ= @@ -553,7 +512,6 @@ github.com/kataras/iris/v12 v12.1.8/go.mod h1:LMYy4VlP67TQ3Zgriz8RE2h2kMZV2SgMYb github.com/kataras/neffos v0.0.14/go.mod h1:8lqADm8PnbeFfL7CLXh1WHw53dG27MC3pgi2R1rmoTE= github.com/kataras/pio v0.0.2/go.mod h1:hAoW0t9UmXi4R5Oyq5Z4irTbaTsOemSrDGUtaTl7Dro= github.com/kataras/sitemap v0.0.5/go.mod h1:KY2eugMKiPwsJgx7+U103YZehfvNGOXURubcGyk0Bz8= -github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q= github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= @@ -630,8 +588,8 @@ github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzp github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0= github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= github.com/mattn/go-sqlite3 v1.11.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= +github.com/mattn/go-sqlite3 v1.14.6 h1:dNPt6NO46WmLVt2DLNpwczCmdV5boIZ6g/tlDrlRUbg= github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= -github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y= github.com/mattn/go-tty v0.0.0-20180907095812-13ff1204f104/go.mod h1:XPvLUNfbS4fJH25nqRHfWLMa1ONC8Amw+mIA639KxkE= github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= @@ -644,8 +602,6 @@ github.com/miekg/dns v1.1.26/go.mod h1:bPDLeHnStXmXAq1m/Ch/hvfNHr14JKNPMBo3VZKju github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI= github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g= github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ= -github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV56Chs1E/U= -github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM= github.com/minio/sha256-simd v1.0.0 h1:v1ta+49hkWZyvaKwrQB8elexRqm6Y0aMLjCNsrYxo6g= github.com/minio/sha256-simd v1.0.0/go.mod h1:OuYzVNI5vcoYIAmbIvHPl3N3jUzVedXbKy5RFepssQM= github.com/mitchellh/cli v1.1.0/go.mod h1:xcISNoH86gajksDmfB23e/pu+B+GeFRMYmoHXxx3xhI= @@ -665,7 +621,6 @@ github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3Rllmb github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ= github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8= -github.com/mr-tron/base58 v1.1.3/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o= github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= github.com/mschoch/smat v0.0.0-20160514031455-90eadee771ae/go.mod h1:qAyveg+e4CE+eKJXWVjKXM4ck2QobLqTDytGJbLLhJg= @@ -673,15 +628,10 @@ github.com/multiformats/go-base32 v0.0.3 h1:tw5+NhuwaOjJCC5Pp82QuXbrmLzWg7uxlMFp github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA= github.com/multiformats/go-base36 v0.1.0 h1:JR6TyF7JjGd3m6FbLU2cOxhC0Li8z8dLNGQ89tUg4F4= github.com/multiformats/go-base36 v0.1.0/go.mod h1:kFGE83c6s80PklsHO9sRn2NCoffoRdUUOENyW/Vv6sM= -github.com/multiformats/go-multibase v0.0.1/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs= github.com/multiformats/go-multibase v0.0.3 h1:l/B6bJDQjvQ5G52jw4QGSYeOTZoAwIO77RblWplfIqk= github.com/multiformats/go-multibase v0.0.3/go.mod h1:5+1R4eQrT3PkYZ24C3W2Ue2tPwIdYQD509ZjSb5y9Oc= -github.com/multiformats/go-multihash v0.0.1/go.mod h1:w/5tugSrLEbWqlcgJabL3oHFKTwfvkofsjW2Qa1ct4U= -github.com/multiformats/go-multihash v0.0.13/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc= -github.com/multiformats/go-multihash v0.0.14/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc= github.com/multiformats/go-multihash v0.1.0 h1:CgAgwqk3//SVEw3T+6DqI4mWMyRuDwZtOWcJT0q9+EA= github.com/multiformats/go-multihash v0.1.0/go.mod h1:RJlXsxt6vHGaia+S8We0ErjhojtKzPP2AH4+kYM7k84= -github.com/multiformats/go-varint v0.0.5/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE= github.com/multiformats/go-varint v0.0.6 h1:gk85QWKxh3TazbLxED/NlDVv8+q+ReFJk7Y2W/KhfNY= github.com/multiformats/go-varint v0.0.6/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= @@ -824,8 +774,8 @@ github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobt github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.2.0 h1:Hbg2NidpLE8veEBkEZTL3CvlkUIVzuU9jDplZO54c48= github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= +github.com/stretchr/objx v0.4.0 h1:M2gUjqZET1qApGOWNSnZ49BAIMX4F/1plDv3+l31EJ4= github.com/stretchr/testify v1.2.0/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= @@ -861,7 +811,6 @@ github.com/valyala/fasthttp v1.6.0/go.mod h1:FstJa9V+Pj9vQ7OJie2qMHdwemEDaDiSdBn github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8= github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ= github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio= -github.com/whyrusleeping/go-logging v0.0.0-20170515211332-0457bb6b88fc/go.mod h1:bopw91TMyo8J3tvftk8xmU2kPmlrt4nScJQZU2hE5EM= github.com/willf/bitset v1.1.3/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4= github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= @@ -897,29 +846,23 @@ go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= -go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU= -go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= -go.uber.org/zap v1.16.0/go.mod h1:MA8QOfq0BHJwdXa996Y4dYkAqRKB8/1K1QMMZVaNZjQ= -go.uber.org/zap v1.17.0 h1:MTjgFu6ZLKvY6Pvaqk97GlxNBuMpV4Hy/3P6tRGlI2U= go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= -golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190411191339-88737f569e3a/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190911031432-227b76d455e7/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= @@ -989,7 +932,6 @@ golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190227160552-c95aed5357e7/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190327091125-710a502c58a2/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= @@ -1073,7 +1015,6 @@ golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190219092855-153ac476189d/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1178,7 +1119,6 @@ golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxb golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20220922220347-f3bd1da661af h1:Yx9k8YCG3dvF87UAn2tu2HQLf2dt/eR1bXxpLMWeH+Y= golang.org/x/time v0.0.0-20220922220347-f3bd1da661af/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=