light: light chain, VM env and tx pool

1 files changed, 323 insertions, 0 deletions

diff --git a/light/odr_test.go b/light/odr_test.go
new file mode 100644
index 000000000..1cf9bce3c
--- /dev/null
+++ b/light/odr_test.go
@@ -0,0 +1,323 @@
+package light
+
+import (
+	"bytes"
+	"errors"
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/event"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/ethereum/go-ethereum/trie"
+	"golang.org/x/net/context"
+)
+
+var (
+	testBankKey, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+	testBankAddress = crypto.PubkeyToAddress(testBankKey.PublicKey)
+	testBankFunds   = big.NewInt(100000000)
+
+	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
+)
+
+type testOdr struct {
+	OdrBackend
+	sdb, ldb ethdb.Database
+	disable  bool
+}
+
+func (odr *testOdr) Database() ethdb.Database {
+	return odr.ldb
+}
+
+var ErrOdrDisabled = errors.New("ODR disabled")
+
+func (odr *testOdr) Retrieve(ctx context.Context, req OdrRequest) error {
+	if odr.disable {
+		return ErrOdrDisabled
+	}
+	switch req := req.(type) {
+	case *BlockRequest:
+		req.Rlp = core.GetBodyRLP(odr.sdb, req.Hash, core.GetBlockNumber(odr.sdb, req.Hash))
+	case *ReceiptsRequest:
+		req.Receipts = core.GetBlockReceipts(odr.sdb, req.Hash, core.GetBlockNumber(odr.sdb, req.Hash))
+	case *TrieRequest:
+		t, _ := trie.New(req.Id.Root, odr.sdb)
+		req.Proof = t.Prove(req.Key)
+	case *CodeRequest:
+		req.Data, _ = odr.sdb.Get(req.Hash[:])
+	}
+	req.StoreResult(odr.ldb)
+	return nil
+}
+
+type odrTestFn func(ctx context.Context, db ethdb.Database, bc *core.BlockChain, lc *LightChain, bhash common.Hash) []byte
+
+func TestOdrGetBlockLes1(t *testing.T) { testChainOdr(t, 1, 1, odrGetBlock) }
+
+func odrGetBlock(ctx context.Context, db ethdb.Database, bc *core.BlockChain, lc *LightChain, bhash common.Hash) []byte {
+	var block *types.Block
+	if bc != nil {
+		block = bc.GetBlockByHash(bhash)
+	} else {
+		block, _ = lc.GetBlockByHash(ctx, bhash)
+	}
+	if block == nil {
+		return nil
+	}
+	rlp, _ := rlp.EncodeToBytes(block)
+	return rlp
+}
+
+func TestOdrGetReceiptsLes1(t *testing.T) { testChainOdr(t, 1, 1, odrGetReceipts) }
+
+func odrGetReceipts(ctx context.Context, db ethdb.Database, bc *core.BlockChain, lc *LightChain, bhash common.Hash) []byte {
+	var receipts types.Receipts
+	if bc != nil {
+		receipts = core.GetBlockReceipts(db, bhash, core.GetBlockNumber(db, bhash))
+	} else {
+		receipts, _ = GetBlockReceipts(ctx, lc.Odr(), bhash, core.GetBlockNumber(db, bhash))
+	}
+	if receipts == nil {
+		return nil
+	}
+	rlp, _ := rlp.EncodeToBytes(receipts)
+	return rlp
+}
+
+func TestOdrAccountsLes1(t *testing.T) { testChainOdr(t, 1, 1, odrAccounts) }
+
+func odrAccounts(ctx context.Context, db ethdb.Database, bc *core.BlockChain, lc *LightChain, bhash common.Hash) []byte {
+	dummyAddr := common.HexToAddress("1234567812345678123456781234567812345678")
+	acc := []common.Address{testBankAddress, acc1Addr, acc2Addr, dummyAddr}
+
+	var res []byte
+	for _, addr := range acc {
+		if bc != nil {
+			header := bc.GetHeaderByHash(bhash)
+			st, err := state.New(header.Root, db)
+			if err == nil {
+				bal := st.GetBalance(addr)
+				rlp, _ := rlp.EncodeToBytes(bal)
+				res = append(res, rlp...)
+			}
+		} else {
+			header := lc.GetHeaderByHash(bhash)
+			st := NewLightState(StateTrieID(header), lc.Odr())
+			bal, err := st.GetBalance(ctx, addr)
+			if err == nil {
+				rlp, _ := rlp.EncodeToBytes(bal)
+				res = append(res, rlp...)
+			}
+		}
+	}
+
+	return res
+}
+
+func TestOdrContractCallLes1(t *testing.T) { testChainOdr(t, 1, 2, odrContractCall) }
+
+// fullcallmsg is the message type used for call transations.
+type fullcallmsg struct {
+	from          *state.StateObject
+	to            *common.Address
+	gas, gasPrice *big.Int
+	value         *big.Int
+	data          []byte
+}
+
+// accessor boilerplate to implement core.Message
+func (m fullcallmsg) From() (common.Address, error)         { return m.from.Address(), nil }
+func (m fullcallmsg) FromFrontier() (common.Address, error) { return m.from.Address(), nil }
+func (m fullcallmsg) Nonce() uint64                         { return 0 }
+func (m fullcallmsg) CheckNonce() bool                      { return false }
+func (m fullcallmsg) To() *common.Address                   { return m.to }
+func (m fullcallmsg) GasPrice() *big.Int                    { return m.gasPrice }
+func (m fullcallmsg) Gas() *big.Int                         { return m.gas }
+func (m fullcallmsg) Value() *big.Int                       { return m.value }
+func (m fullcallmsg) Data() []byte                          { return m.data }
+
+// callmsg is the message type used for call transations.
+type lightcallmsg struct {
+	from          *StateObject
+	to            *common.Address
+	gas, gasPrice *big.Int
+	value         *big.Int
+	data          []byte
+}
+
+// accessor boilerplate to implement core.Message
+func (m lightcallmsg) From() (common.Address, error)         { return m.from.Address(), nil }
+func (m lightcallmsg) FromFrontier() (common.Address, error) { return m.from.Address(), nil }
+func (m lightcallmsg) Nonce() uint64                         { return 0 }
+func (m lightcallmsg) CheckNonce() bool                      { return false }
+func (m lightcallmsg) To() *common.Address                   { return m.to }
+func (m lightcallmsg) GasPrice() *big.Int                    { return m.gasPrice }
+func (m lightcallmsg) Gas() *big.Int                         { return m.gas }
+func (m lightcallmsg) Value() *big.Int                       { return m.value }
+func (m lightcallmsg) Data() []byte                          { return m.data }
+
+func odrContractCall(ctx context.Context, db ethdb.Database, bc *core.BlockChain, lc *LightChain, bhash common.Hash) []byte {
+	data := common.Hex2Bytes("60CD26850000000000000000000000000000000000000000000000000000000000000000")
+
+	var res []byte
+	for i := 0; i < 3; i++ {
+		data[35] = byte(i)
+		if bc != nil {
+			header := bc.GetHeaderByHash(bhash)
+			statedb, err := state.New(header.Root, db)
+			if err == nil {
+				from := statedb.GetOrNewStateObject(testBankAddress)
+				from.SetBalance(common.MaxBig)
+
+				msg := fullcallmsg{
+					from:     from,
+					gas:      big.NewInt(100000),
+					gasPrice: big.NewInt(0),
+					value:    big.NewInt(0),
+					data:     data,
+					to:       &testContractAddr,
+				}
+
+				vmenv := core.NewEnv(statedb, testChainConfig(), bc, msg, header, vm.Config{})
+				gp := new(core.GasPool).AddGas(common.MaxBig)
+				ret, _, _ := core.ApplyMessage(vmenv, msg, gp)
+				res = append(res, ret...)
+			}
+		} else {
+			header := lc.GetHeaderByHash(bhash)
+			state := NewLightState(StateTrieID(header), lc.Odr())
+			from, err := state.GetOrNewStateObject(ctx, testBankAddress)
+			if err == nil {
+				from.SetBalance(common.MaxBig)
+
+				msg := lightcallmsg{
+					from:     from,
+					gas:      big.NewInt(100000),
+					gasPrice: big.NewInt(0),
+					value:    big.NewInt(0),
+					data:     data,
+					to:       &testContractAddr,
+				}
+
+				vmenv := NewEnv(ctx, state, testChainConfig(), lc, msg, header, vm.Config{})
+				gp := new(core.GasPool).AddGas(common.MaxBig)
+				ret, _, _ := core.ApplyMessage(vmenv, msg, gp)
+				if vmenv.Error() == nil {
+					res = append(res, ret...)
+				}
+			}
+		}
+	}
+	return res
+}
+
+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(1000000), 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 testChainOdr(t *testing.T, protocol int, expFail uint64, fn odrTestFn) {
+	var (
+		evmux   = new(event.TypeMux)
+		pow     = new(core.FakePow)
+		sdb, _  = ethdb.NewMemDatabase()
+		ldb, _  = ethdb.NewMemDatabase()
+		genesis = core.WriteGenesisBlockForTesting(sdb, core.GenesisAccount{Address: testBankAddress, Balance: testBankFunds})
+	)
+	core.WriteGenesisBlockForTesting(ldb, core.GenesisAccount{Address: testBankAddress, Balance: testBankFunds})
+	// Assemble the test environment
+	blockchain, _ := core.NewBlockChain(sdb, testChainConfig(), pow, evmux)
+	gchain, _ := core.GenerateChain(nil, genesis, sdb, 4, testChainGen)
+	if _, err := blockchain.InsertChain(gchain); err != nil {
+		panic(err)
+	}
+
+	odr := &testOdr{sdb: sdb, ldb: ldb}
+	lightchain, _ := NewLightChain(odr, testChainConfig(), pow, evmux)
+	lightchain.SetValidator(bproc{})
+	headers := make([]*types.Header, len(gchain))
+	for i, block := range gchain {
+		headers[i] = block.Header()
+	}
+	if _, err := lightchain.InsertHeaderChain(headers, 1); err != nil {
+		panic(err)
+	}
+
+	test := func(expFail uint64) {
+		for i := uint64(0); i <= blockchain.CurrentHeader().GetNumberU64(); i++ {
+			bhash := core.GetCanonicalHash(sdb, i)
+			b1 := fn(NoOdr, sdb, blockchain, nil, bhash)
+			ctx, _ := context.WithTimeout(context.Background(), 200*time.Millisecond)
+			b2 := fn(ctx, ldb, nil, lightchain, bhash)
+			eq := bytes.Equal(b1, b2)
+			exp := i < expFail
+			if exp && !eq {
+				t.Errorf("odr mismatch")
+			}
+			if !exp && eq {
+				t.Errorf("unexpected odr match")
+			}
+		}
+	}
+
+	odr.disable = true
+	// expect retrievals to fail (except genesis block) without a les peer
+	test(expFail)
+	odr.disable = false
+	// expect all retrievals to pass
+	test(5)
+	odr.disable = true
+	// still expect all retrievals to pass, now data should be cached locally
+	test(5)
+}