Merge branch 'develop' of github.com-obscure:ethereum/go-ethereum into develop

README.md

@@ -40,7 +40,7 @@ godep go build -v ./cmd/geth
 
 Instead of `build`, you can use `install` which will also install the resulting binary.
 
-For prerequisites and detailed build instructions please see the [Wiki](https://github.com/ethereum/go-ethereum/wiki/Building-Ethereum(Go))
+For prerequisites and detailed build instructions please see the [Wiki](https://github.com/ethereum/go-ethereum/wiki/Building-Ethereum)
 
 If you intend to develop on go-ethereum, check the [Developers' Guide](https://github.com/ethereum/go-ethereum/wiki/Developers'-Guide)
 

cmd/geth/block_go_test.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"path"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/accounts"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/eth"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/tests"
+)
+
+// TODO: refactor test setup & execution to better align with vm and tx tests
+// TODO: refactor to avoid duplication with cmd/geth/blocktest.go
+func TestBcValidBlockTests(t *testing.T) {
+	runBlockTestsInFile("../../tests/files/BlockTests/bcValidBlockTest.json", t)
+}
+
+/*
+func TestBcUncleTests(t *testing.T) {
+	runBlockTestsInFile("../../tests/files/BlockTests/bcUncleTest.json", t)
+}
+*/
+
+func runBlockTestsInFile(filepath string, t *testing.T) {
+	bt, err := tests.LoadBlockTests(filepath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, test := range bt {
+		runTest(name, test, t)
+	}
+}
+
+func runTest(name string, test *tests.BlockTest, t *testing.T) {
+	t.Log("Running test: ", name)
+	cfg := testEthConfig()
+	ethereum, err := eth.New(cfg)
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+
+	err = ethereum.Start()
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+
+	// import the genesis block
+	ethereum.ResetWithGenesisBlock(test.Genesis)
+
+	// import pre accounts
+	statedb, err := test.InsertPreState(ethereum.StateDb())
+	if err != nil {
+		t.Fatalf("InsertPreState: %v", err)
+	}
+
+	// insert the test blocks, which will execute all transactions
+	if err := test.InsertBlocks(ethereum.ChainManager()); err != nil {
+		t.Fatalf("Block Test load error: %v %T", err, err)
+	}
+
+	if err := test.ValidatePostState(statedb); err != nil {
+		t.Fatal("post state validation failed: %v", err)
+	}
+	t.Log("Test passed: ", name)
+}
+
+func testEthConfig() *eth.Config {
+	ks := crypto.NewKeyStorePassphrase(path.Join(common.DefaultDataDir(), "keys"))
+
+	return &eth.Config{
+		DataDir:        common.DefaultDataDir(),
+		LogLevel:       5,
+		Etherbase:      "primary",
+		AccountManager: accounts.NewManager(ks),
+		NewDB:          func(path string) (common.Database, error) { return ethdb.NewMemDatabase() },
+	}
+}

cmd/geth/blocktest.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"os"
 
 	"github.com/codegangsta/cli"
 	"github.com/ethereum/go-ethereum/cmd/utils"
@@ -12,7 +13,7 @@ import (
 )
 
 var blocktestCmd = cli.Command{
-	Action: runblocktest,
+	Action: runBlockTest,
 	Name:   "blocktest",
 	Usage:  `loads a block test file`,
 	Description: `
@@ -25,27 +26,78 @@ be able to interact with the chain defined by the test.
 `,
 }
 
-func runblocktest(ctx *cli.Context) {
+func runBlockTest(ctx *cli.Context) {
-	if len(ctx.Args()) != 3 {
+	var (
-		utils.Fatalf("Usage: ethereum blocktest <path-to-test-file> <test-name> {rpc, norpc}")
+		file, testname string
+		rpc            bool
+	)
+	args := ctx.Args()
+	switch {
+	case len(args) == 1:
+		file = args[0]
+	case len(args) == 2:
+		file, testname = args[0], args[1]
+	case len(args) == 3:
+		file, testname = args[0], args[1]
+		rpc = true
+	default:
+		utils.Fatalf(`Usage: ethereum blocktest <path-to-test-file> [ <test-name> [ "rpc" ] ]`)
 	}
-	file, testname, startrpc := ctx.Args()[0], ctx.Args()[1], ctx.Args()[2]
-
 	bt, err := tests.LoadBlockTests(file)
 	if err != nil {
 		utils.Fatalf("%v", err)
 	}
+
+	// run all tests if no test name is specified
+	if testname == "" {
+		ecode := 0
+		for name, test := range bt {
+			fmt.Printf("----------------- Running Block Test %q\n", name)
+			ethereum, err := runOneBlockTest(ctx, test)
+			if err != nil {
+				fmt.Println(err)
+				fmt.Println("FAIL")
+				ecode = 1
+			}
+			if ethereum != nil {
+				ethereum.Stop()
+				ethereum.WaitForShutdown()
+			}
+		}
+		os.Exit(ecode)
+		return
+	}
+	// otherwise, run the given test
 	test, ok := bt[testname]
 	if !ok {
 		utils.Fatalf("Test file does not contain test named %q", testname)
 	}
+	ethereum, err := runOneBlockTest(ctx, test)
+	if err != nil {
+		utils.Fatalf("%v", err)
+	}
+	defer ethereum.Stop()
+	if rpc {
+		fmt.Println("Block Test post state validated, starting RPC interface.")
+		startEth(ctx, ethereum)
+		utils.StartRPC(ethereum, ctx)
+		ethereum.WaitForShutdown()
+	}
+}
 
+func runOneBlockTest(ctx *cli.Context, test *tests.BlockTest) (*eth.Ethereum, error) {
 	cfg := utils.MakeEthConfig(ClientIdentifier, Version, ctx)
 	cfg.NewDB = func(path string) (common.Database, error) { return ethdb.NewMemDatabase() }
 	cfg.MaxPeers = 0 // disable network
+	cfg.Shh = false  // disable whisper
+	cfg.NAT = nil    // disable port mapping
+
 	ethereum, err := eth.New(cfg)
 	if err != nil {
-		utils.Fatalf("%v", err)
+		return nil, err
+	}
+	if err := ethereum.Start(); err != nil {
+		return nil, err
 	}
 
 	// import the genesis block
@@ -54,27 +106,16 @@ func runblocktest(ctx *cli.Context) {
 	// import pre accounts
 	statedb, err := test.InsertPreState(ethereum.StateDb())
 	if err != nil {
-		utils.Fatalf("could not insert genesis accounts: %v", err)
+		return ethereum, fmt.Errorf("InsertPreState: %v", err)
 	}
 
 	// insert the test blocks, which will execute all transactions
-	chain := ethereum.ChainManager()
+	if err := test.InsertBlocks(ethereum.ChainManager()); err != nil {
-	if err := chain.InsertChain(test.Blocks); err != nil {
+		return ethereum, fmt.Errorf("Block Test load error: %v %T", err, err)
-		utils.Fatalf("Block Test load error: %v %T", err, err)
-	} else {
-		fmt.Println("Block Test chain loaded")
 	}
-
+	fmt.Println("chain loaded")
 	if err := test.ValidatePostState(statedb); err != nil {
-		utils.Fatalf("post state validation failed: %v", err)
+		return ethereum, fmt.Errorf("post state validation failed: %v", err)
-	}
-	fmt.Println("Block Test post state validated, starting ethereum.")
-
-	if startrpc == "rpc" {
-		startEth(ctx, ethereum)
-		utils.StartRPC(ethereum, ctx)
-		ethereum.WaitForShutdown()
-	} else {
-		startEth(ctx, ethereum)
 	}
+	return ethereum, nil
 }

eth/backend.go

@@ -173,7 +173,10 @@ func New(config *Config) (*Ethereum, error) {
 	if err != nil {
 		return nil, err
 	}
-	extraDb, err := ethdb.NewLDBDatabase(path.Join(config.DataDir, "extra"))
+	extraDb, err := newdb(path.Join(config.DataDir, "extra"))
+	if err != nil {
+		return nil, err
+	}
 
 	// Perform database sanity checks
 	d, _ := blockDb.Get([]byte("ProtocolVersion"))

rpc/responses.go

@@ -24,7 +24,6 @@ type BlockRes struct {
 	Size            *hexnum           `json:"size"`
 	ExtraData       *hexdata          `json:"extraData"`
 	GasLimit        *hexnum           `json:"gasLimit"`
-	MinGasPrice     *hexnum           `json:"minGasPrice"`
 	GasUsed         *hexnum           `json:"gasUsed"`
 	UnixTimestamp   *hexnum           `json:"timestamp"`
 	Transactions    []*TransactionRes `json:"transactions"`
@@ -48,7 +47,6 @@ func (b *BlockRes) MarshalJSON() ([]byte, error) {
 			Size            *hexnum           `json:"size"`
 			ExtraData       *hexdata          `json:"extraData"`
 			GasLimit        *hexnum           `json:"gasLimit"`
-			MinGasPrice     *hexnum           `json:"minGasPrice"`
 			GasUsed         *hexnum           `json:"gasUsed"`
 			UnixTimestamp   *hexnum           `json:"timestamp"`
 			Transactions    []*TransactionRes `json:"transactions"`
@@ -69,7 +67,6 @@ func (b *BlockRes) MarshalJSON() ([]byte, error) {
 		ext.Size = b.Size
 		ext.ExtraData = b.ExtraData
 		ext.GasLimit = b.GasLimit
-		ext.MinGasPrice = b.MinGasPrice
 		ext.GasUsed = b.GasUsed
 		ext.UnixTimestamp = b.UnixTimestamp
 		ext.Transactions = b.Transactions
@@ -94,7 +91,6 @@ func (b *BlockRes) MarshalJSON() ([]byte, error) {
 			Size            *hexnum    `json:"size"`
 			ExtraData       *hexdata   `json:"extraData"`
 			GasLimit        *hexnum    `json:"gasLimit"`
-			MinGasPrice     *hexnum    `json:"minGasPrice"`
 			GasUsed         *hexnum    `json:"gasUsed"`
 			UnixTimestamp   *hexnum    `json:"timestamp"`
 			Transactions    []*hexdata `json:"transactions"`
@@ -115,7 +111,6 @@ func (b *BlockRes) MarshalJSON() ([]byte, error) {
 		ext.Size = b.Size
 		ext.ExtraData = b.ExtraData
 		ext.GasLimit = b.GasLimit
-		ext.MinGasPrice = b.MinGasPrice
 		ext.GasUsed = b.GasUsed
 		ext.UnixTimestamp = b.UnixTimestamp
 		ext.Transactions = make([]*hexdata, len(b.Transactions))
@@ -151,7 +146,6 @@ func NewBlockRes(block *types.Block, fullTx bool) *BlockRes {
 	res.Size = newHexNum(block.Size().Int64())
 	res.ExtraData = newHexData(block.Header().Extra)
 	res.GasLimit = newHexNum(block.GasLimit())
-	// res.MinGasPrice =
 	res.GasUsed = newHexNum(block.GasUsed())
 	res.UnixTimestamp = newHexNum(block.Time())
 

tests/block_test_util.go

@@ -12,6 +12,7 @@ import (
 	"strings"
 
 	"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/rlp"
@@ -73,8 +74,8 @@ type btBlock struct {
 
 type BlockTest struct {
 	Genesis *types.Block
-	Blocks  []*types.Block
 
+	json        *btJSON
 	preAccounts map[string]btAccount
 }
 
@@ -88,7 +89,7 @@ func LoadBlockTests(file string) (map[string]*BlockTest, error) {
 	for name, in := range bt {
 		var err error
 		if out[name], err = convertTest(in); err != nil {
-			return nil, fmt.Errorf("bad test %q: %v", err)
+			return out, fmt.Errorf("bad test %q: %v", name, err)
 		}
 	}
 	return out, nil
@@ -124,6 +125,15 @@ func (t *BlockTest) InsertPreState(db common.Database) (*state.StateDB, error) {
 	return statedb, nil
 }
 
+// InsertBlocks loads the test's blocks into the given chain.
+func (t *BlockTest) InsertBlocks(chain *core.ChainManager) error {
+	blocks, err := t.convertBlocks()
+	if err != nil {
+		return err
+	}
+	return chain.InsertChain(blocks)
+}
+
 func (t *BlockTest) ValidatePostState(statedb *state.StateDB) error {
 	for addrString, acct := range t.preAccounts {
 		// XXX: is is worth it checking for errors here?
@@ -149,6 +159,21 @@ func (t *BlockTest) ValidatePostState(statedb *state.StateDB) error {
 	return nil
 }
 
+func (t *BlockTest) convertBlocks() (blocks []*types.Block, err error) {
+	// the conversion handles errors by catching panics.
+	// you might consider this ugly, but the alternative (passing errors)
+	// would be much harder to read.
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			buf := make([]byte, 64<<10)
+			buf = buf[:runtime.Stack(buf, false)]
+			err = fmt.Errorf("%v\n%s", recovered, buf)
+		}
+	}()
+	blocks = mustConvertBlocks(t.json.Blocks)
+	return blocks, nil
+}
+
 func convertTest(in *btJSON) (out *BlockTest, err error) {
 	// the conversion handles errors by catching panics.
 	// you might consider this ugly, but the alternative (passing errors)
@@ -160,9 +185,8 @@ func convertTest(in *btJSON) (out *BlockTest, err error) {
 			err = fmt.Errorf("%v\n%s", recovered, buf)
 		}
 	}()
-	out = &BlockTest{preAccounts: in.Pre}
+	out = &BlockTest{preAccounts: in.Pre, json: in}
 	out.Genesis = mustConvertGenesis(in.GenesisBlockHeader)
-	out.Blocks = mustConvertBlocks(in.Blocks)
 	return out, err
 }
 
@@ -187,13 +211,13 @@ func mustConvertHeader(in btHeader) *types.Header {
 		UncleHash:   mustConvertHash(in.UncleHash),
 		ParentHash:  mustConvertHash(in.ParentHash),
 		Extra:       mustConvertBytes(in.ExtraData),
-		GasUsed:     mustConvertBigInt(in.GasUsed),
+		GasUsed:     mustConvertBigInt(in.GasUsed, 10),
-		GasLimit:    mustConvertBigInt(in.GasLimit),
+		GasLimit:    mustConvertBigInt(in.GasLimit, 10),
-		Difficulty:  mustConvertBigInt(in.Difficulty),
+		Difficulty:  mustConvertBigInt(in.Difficulty, 10),
-		Time:        mustConvertUint(in.Timestamp),
+		Time:        mustConvertUint(in.Timestamp, 10),
 	}
 	// XXX cheats? :-)
-	header.SetNonce(common.BytesToHash(mustConvertBytes(in.Nonce)).Big().Uint64())
+	header.SetNonce(mustConvertUint(in.Nonce, 16))
 	return header
 }
 
@@ -203,7 +227,7 @@ func mustConvertBlocks(testBlocks []btBlock) []*types.Block {
 		var b types.Block
 		r := bytes.NewReader(mustConvertBytes(inb.Rlp))
 		if err := rlp.Decode(r, &b); err != nil {
-			panic(fmt.Errorf("invalid block %d: %q", i, inb.Rlp))
+			panic(fmt.Errorf("invalid block %d: %q\nerror: %v", i, inb.Rlp, err))
 		}
 		out = append(out, &b)
 	}
@@ -214,10 +238,10 @@ func mustConvertBytes(in string) []byte {
 	if in == "0x" {
 		return []byte{}
 	}
-	h := strings.TrimPrefix(unfuckCPPHexInts(in), "0x")
+	h := unfuckFuckedHex(strings.TrimPrefix(in, "0x"))
 	out, err := hex.DecodeString(h)
 	if err != nil {
-		panic(fmt.Errorf("invalid hex: %q", h))
+		panic(fmt.Errorf("invalid hex: %q: ", h, err))
 	}
 	return out
 }
@@ -246,16 +270,18 @@ func mustConvertBloom(in string) types.Bloom {
 	return types.BytesToBloom(out)
 }
 
-func mustConvertBigInt(in string) *big.Int {
+func mustConvertBigInt(in string, base int) *big.Int {
-	out, ok := new(big.Int).SetString(unfuckCPPHexInts(in), 0)
+	in = prepInt(base, in)
+	out, ok := new(big.Int).SetString(in, base)
 	if !ok {
 		panic(fmt.Errorf("invalid integer: %q", in))
 	}
 	return out
 }
 
-func mustConvertUint(in string) uint64 {
+func mustConvertUint(in string, base int) uint64 {
-	out, err := strconv.ParseUint(unfuckCPPHexInts(in), 0, 64)
+	in = prepInt(base, in)
+	out, err := strconv.ParseUint(in, base, 64)
 	if err != nil {
 		panic(fmt.Errorf("invalid integer: %q", in))
 	}
@@ -292,12 +318,28 @@ func findLine(data []byte, offset int64) (line int) {
 	return
 }
 
-func unfuckCPPHexInts(s string) string {
+// Nothing to see here, please move along...
-	if s == "0x" { // no respect for the empty value :(
+func prepInt(base int, s string) string {
-		return "0x00"
+	if base == 16 {
-	}
+		if strings.HasPrefix(s, "0x") {
-	if (len(s) % 2) != 0 { // motherfucking nibbles
+			s = s[2:]
-		return "0x0" + s[2:]
+		}
+		if len(s) == 0 {
+			s = "00"
+		}
+		s = nibbleFix(s)
+	}
+	return s
+}
+
+// don't ask
+func unfuckFuckedHex(almostHex string) string {
+	return nibbleFix(strings.Replace(almostHex, "v", "", -1))
+}
+
+func nibbleFix(s string) string {
+	if len(s)%2 != 0 {
+		s = "0" + s
 	}
 	return s
 }

tests/transaction_test_util.go

@@ -2,8 +2,8 @@ package tests
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
-	"math/big"
 	"runtime"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -49,70 +49,44 @@ func RunTransactionTests(file string, notWorking map[string]bool) error {
 }
 
 func runTest(txTest TransactionTest) (err error) {
-	expectedSender, expectedTo, expectedData, rlpBytes, expectedGasLimit, expectedGasPrice, expectedValue, expectedR, expectedS, expectedNonce, expectedV, err := convertTestTypes(txTest)
+	tx := new(types.Transaction)
+	err = rlp.DecodeBytes(mustConvertBytes(txTest.Rlp), tx)
 
 	if err != nil {
-		if txTest.Sender == "" { // tx is invalid and this is expected (test OK)
+		if txTest.Sender == "" {
+			// RLP decoding failed and this is expected (test OK)
 			return nil
 		} else {
-			return err // tx is invalid and this is NOT expected (test FAIL)
+			// RLP decoding failed but is expected to succeed (test FAIL)
-		}
+			return errors.New("RLP decoding failed when expected to succeed")
-	}
-	tx := new(types.Transaction)
-	rlp.DecodeBytes(rlpBytes, tx)
-	//fmt.Println("HURR tx: %v", tx)
-	sender, err := tx.From()
-	if err != nil {
-		return err
-	}
-
-	if expectedSender != sender {
-		return fmt.Errorf("Sender mismatch: %v %v", expectedSender, sender)
-	}
-	if !bytes.Equal(expectedData, tx.Payload) {
-		return fmt.Errorf("Tx input data mismatch: %#v %#v", expectedData, tx.Payload)
-	}
-	if expectedGasLimit.Cmp(tx.GasLimit) != 0 {
-		return fmt.Errorf("GasLimit mismatch: %v %v", expectedGasLimit, tx.GasLimit)
-	}
-	if expectedGasPrice.Cmp(tx.Price) != 0 {
-		return fmt.Errorf("GasPrice mismatch: %v %v", expectedGasPrice, tx.Price)
-	}
-	if expectedNonce != tx.AccountNonce {
-		return fmt.Errorf("Nonce mismatch: %v %v", expectedNonce, tx.AccountNonce)
-	}
-	if expectedR.Cmp(tx.R) != 0 {
-		return fmt.Errorf("R mismatch: %v %v", expectedR, tx.R)
-	}
-	if expectedS.Cmp(tx.S) != 0 {
-		return fmt.Errorf("S mismatch: %v %v", expectedS, tx.S)
-	}
-	if expectedV != uint64(tx.V) {
-		return fmt.Errorf("V mismatch: %v %v", expectedV, uint64(tx.V))
-	}
-	if tx.Recipient == nil {
-		if expectedTo != common.BytesToAddress([]byte{}) { // "empty" or "zero" address
-			return fmt.Errorf("To mismatch when recipient is nil (contract creation): %v", expectedTo)
-		}
-	} else {
-		if expectedTo != *tx.Recipient {
-			return fmt.Errorf("To mismatch: %v %v", expectedTo, *tx.Recipient)
 		}
 	}
 
-	if expectedValue.Cmp(tx.Amount) != 0 {
+	validationError := verifyTxFields(txTest, tx)
-		return fmt.Errorf("Value mismatch: %v %v", expectedValue, tx.Amount)
+	if txTest.Sender == "" {
+		if validationError != nil {
+			// RLP decoding works but validation should fail (test OK)
+			return nil
+		} else {
+			// RLP decoding works but validation should fail (test FAIL)
+			// (this should not be possible but added here for completeness)
+			return errors.New("Field validations succeeded but should fail")
+		}
 	}
 
-	return nil
+	if txTest.Sender != "" {
+		if validationError == nil {
+			// RLP decoding works and validations pass (test OK)
+			return nil
+		} else {
+			// RLP decoding works and validations pass (test FAIL)
+			return errors.New("Field validations failed after RLP decoding")
+		}
+	}
+	return errors.New("Should not happen: verify RLP decoding and field validation")
 }
 
-func convertTestTypes(txTest TransactionTest) (sender, to common.Address,
+func verifyTxFields(txTest TransactionTest, decodedTx *types.Transaction) (err error) {
-	txInputData, rlpBytes []byte,
-	gasLimit, gasPrice, value, r, s *big.Int,
-	nonce, v uint64,
-	err error) {
-
 	defer func() {
 		if recovered := recover(); recovered != nil {
 			buf := make([]byte, 64<<10)
@@ -121,21 +95,66 @@ func convertTestTypes(txTest TransactionTest) (sender, to common.Address,
 		}
 	}()
 
-	sender = mustConvertAddress(txTest.Sender)
+	decodedSender, err := decodedTx.From()
-	to = mustConvertAddress(txTest.Transaction.To)
+	if err != nil {
+		return err
+	}
 
-	txInputData = mustConvertBytes(txTest.Transaction.Data)
+	expectedSender := mustConvertAddress(txTest.Sender)
-	rlpBytes = mustConvertBytes(txTest.Rlp)
+	if expectedSender != decodedSender {
+		return fmt.Errorf("Sender mismatch: %v %v", expectedSender, decodedSender)
+	}
 
-	gasLimit = mustConvertBigInt(txTest.Transaction.GasLimit)
+	expectedData := mustConvertBytes(txTest.Transaction.Data)
-	gasPrice = mustConvertBigInt(txTest.Transaction.GasPrice)
+	if !bytes.Equal(expectedData, decodedTx.Payload) {
-	value = mustConvertBigInt(txTest.Transaction.Value)
+		return fmt.Errorf("Tx input data mismatch: %#v %#v", expectedData, decodedTx.Payload)
+	}
 
-	r = common.Bytes2Big(mustConvertBytes(txTest.Transaction.R))
+	expectedGasLimit := mustConvertBigInt(txTest.Transaction.GasLimit, 16)
-	s = common.Bytes2Big(mustConvertBytes(txTest.Transaction.S))
+	if expectedGasLimit.Cmp(decodedTx.GasLimit) != 0 {
+		return fmt.Errorf("GasLimit mismatch: %v %v", expectedGasLimit, decodedTx.GasLimit)
+	}
 
-	nonce = mustConvertUint(txTest.Transaction.Nonce)
+	expectedGasPrice := mustConvertBigInt(txTest.Transaction.GasPrice, 16)
-	v = mustConvertUint(txTest.Transaction.V)
+	if expectedGasPrice.Cmp(decodedTx.Price) != 0 {
+		return fmt.Errorf("GasPrice mismatch: %v %v", expectedGasPrice, decodedTx.Price)
+	}
 
-	return sender, to, txInputData, rlpBytes, gasLimit, gasPrice, value, r, s, nonce, v, nil
+	expectedNonce := mustConvertUint(txTest.Transaction.Nonce, 16)
+	if expectedNonce != decodedTx.AccountNonce {
+		return fmt.Errorf("Nonce mismatch: %v %v", expectedNonce, decodedTx.AccountNonce)
+	}
+
+	expectedR := common.Bytes2Big(mustConvertBytes(txTest.Transaction.R))
+	if expectedR.Cmp(decodedTx.R) != 0 {
+		return fmt.Errorf("R mismatch: %v %v", expectedR, decodedTx.R)
+	}
+
+	expectedS := common.Bytes2Big(mustConvertBytes(txTest.Transaction.S))
+	if expectedS.Cmp(decodedTx.S) != 0 {
+		return fmt.Errorf("S mismatch: %v %v", expectedS, decodedTx.S)
+	}
+
+	expectedV := mustConvertUint(txTest.Transaction.V, 16)
+	if expectedV != uint64(decodedTx.V) {
+		return fmt.Errorf("V mismatch: %v %v", expectedV, uint64(decodedTx.V))
+	}
+
+	expectedTo := mustConvertAddress(txTest.Transaction.To)
+	if decodedTx.Recipient == nil {
+		if expectedTo != common.BytesToAddress([]byte{}) { // "empty" or "zero" address
+			return fmt.Errorf("To mismatch when recipient is nil (contract creation): %v", expectedTo)
+		}
+	} else {
+		if expectedTo != *decodedTx.Recipient {
+			return fmt.Errorf("To mismatch: %v %v", expectedTo, *decodedTx.Recipient)
+		}
+	}
+
+	expectedValue := mustConvertBigInt(txTest.Transaction.Value, 16)
+	if expectedValue.Cmp(decodedTx.Amount) != 0 {
+		return fmt.Errorf("Value mismatch: %v %v", expectedValue, decodedTx.Amount)
+	}
+
+	return nil
 }