123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750 |
- // Copyright 2016 The go-ethereum Authors
- // This file is part of the go-ethereum library.
- //
- // The go-ethereum library is free software: you can redistribute it and/or modify
- // it under the terms of the GNU Lesser General Public License as published by
- // the Free Software Foundation, either version 3 of the License, or
- // (at your option) any later version.
- //
- // The go-ethereum library is distributed in the hope that it will be useful,
- // but WITHOUT ANY WARRANTY; without even the implied warranty of
- // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- // GNU Lesser General Public License for more details.
- //
- // You should have received a copy of the GNU Lesser General Public License
- // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
- package les
- import (
- "encoding/binary"
- "math/big"
- "math/rand"
- "testing"
- "time"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/mclock"
- "github.com/ethereum/go-ethereum/consensus/ethash"
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth/downloader"
- "github.com/ethereum/go-ethereum/light"
- "github.com/ethereum/go-ethereum/p2p"
- "github.com/ethereum/go-ethereum/params"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/trie"
- )
- func expectResponse(r p2p.MsgReader, msgcode, reqID, bv uint64, data interface{}) error {
- type resp struct {
- ReqID, BV uint64
- Data interface{}
- }
- return p2p.ExpectMsg(r, msgcode, resp{reqID, bv, data})
- }
- // Tests that block headers can be retrieved from a remote chain based on user queries.
- func TestGetBlockHeadersLes2(t *testing.T) { testGetBlockHeaders(t, 2) }
- func TestGetBlockHeadersLes3(t *testing.T) { testGetBlockHeaders(t, 3) }
- func TestGetBlockHeadersLes4(t *testing.T) { testGetBlockHeaders(t, 4) }
- func testGetBlockHeaders(t *testing.T, protocol int) {
- netconfig := testnetConfig{
- blocks: downloader.MaxHeaderFetch + 15,
- protocol: protocol,
- nopruning: true,
- }
- server, _, tearDown := newClientServerEnv(t, netconfig)
- defer tearDown()
- rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
- defer closePeer()
- bc := server.handler.blockchain
- // Create a "random" unknown hash for testing
- var unknown common.Hash
- for i := range unknown {
- unknown[i] = byte(i)
- }
- // Create a batch of tests for various scenarios
- limit := uint64(MaxHeaderFetch)
- tests := []struct {
- query *GetBlockHeadersData // The query to execute for header retrieval
- expect []common.Hash // The hashes of the block whose headers are expected
- }{
- // A single random block should be retrievable by hash and number too
- {
- &GetBlockHeadersData{Origin: hashOrNumber{Hash: bc.GetBlockByNumber(limit / 2).Hash()}, Amount: 1},
- []common.Hash{bc.GetBlockByNumber(limit / 2).Hash()},
- }, {
- &GetBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Amount: 1},
- []common.Hash{bc.GetBlockByNumber(limit / 2).Hash()},
- },
- // Multiple headers should be retrievable in both directions
- {
- &GetBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Amount: 3},
- []common.Hash{
- bc.GetBlockByNumber(limit / 2).Hash(),
- bc.GetBlockByNumber(limit/2 + 1).Hash(),
- bc.GetBlockByNumber(limit/2 + 2).Hash(),
- },
- }, {
- &GetBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Amount: 3, Reverse: true},
- []common.Hash{
- bc.GetBlockByNumber(limit / 2).Hash(),
- bc.GetBlockByNumber(limit/2 - 1).Hash(),
- bc.GetBlockByNumber(limit/2 - 2).Hash(),
- },
- },
- // Multiple headers with skip lists should be retrievable
- {
- &GetBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Skip: 3, Amount: 3},
- []common.Hash{
- bc.GetBlockByNumber(limit / 2).Hash(),
- bc.GetBlockByNumber(limit/2 + 4).Hash(),
- bc.GetBlockByNumber(limit/2 + 8).Hash(),
- },
- }, {
- &GetBlockHeadersData{Origin: hashOrNumber{Number: limit / 2}, Skip: 3, Amount: 3, Reverse: true},
- []common.Hash{
- bc.GetBlockByNumber(limit / 2).Hash(),
- bc.GetBlockByNumber(limit/2 - 4).Hash(),
- bc.GetBlockByNumber(limit/2 - 8).Hash(),
- },
- },
- // The chain endpoints should be retrievable
- {
- &GetBlockHeadersData{Origin: hashOrNumber{Number: 0}, Amount: 1},
- []common.Hash{bc.GetBlockByNumber(0).Hash()},
- }, {
- &GetBlockHeadersData{Origin: hashOrNumber{Number: bc.CurrentBlock().NumberU64()}, Amount: 1},
- []common.Hash{bc.CurrentBlock().Hash()},
- },
- // Ensure protocol limits are honored
- //{
- // &GetBlockHeadersData{Origin: hashOrNumber{Number: bc.CurrentBlock().NumberU64() - 1}, Amount: limit + 10, Reverse: true},
- // []common.Hash{},
- //},
- // Check that requesting more than available is handled gracefully
- {
- &GetBlockHeadersData{Origin: hashOrNumber{Number: bc.CurrentBlock().NumberU64() - 4}, Skip: 3, Amount: 3},
- []common.Hash{
- bc.GetBlockByNumber(bc.CurrentBlock().NumberU64() - 4).Hash(),
- bc.GetBlockByNumber(bc.CurrentBlock().NumberU64()).Hash(),
- },
- }, {
- &GetBlockHeadersData{Origin: hashOrNumber{Number: 4}, Skip: 3, Amount: 3, Reverse: true},
- []common.Hash{
- bc.GetBlockByNumber(4).Hash(),
- bc.GetBlockByNumber(0).Hash(),
- },
- },
- // Check that requesting more than available is handled gracefully, even if mid skip
- {
- &GetBlockHeadersData{Origin: hashOrNumber{Number: bc.CurrentBlock().NumberU64() - 4}, Skip: 2, Amount: 3},
- []common.Hash{
- bc.GetBlockByNumber(bc.CurrentBlock().NumberU64() - 4).Hash(),
- bc.GetBlockByNumber(bc.CurrentBlock().NumberU64() - 1).Hash(),
- },
- }, {
- &GetBlockHeadersData{Origin: hashOrNumber{Number: 4}, Skip: 2, Amount: 3, Reverse: true},
- []common.Hash{
- bc.GetBlockByNumber(4).Hash(),
- bc.GetBlockByNumber(1).Hash(),
- },
- },
- // Check that non existing headers aren't returned
- {
- &GetBlockHeadersData{Origin: hashOrNumber{Hash: unknown}, Amount: 1},
- []common.Hash{},
- }, {
- &GetBlockHeadersData{Origin: hashOrNumber{Number: bc.CurrentBlock().NumberU64() + 1}, Amount: 1},
- []common.Hash{},
- },
- }
- // Run each of the tests and verify the results against the chain
- var reqID uint64
- for i, tt := range tests {
- // Collect the headers to expect in the response
- var headers []*types.Header
- for _, hash := range tt.expect {
- headers = append(headers, bc.GetHeaderByHash(hash))
- }
- // Send the hash request and verify the response
- reqID++
- sendRequest(rawPeer.app, GetBlockHeadersMsg, reqID, tt.query)
- if err := expectResponse(rawPeer.app, BlockHeadersMsg, reqID, testBufLimit, headers); err != nil {
- t.Errorf("test %d: headers mismatch: %v", i, err)
- }
- }
- }
- // Tests that block contents can be retrieved from a remote chain based on their hashes.
- func TestGetBlockBodiesLes2(t *testing.T) { testGetBlockBodies(t, 2) }
- func TestGetBlockBodiesLes3(t *testing.T) { testGetBlockBodies(t, 3) }
- func TestGetBlockBodiesLes4(t *testing.T) { testGetBlockBodies(t, 4) }
- func testGetBlockBodies(t *testing.T, protocol int) {
- netconfig := testnetConfig{
- blocks: downloader.MaxHeaderFetch + 15,
- protocol: protocol,
- nopruning: true,
- }
- server, _, tearDown := newClientServerEnv(t, netconfig)
- defer tearDown()
- rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
- defer closePeer()
- bc := server.handler.blockchain
- // Create a batch of tests for various scenarios
- limit := MaxBodyFetch
- tests := []struct {
- random int // Number of blocks to fetch randomly from the chain
- explicit []common.Hash // Explicitly requested blocks
- available []bool // Availability of explicitly requested blocks
- expected int // Total number of existing blocks to expect
- }{
- {1, nil, nil, 1}, // A single random block should be retrievable
- {10, nil, nil, 10}, // Multiple random blocks should be retrievable
- {limit, nil, nil, limit}, // The maximum possible blocks should be retrievable
- //{limit + 1, nil, nil, limit}, // No more than the possible block count should be returned
- {0, []common.Hash{bc.Genesis().Hash()}, []bool{true}, 1}, // The genesis block should be retrievable
- {0, []common.Hash{bc.CurrentBlock().Hash()}, []bool{true}, 1}, // The chains head block should be retrievable
- {0, []common.Hash{{}}, []bool{false}, 0}, // A non existent block should not be returned
- // Existing and non-existing blocks interleaved should not cause problems
- {0, []common.Hash{
- {},
- bc.GetBlockByNumber(1).Hash(),
- {},
- bc.GetBlockByNumber(10).Hash(),
- {},
- bc.GetBlockByNumber(100).Hash(),
- {},
- }, []bool{false, true, false, true, false, true, false}, 3},
- }
- // Run each of the tests and verify the results against the chain
- var reqID uint64
- for i, tt := range tests {
- // Collect the hashes to request, and the response to expect
- var hashes []common.Hash
- seen := make(map[int64]bool)
- var bodies []*types.Body
- for j := 0; j < tt.random; j++ {
- for {
- num := rand.Int63n(int64(bc.CurrentBlock().NumberU64()))
- if !seen[num] {
- seen[num] = true
- block := bc.GetBlockByNumber(uint64(num))
- hashes = append(hashes, block.Hash())
- if len(bodies) < tt.expected {
- bodies = append(bodies, &types.Body{Transactions: block.Transactions(), Uncles: block.Uncles()})
- }
- break
- }
- }
- }
- for j, hash := range tt.explicit {
- hashes = append(hashes, hash)
- if tt.available[j] && len(bodies) < tt.expected {
- block := bc.GetBlockByHash(hash)
- bodies = append(bodies, &types.Body{Transactions: block.Transactions(), Uncles: block.Uncles()})
- }
- }
- reqID++
- // Send the hash request and verify the response
- sendRequest(rawPeer.app, GetBlockBodiesMsg, reqID, hashes)
- if err := expectResponse(rawPeer.app, BlockBodiesMsg, reqID, testBufLimit, bodies); err != nil {
- t.Errorf("test %d: bodies mismatch: %v", i, err)
- }
- }
- }
- // Tests that the contract codes can be retrieved based on account addresses.
- func TestGetCodeLes2(t *testing.T) { testGetCode(t, 2) }
- func TestGetCodeLes3(t *testing.T) { testGetCode(t, 3) }
- func TestGetCodeLes4(t *testing.T) { testGetCode(t, 4) }
- func testGetCode(t *testing.T, protocol int) {
- // Assemble the test environment
- netconfig := testnetConfig{
- blocks: 4,
- protocol: protocol,
- nopruning: true,
- }
- server, _, tearDown := newClientServerEnv(t, netconfig)
- defer tearDown()
- rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
- defer closePeer()
- bc := server.handler.blockchain
- var codereqs []*CodeReq
- var codes [][]byte
- for i := uint64(0); i <= bc.CurrentBlock().NumberU64(); i++ {
- header := bc.GetHeaderByNumber(i)
- req := &CodeReq{
- BHash: header.Hash(),
- AccKey: crypto.Keccak256(testContractAddr[:]),
- }
- codereqs = append(codereqs, req)
- if i >= testContractDeployed {
- codes = append(codes, testContractCodeDeployed)
- }
- }
- sendRequest(rawPeer.app, GetCodeMsg, 42, codereqs)
- if err := expectResponse(rawPeer.app, CodeMsg, 42, testBufLimit, codes); err != nil {
- t.Errorf("codes mismatch: %v", err)
- }
- }
- // Tests that the stale contract codes can't be retrieved based on account addresses.
- func TestGetStaleCodeLes2(t *testing.T) { testGetStaleCode(t, 2) }
- func TestGetStaleCodeLes3(t *testing.T) { testGetStaleCode(t, 3) }
- func TestGetStaleCodeLes4(t *testing.T) { testGetStaleCode(t, 4) }
- func testGetStaleCode(t *testing.T, protocol int) {
- netconfig := testnetConfig{
- blocks: core.TriesInMemory + 4,
- protocol: protocol,
- nopruning: true,
- }
- server, _, tearDown := newClientServerEnv(t, netconfig)
- defer tearDown()
- rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
- defer closePeer()
- bc := server.handler.blockchain
- check := func(number uint64, expected [][]byte) {
- req := &CodeReq{
- BHash: bc.GetHeaderByNumber(number).Hash(),
- AccKey: crypto.Keccak256(testContractAddr[:]),
- }
- sendRequest(rawPeer.app, GetCodeMsg, 42, []*CodeReq{req})
- if err := expectResponse(rawPeer.app, CodeMsg, 42, testBufLimit, expected); err != nil {
- t.Errorf("codes mismatch: %v", err)
- }
- }
- check(0, [][]byte{}) // Non-exist contract
- check(testContractDeployed, [][]byte{}) // Stale contract
- check(bc.CurrentHeader().Number.Uint64(), [][]byte{testContractCodeDeployed}) // Fresh contract
- }
- // Tests that the transaction receipts can be retrieved based on hashes.
- func TestGetReceiptLes2(t *testing.T) { testGetReceipt(t, 2) }
- func TestGetReceiptLes3(t *testing.T) { testGetReceipt(t, 3) }
- func TestGetReceiptLes4(t *testing.T) { testGetReceipt(t, 4) }
- func testGetReceipt(t *testing.T, protocol int) {
- // Assemble the test environment
- netconfig := testnetConfig{
- blocks: 4,
- protocol: protocol,
- nopruning: true,
- }
- server, _, tearDown := newClientServerEnv(t, netconfig)
- defer tearDown()
- rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
- defer closePeer()
- bc := server.handler.blockchain
- // Collect the hashes to request, and the response to expect
- var receipts []types.Receipts
- var hashes []common.Hash
- for i := uint64(0); i <= bc.CurrentBlock().NumberU64(); i++ {
- block := bc.GetBlockByNumber(i)
- hashes = append(hashes, block.Hash())
- receipts = append(receipts, rawdb.ReadRawReceipts(server.db, block.Hash(), block.NumberU64()))
- }
- // Send the hash request and verify the response
- sendRequest(rawPeer.app, GetReceiptsMsg, 42, hashes)
- if err := expectResponse(rawPeer.app, ReceiptsMsg, 42, testBufLimit, receipts); err != nil {
- t.Errorf("receipts mismatch: %v", err)
- }
- }
- // Tests that trie merkle proofs can be retrieved
- func TestGetProofsLes2(t *testing.T) { testGetProofs(t, 2) }
- func TestGetProofsLes3(t *testing.T) { testGetProofs(t, 3) }
- func TestGetProofsLes4(t *testing.T) { testGetProofs(t, 4) }
- func testGetProofs(t *testing.T, protocol int) {
- // Assemble the test environment
- netconfig := testnetConfig{
- blocks: 4,
- protocol: protocol,
- nopruning: true,
- }
- server, _, tearDown := newClientServerEnv(t, netconfig)
- defer tearDown()
- rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
- defer closePeer()
- bc := server.handler.blockchain
- var proofreqs []ProofReq
- proofsV2 := light.NewNodeSet()
- accounts := []common.Address{bankAddr, userAddr1, userAddr2, signerAddr, {}}
- for i := uint64(0); i <= bc.CurrentBlock().NumberU64(); i++ {
- header := bc.GetHeaderByNumber(i)
- trie, _ := trie.New(header.Root, trie.NewDatabase(server.db))
- for _, acc := range accounts {
- req := ProofReq{
- BHash: header.Hash(),
- Key: crypto.Keccak256(acc[:]),
- }
- proofreqs = append(proofreqs, req)
- trie.Prove(crypto.Keccak256(acc[:]), 0, proofsV2)
- }
- }
- // Send the proof request and verify the response
- sendRequest(rawPeer.app, GetProofsV2Msg, 42, proofreqs)
- if err := expectResponse(rawPeer.app, ProofsV2Msg, 42, testBufLimit, proofsV2.NodeList()); err != nil {
- t.Errorf("proofs mismatch: %v", err)
- }
- }
- // Tests that the stale contract codes can't be retrieved based on account addresses.
- func TestGetStaleProofLes2(t *testing.T) { testGetStaleProof(t, 2) }
- func TestGetStaleProofLes3(t *testing.T) { testGetStaleProof(t, 3) }
- func TestGetStaleProofLes4(t *testing.T) { testGetStaleProof(t, 4) }
- func testGetStaleProof(t *testing.T, protocol int) {
- netconfig := testnetConfig{
- blocks: core.TriesInMemory + 4,
- protocol: protocol,
- nopruning: true,
- }
- server, _, tearDown := newClientServerEnv(t, netconfig)
- defer tearDown()
- rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
- defer closePeer()
- bc := server.handler.blockchain
- check := func(number uint64, wantOK bool) {
- var (
- header = bc.GetHeaderByNumber(number)
- account = crypto.Keccak256(userAddr1.Bytes())
- )
- req := &ProofReq{
- BHash: header.Hash(),
- Key: account,
- }
- sendRequest(rawPeer.app, GetProofsV2Msg, 42, []*ProofReq{req})
- var expected []rlp.RawValue
- if wantOK {
- proofsV2 := light.NewNodeSet()
- t, _ := trie.New(header.Root, trie.NewDatabase(server.db))
- t.Prove(account, 0, proofsV2)
- expected = proofsV2.NodeList()
- }
- if err := expectResponse(rawPeer.app, ProofsV2Msg, 42, testBufLimit, expected); err != nil {
- t.Errorf("codes mismatch: %v", err)
- }
- }
- check(0, false) // Non-exist proof
- check(2, false) // Stale proof
- check(bc.CurrentHeader().Number.Uint64(), true) // Fresh proof
- }
- // Tests that CHT proofs can be correctly retrieved.
- func TestGetCHTProofsLes2(t *testing.T) { testGetCHTProofs(t, 2) }
- func TestGetCHTProofsLes3(t *testing.T) { testGetCHTProofs(t, 3) }
- func TestGetCHTProofsLes4(t *testing.T) { testGetCHTProofs(t, 4) }
- func testGetCHTProofs(t *testing.T, protocol int) {
- var (
- config = light.TestServerIndexerConfig
- waitIndexers = func(cIndexer, bIndexer, btIndexer *core.ChainIndexer) {
- for {
- cs, _, _ := cIndexer.Sections()
- if cs >= 1 {
- break
- }
- time.Sleep(10 * time.Millisecond)
- }
- }
- netconfig = testnetConfig{
- blocks: int(config.ChtSize + config.ChtConfirms),
- protocol: protocol,
- indexFn: waitIndexers,
- nopruning: true,
- }
- )
- server, _, tearDown := newClientServerEnv(t, netconfig)
- defer tearDown()
- rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
- defer closePeer()
- bc := server.handler.blockchain
- // Assemble the proofs from the different protocols
- header := bc.GetHeaderByNumber(config.ChtSize - 1)
- rlp, _ := rlp.EncodeToBytes(header)
- key := make([]byte, 8)
- binary.BigEndian.PutUint64(key, config.ChtSize-1)
- proofsV2 := HelperTrieResps{
- AuxData: [][]byte{rlp},
- }
- root := light.GetChtRoot(server.db, 0, bc.GetHeaderByNumber(config.ChtSize-1).Hash())
- trie, _ := trie.New(root, trie.NewDatabase(rawdb.NewTable(server.db, light.ChtTablePrefix)))
- trie.Prove(key, 0, &proofsV2.Proofs)
- // Assemble the requests for the different protocols
- requestsV2 := []HelperTrieReq{{
- Type: htCanonical,
- TrieIdx: 0,
- Key: key,
- AuxReq: htAuxHeader,
- }}
- // Send the proof request and verify the response
- sendRequest(rawPeer.app, GetHelperTrieProofsMsg, 42, requestsV2)
- if err := expectResponse(rawPeer.app, HelperTrieProofsMsg, 42, testBufLimit, proofsV2); err != nil {
- t.Errorf("proofs mismatch: %v", err)
- }
- }
- func TestGetBloombitsProofsLes2(t *testing.T) { testGetBloombitsProofs(t, 2) }
- func TestGetBloombitsProofsLes3(t *testing.T) { testGetBloombitsProofs(t, 3) }
- func TestGetBloombitsProofsLes4(t *testing.T) { testGetBloombitsProofs(t, 4) }
- // Tests that bloombits proofs can be correctly retrieved.
- func testGetBloombitsProofs(t *testing.T, protocol int) {
- var (
- config = light.TestServerIndexerConfig
- waitIndexers = func(cIndexer, bIndexer, btIndexer *core.ChainIndexer) {
- for {
- bts, _, _ := btIndexer.Sections()
- if bts >= 1 {
- break
- }
- time.Sleep(10 * time.Millisecond)
- }
- }
- netconfig = testnetConfig{
- blocks: int(config.BloomTrieSize + config.BloomTrieConfirms),
- protocol: protocol,
- indexFn: waitIndexers,
- nopruning: true,
- }
- )
- server, _, tearDown := newClientServerEnv(t, netconfig)
- defer tearDown()
- rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
- defer closePeer()
- bc := server.handler.blockchain
- // Request and verify each bit of the bloom bits proofs
- for bit := 0; bit < 2048; bit++ {
- // Assemble the request and proofs for the bloombits
- key := make([]byte, 10)
- binary.BigEndian.PutUint16(key[:2], uint16(bit))
- // Only the first bloom section has data.
- binary.BigEndian.PutUint64(key[2:], 0)
- requests := []HelperTrieReq{{
- Type: htBloomBits,
- TrieIdx: 0,
- Key: key,
- }}
- var proofs HelperTrieResps
- root := light.GetBloomTrieRoot(server.db, 0, bc.GetHeaderByNumber(config.BloomTrieSize-1).Hash())
- trie, _ := trie.New(root, trie.NewDatabase(rawdb.NewTable(server.db, light.BloomTrieTablePrefix)))
- trie.Prove(key, 0, &proofs.Proofs)
- // Send the proof request and verify the response
- sendRequest(rawPeer.app, GetHelperTrieProofsMsg, 42, requests)
- if err := expectResponse(rawPeer.app, HelperTrieProofsMsg, 42, testBufLimit, proofs); err != nil {
- t.Errorf("bit %d: proofs mismatch: %v", bit, err)
- }
- }
- }
- func TestTransactionStatusLes2(t *testing.T) { testTransactionStatus(t, lpv2) }
- func TestTransactionStatusLes3(t *testing.T) { testTransactionStatus(t, lpv3) }
- func TestTransactionStatusLes4(t *testing.T) { testTransactionStatus(t, lpv4) }
- func testTransactionStatus(t *testing.T, protocol int) {
- netconfig := testnetConfig{
- protocol: protocol,
- nopruning: true,
- }
- server, _, tearDown := newClientServerEnv(t, netconfig)
- defer tearDown()
- rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
- defer closePeer()
- server.handler.addTxsSync = true
- chain := server.handler.blockchain
- var reqID uint64
- test := func(tx *types.Transaction, send bool, expStatus light.TxStatus) {
- reqID++
- if send {
- sendRequest(rawPeer.app, SendTxV2Msg, reqID, types.Transactions{tx})
- } else {
- sendRequest(rawPeer.app, GetTxStatusMsg, reqID, []common.Hash{tx.Hash()})
- }
- if err := expectResponse(rawPeer.app, TxStatusMsg, reqID, testBufLimit, []light.TxStatus{expStatus}); err != nil {
- t.Errorf("transaction status mismatch")
- }
- }
- signer := types.HomesteadSigner{}
- // test error status by sending an underpriced transaction
- tx0, _ := types.SignTx(types.NewTransaction(0, userAddr1, big.NewInt(10000), params.TxGas, nil, nil), signer, bankKey)
- test(tx0, true, light.TxStatus{Status: core.TxStatusUnknown, Error: core.ErrUnderpriced.Error()})
- tx1, _ := types.SignTx(types.NewTransaction(0, userAddr1, big.NewInt(10000), params.TxGas, big.NewInt(100000000000), nil), signer, bankKey)
- test(tx1, false, light.TxStatus{Status: core.TxStatusUnknown}) // query before sending, should be unknown
- test(tx1, true, light.TxStatus{Status: core.TxStatusPending}) // send valid processable tx, should return pending
- test(tx1, true, light.TxStatus{Status: core.TxStatusPending}) // adding it again should not return an error
- tx2, _ := types.SignTx(types.NewTransaction(1, userAddr1, big.NewInt(10000), params.TxGas, big.NewInt(100000000000), nil), signer, bankKey)
- tx3, _ := types.SignTx(types.NewTransaction(2, userAddr1, big.NewInt(10000), params.TxGas, big.NewInt(100000000000), nil), signer, bankKey)
- // send transactions in the wrong order, tx3 should be queued
- test(tx3, true, light.TxStatus{Status: core.TxStatusQueued})
- test(tx2, true, light.TxStatus{Status: core.TxStatusPending})
- // query again, now tx3 should be pending too
- test(tx3, false, light.TxStatus{Status: core.TxStatusPending})
- // generate and add a block with tx1 and tx2 included
- gchain, _ := core.GenerateChain(params.TestChainConfig, chain.GetBlockByNumber(0), ethash.NewFaker(), server.db, 1, func(i int, block *core.BlockGen) {
- block.AddTx(tx1)
- block.AddTx(tx2)
- })
- if _, err := chain.InsertChain(gchain); err != nil {
- panic(err)
- }
- // wait until TxPool processes the inserted block
- for i := 0; i < 10; i++ {
- if pending, _ := server.handler.txpool.Stats(); pending == 1 {
- break
- }
- time.Sleep(100 * time.Millisecond)
- }
- if pending, _ := server.handler.txpool.Stats(); pending != 1 {
- t.Fatalf("pending count mismatch: have %d, want 1", pending)
- }
- // Discard new block announcement
- msg, _ := rawPeer.app.ReadMsg()
- msg.Discard()
- // check if their status is included now
- block1hash := rawdb.ReadCanonicalHash(server.db, 1)
- test(tx1, false, light.TxStatus{Status: core.TxStatusIncluded, Lookup: &rawdb.LegacyTxLookupEntry{BlockHash: block1hash, BlockIndex: 1, Index: 0}})
- test(tx2, false, light.TxStatus{Status: core.TxStatusIncluded, Lookup: &rawdb.LegacyTxLookupEntry{BlockHash: block1hash, BlockIndex: 1, Index: 1}})
- // create a reorg that rolls them back
- gchain, _ = core.GenerateChain(params.TestChainConfig, chain.GetBlockByNumber(0), ethash.NewFaker(), server.db, 2, func(i int, block *core.BlockGen) {})
- if _, err := chain.InsertChain(gchain); err != nil {
- panic(err)
- }
- // wait until TxPool processes the reorg
- for i := 0; i < 10; i++ {
- if pending, _ := server.handler.txpool.Stats(); pending == 3 {
- break
- }
- time.Sleep(100 * time.Millisecond)
- }
- if pending, _ := server.handler.txpool.Stats(); pending != 3 {
- t.Fatalf("pending count mismatch: have %d, want 3", pending)
- }
- // Discard new block announcement
- msg, _ = rawPeer.app.ReadMsg()
- msg.Discard()
- // check if their status is pending again
- test(tx1, false, light.TxStatus{Status: core.TxStatusPending})
- test(tx2, false, light.TxStatus{Status: core.TxStatusPending})
- }
- func TestStopResumeLES3(t *testing.T) { testStopResume(t, lpv3) }
- func TestStopResumeLES4(t *testing.T) { testStopResume(t, lpv4) }
- func testStopResume(t *testing.T, protocol int) {
- netconfig := testnetConfig{
- protocol: protocol,
- simClock: true,
- nopruning: true,
- }
- server, _, tearDown := newClientServerEnv(t, netconfig)
- defer tearDown()
- server.handler.server.costTracker.testing = true
- server.handler.server.costTracker.testCostList = testCostList(testBufLimit / 10)
- rawPeer, closePeer, _ := server.newRawPeer(t, "peer", protocol)
- defer closePeer()
- var (
- reqID uint64
- expBuf = testBufLimit
- testCost = testBufLimit / 10
- )
- header := server.handler.blockchain.CurrentHeader()
- req := func() {
- reqID++
- sendRequest(rawPeer.app, GetBlockHeadersMsg, reqID, &GetBlockHeadersData{Origin: hashOrNumber{Hash: header.Hash()}, Amount: 1})
- }
- for i := 1; i <= 5; i++ {
- // send requests while we still have enough buffer and expect a response
- for expBuf >= testCost {
- req()
- expBuf -= testCost
- if err := expectResponse(rawPeer.app, BlockHeadersMsg, reqID, expBuf, []*types.Header{header}); err != nil {
- t.Errorf("expected response and failed: %v", err)
- }
- }
- // send some more requests in excess and expect a single StopMsg
- c := i
- for c > 0 {
- req()
- c--
- }
- if err := p2p.ExpectMsg(rawPeer.app, StopMsg, nil); err != nil {
- t.Errorf("expected StopMsg and failed: %v", err)
- }
- // wait until the buffer is recharged by half of the limit
- wait := testBufLimit / testBufRecharge / 2
- server.clock.(*mclock.Simulated).Run(time.Millisecond * time.Duration(wait))
- // expect a ResumeMsg with the partially recharged buffer value
- expBuf += testBufRecharge * wait
- if err := p2p.ExpectMsg(rawPeer.app, ResumeMsg, expBuf); err != nil {
- t.Errorf("expected ResumeMsg and failed: %v", err)
- }
- }
- }
|