path: root/les/helper_test.go

// This file contains some shares testing functionality, common to  multiple
// different files and modules being tested.

package les

import (
    "crypto/ecdsa"
    "crypto/rand"
    "math/big"
    "sync"
    "testing"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/ethdb"
    "github.com/ethereum/go-ethereum/event"
    "github.com/ethereum/go-ethereum/les/flowcontrol"
    "github.com/ethereum/go-ethereum/light"
    "github.com/ethereum/go-ethereum/p2p"
    "github.com/ethereum/go-ethereum/p2p/discover"
    "github.com/ethereum/go-ethereum/params"
)

var (
    testBankKey, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
    testBankAddress = crypto.PubkeyToAddress(testBankKey.PublicKey)
    testBankFunds   = big.NewInt(1000000)

    acc1Key, _ = crypto.HexToECDSA("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a")
    acc2Key, _ = crypto.HexToECDSA("49a7b37aa6f6645917e7b807e9d1c00d4fa71f18343b0d4122a4d2df64dd6fee")
    acc1Addr   = crypto.PubkeyToAddress(acc1Key.PublicKey)
    acc2Addr   = crypto.PubkeyToAddress(acc2Key.PublicKey)

    testContractCode         = common.Hex2Bytes("606060405260cc8060106000396000f360606040526000357c01000000000000000000000000000000000000000000000000000000009004806360cd2685146041578063c16431b914606b57603f565b005b6055600480803590602001909190505060a9565b6040518082815260200191505060405180910390f35b60886004808035906020019091908035906020019091905050608a565b005b80600060005083606481101560025790900160005b50819055505b5050565b6000600060005082606481101560025790900160005b5054905060c7565b91905056")
    testContractAddr         common.Address
    testContractCodeDeployed = testContractCode[16:]
    testContractDeployed     = uint64(2)

    testBufLimit = uint64(100)
)

/*
contract test {

    uint256[100] data;

    function Put(uint256 addr, uint256 value) {
        data[addr] = value;
    }

    function Get(uint256 addr) constant returns (uint256 value) {
        return data[addr];
    }
}
*/

func testChainGen(i int, block *core.BlockGen) {
    switch i {
    case 0:
        // In block 1, the test bank sends account #1 some ether.
        tx, _ := types.NewTransaction(block.TxNonce(testBankAddress), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil).SignECDSA(testBankKey)
        block.AddTx(tx)
    case 1:
        // In block 2, the test bank sends some more ether to account #1.
        // acc1Addr passes it on to account #2.
        // acc1Addr creates a test contract.
        tx1, _ := types.NewTransaction(block.TxNonce(testBankAddress), acc1Addr, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(testBankKey)
        nonce := block.TxNonce(acc1Addr)
        tx2, _ := types.NewTransaction(nonce, acc2Addr, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(acc1Key)
        nonce++
        tx3, _ := types.NewContractCreation(nonce, big.NewInt(0), big.NewInt(200000), big.NewInt(0), testContractCode).SignECDSA(acc1Key)
        testContractAddr = crypto.CreateAddress(acc1Addr, nonce)
        block.AddTx(tx1)
        block.AddTx(tx2)
        block.AddTx(tx3)
    case 2:
        // Block 3 is empty but was mined by account #2.
        block.SetCoinbase(acc2Addr)
        block.SetExtra([]byte("yeehaw"))
        data := common.Hex2Bytes("C16431B900000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001")
        tx, _ := types.NewTransaction(block.TxNonce(testBankAddress), testContractAddr, big.NewInt(0), big.NewInt(100000), nil, data).SignECDSA(testBankKey)
        block.AddTx(tx)
    case 3:
        // Block 4 includes blocks 2 and 3 as uncle headers (with modified extra data).
        b2 := block.PrevBlock(1).Header()
        b2.Extra = []byte("foo")
        block.AddUncle(b2)
        b3 := block.PrevBlock(2).Header()
        b3.Extra = []byte("foo")
        block.AddUncle(b3)
        data := common.Hex2Bytes("C16431B900000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002")
        tx, _ := types.NewTransaction(block.TxNonce(testBankAddress), testContractAddr, big.NewInt(0), big.NewInt(100000), nil, data).SignECDSA(testBankKey)
        block.AddTx(tx)
    }
}

func testRCL() RequestCostList {
    cl := make(RequestCostList, len(reqList))
    for i, code := range reqList {
        cl[i].MsgCode = code
        cl[i].BaseCost = 0
        cl[i].ReqCost = 0
    }
    return cl
}

// newTestProtocolManager creates a new protocol manager for testing purposes,
// with the given number of blocks already known, and potential notification
// channels for different events.
func newTestProtocolManager(lightSync bool, blocks int, generator func(int, *core.BlockGen)) (*ProtocolManager, ethdb.Database, *LesOdr, error) {
    var (
        evmux       = new(event.TypeMux)
        pow         = new(core.FakePow)
        db, _       = ethdb.NewMemDatabase()
        genesis     = core.WriteGenesisBlockForTesting(db, core.GenesisAccount{Address: testBankAddress, Balance: testBankFunds})
        chainConfig = &core.ChainConfig{HomesteadBlock: big.NewInt(0)} // homestead set to 0 because of chain maker
        odr         *LesOdr
        chain       BlockChain
    )

    if lightSync {
        odr = NewLesOdr(db)
        chain, _ = light.NewLightChain(odr, chainConfig, pow, evmux)
    } else {
        blockchain, _ := core.NewBlockChain(db, chainConfig, pow, evmux)
        gchain, _ := core.GenerateChain(nil, genesis, db, blocks, generator)
        if _, err := blockchain.InsertChain(gchain); err != nil {
            panic(err)
        }
        chain = blockchain
    }

    pm, err := NewProtocolManager(chainConfig, lightSync, NetworkId, evmux, pow, chain, nil, db, odr, nil)
    if err != nil {
        return nil, nil, nil, err
    }
    if !lightSync {
        srv := &LesServer{protocolManager: pm}
        pm.server = srv

        srv.defParams = &flowcontrol.ServerParams{
            BufLimit:    testBufLimit,
            MinRecharge: 1,
        }

        srv.fcManager = flowcontrol.NewClientManager(50, 10, 1000000000)
        srv.fcCostStats = newCostStats(nil)
    }
    pm.Start()
    return pm, db, odr, nil
}

// newTestProtocolManagerMust creates a new protocol manager for testing purposes,
// with the given number of blocks already known, and potential notification
// channels for different events. In case of an error, the constructor force-
// fails the test.
func newTestProtocolManagerMust(t *testing.T, lightSync bool, blocks int, generator func(int, *core.BlockGen)) (*ProtocolManager, ethdb.Database, *LesOdr) {
    pm, db, odr, err := newTestProtocolManager(lightSync, blocks, generator)
    if err != nil {
        t.Fatalf("Failed to create protocol manager: %v", err)
    }
    return pm, db, odr
}

// testTxPool is a fake, helper transaction pool for testing purposes
type testTxPool struct {
    pool  []*types.Transaction        // Collection of all transactions
    added chan<- []*types.Transaction // Notification channel for new transactions

    lock sync.RWMutex // Protects the transaction pool
}

// AddTransactions appends a batch of transactions to the pool, and notifies any
// listeners if the addition channel is non nil
func (p *testTxPool) AddBatch(txs []*types.Transaction) {
    p.lock.Lock()
    defer p.lock.Unlock()

    p.pool = append(p.pool, txs...)
    if p.added != nil {
        p.added <- txs
    }
}

// GetTransactions returns all the transactions known to the pool
func (p *testTxPool) GetTransactions() types.Transactions {
    p.lock.RLock()
    defer p.lock.RUnlock()

    txs := make([]*types.Transaction, len(p.pool))
    copy(txs, p.pool)

    return txs
}

// newTestTransaction create a new dummy transaction.
func newTestTransaction(from *ecdsa.PrivateKey, nonce uint64, datasize int) *types.Transaction {
    tx := types.NewTransaction(nonce, common.Address{}, big.NewInt(0), big.NewInt(100000), big.NewInt(0), make([]byte, datasize))
    tx, _ = tx.SignECDSA(from)

    return tx
}

// testPeer is a simulated peer to allow testing direct network calls.
type testPeer struct {
    net p2p.MsgReadWriter // Network layer reader/writer to simulate remote messaging
    app *p2p.MsgPipeRW    // Application layer reader/writer to simulate the local side
    *peer
}

// newTestPeer creates a new peer registered at the given protocol manager.
func newTestPeer(t *testing.T, name string, version int, pm *ProtocolManager, shake bool) (*testPeer, <-chan error) {
    // Create a message pipe to communicate through
    app, net := p2p.MsgPipe()

    // Generate a random id and create the peer
    var id discover.NodeID
    rand.Read(id[:])

    peer := pm.newPeer(version, NetworkId, p2p.NewPeer(id, name, nil), net)

    // Start the peer on a new thread
    errc := make(chan error, 1)
    go func() {
        select {
        case pm.newPeerCh <- peer:
            errc <- pm.handle(peer)
        case <-pm.quitSync:
            errc <- p2p.DiscQuitting
        }
    }()
    tp := &testPeer{
        app:  app,
        net:  net,
        peer: peer,
    }
    // Execute any implicitly requested handshakes and return
    if shake {
        td, head, genesis := pm.blockchain.Status()
        headNum := pm.blockchain.CurrentHeader().Number.Uint64()
        tp.handshake(t, td, head, headNum, genesis)
    }
    return tp, errc
}

func newTestPeerPair(name string, version int, pm, pm2 *ProtocolManager) (*peer, <-chan error, *peer, <-chan error) {
    // Create a message pipe to communicate through
    app, net := p2p.MsgPipe()

    // Generate a random id and create the peer
    var id discover.NodeID
    rand.Read(id[:])

    peer := pm.newPeer(version, NetworkId, p2p.NewPeer(id, name, nil), net)
    peer2 := pm2.newPeer(version, NetworkId, p2p.NewPeer(id, name, nil), app)

    // Start the peer on a new thread
    errc := make(chan error, 1)
    errc2 := make(chan error, 1)
    go func() {
        select {
        case pm.newPeerCh <- peer:
            errc <- pm.handle(peer)
        case <-pm.quitSync:
            errc <- p2p.DiscQuitting
        }
    }()
    go func() {
        select {
        case pm2.newPeerCh <- peer2:
            errc2 <- pm2.handle(peer2)
        case <-pm2.quitSync:
            errc2 <- p2p.DiscQuitting
        }
    }()
    return peer, errc, peer2, errc2
}

// handshake simulates a trivial handshake that expects the same state from the
// remote side as we are simulating locally.
func (p *testPeer) handshake(t *testing.T, td *big.Int, head common.Hash, headNum uint64, genesis common.Hash) {
    var expList keyValueList
    expList = expList.add("protocolVersion", uint64(p.version))
    expList = expList.add("networkId", uint64(NetworkId))
    expList = expList.add("headTd", td)
    expList = expList.add("headHash", head)
    expList = expList.add("headNum", headNum)
    expList = expList.add("genesisHash", genesis)
    sendList := make(keyValueList, len(expList))
    copy(sendList, expList)
    expList = expList.add("serveHeaders", nil)
    expList = expList.add("serveChainSince", uint64(0))
    expList = expList.add("serveStateSince", uint64(0))
    expList = expList.add("txRelay", nil)
    expList = expList.add("flowControl/BL", testBufLimit)
    expList = expList.add("flowControl/MRR", uint64(1))
    expList = expList.add("flowControl/MRC", testRCL())

    if err := p2p.ExpectMsg(p.app, StatusMsg, expList); err != nil {
        t.Fatalf("status recv: %v", err)
    }
    if err := p2p.Send(p.app, StatusMsg, sendList); err != nil {
        t.Fatalf("status send: %v", err)
    }

    p.fcServerParams = &flowcontrol.ServerParams{
        BufLimit:    testBufLimit,
        MinRecharge: 1,
    }
}

// close terminates the local side of the peer, notifying the remote protocol
// manager of termination.
func (p *testPeer) close() {
    p.app.Close()
}