diff options
| -rw-r--r-- | README.md | 2 | ||||
| -rw-r--r-- | cmd/geth/block_go_test.go | 80 | ||||
| -rw-r--r-- | cmd/geth/blocktest.go | 89 | ||||
| -rw-r--r-- | eth/backend.go | 5 | ||||
| -rw-r--r-- | rpc/responses.go | 6 | ||||
| -rw-r--r-- | tests/block_test_util.go (renamed from tests/blocktest.go) | 84 | ||||
| -rw-r--r-- | tests/transaction_test_util.go | 143 |
7 files changed, 294 insertions, 115 deletions
@@ -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) diff --git a/cmd/geth/block_go_test.go b/cmd/geth/block_go_test.go new file mode 100644 index 000000000..1980e4798 --- /dev/null +++ b/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 ð.Config{ + DataDir: common.DefaultDataDir(), + LogLevel: 5, + Etherbase: "primary", + AccountManager: accounts.NewManager(ks), + NewDB: func(path string) (common.Database, error) { return ethdb.NewMemDatabase() }, + } +} diff --git a/cmd/geth/blocktest.go b/cmd/geth/blocktest.go index f0b6bb1a2..792981ec0 100644 --- a/cmd/geth/blocktest.go +++ b/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) { - if len(ctx.Args()) != 3 { - utils.Fatalf("Usage: ethereum blocktest <path-to-test-file> <test-name> {rpc, norpc}") +func runBlockTest(ctx *cli.Context) { + var ( + 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 := chain.InsertChain(test.Blocks); err != nil { - utils.Fatalf("Block Test load error: %v %T", err, err) - } else { - fmt.Println("Block Test chain loaded") + if err := test.InsertBlocks(ethereum.ChainManager()); err != nil { + return ethereum, fmt.Errorf("Block Test load error: %v %T", err, err) } - + fmt.Println("chain loaded") if err := test.ValidatePostState(statedb); err != nil { - utils.Fatalf("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, fmt.Errorf("post state validation failed: %v", err) } + return ethereum, nil } diff --git a/eth/backend.go b/eth/backend.go index ec2444836..88456e448 100644 --- a/eth/backend.go +++ b/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")) diff --git a/rpc/responses.go b/rpc/responses.go index 5d1be8f34..884b7e69b 100644 --- a/rpc/responses.go +++ b/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()) diff --git a/tests/blocktest.go b/tests/block_test_util.go index 2d6b11944..5c42ae18c 100644 --- a/tests/blocktest.go +++ b/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), - GasLimit: mustConvertBigInt(in.GasLimit), - Difficulty: mustConvertBigInt(in.Difficulty), - Time: mustConvertUint(in.Timestamp), + GasUsed: mustConvertBigInt(in.GasUsed, 10), + GasLimit: mustConvertBigInt(in.GasLimit, 10), + Difficulty: mustConvertBigInt(in.Difficulty, 10), + 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 { - out, ok := new(big.Int).SetString(unfuckCPPHexInts(in), 0) +func mustConvertBigInt(in string, base int) *big.Int { + 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 { - out, err := strconv.ParseUint(unfuckCPPHexInts(in), 0, 64) +func mustConvertUint(in string, base int) uint64 { + 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 { - if s == "0x" { // no respect for the empty value :( - return "0x00" +// Nothing to see here, please move along... +func prepInt(base int, s string) string { + if base == 16 { + if strings.HasPrefix(s, "0x") { + s = s[2:] + } + if len(s) == 0 { + s = "00" + } + s = nibbleFix(s) } - if (len(s) % 2) != 0 { // motherfucking nibbles - return "0x0" + s[2:] + 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 } diff --git a/tests/transaction_test_util.go b/tests/transaction_test_util.go index 567aba66f..23ec375e3 100644 --- a/tests/transaction_test_util.go +++ b/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,93 +49,112 @@ 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() + + validationError := verifyTxFields(txTest, tx) + 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") + } + } + + 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 verifyTxFields(txTest TransactionTest, decodedTx *types.Transaction) (err error) { + 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) + } + }() + + decodedSender, err := decodedTx.From() if err != nil { return err } - if expectedSender != sender { - return fmt.Errorf("Sender mismatch: %v %v", expectedSender, sender) + expectedSender := mustConvertAddress(txTest.Sender) + if expectedSender != decodedSender { + return fmt.Errorf("Sender mismatch: %v %v", expectedSender, decodedSender) } - if !bytes.Equal(expectedData, tx.Payload) { - return fmt.Errorf("Tx input data mismatch: %#v %#v", expectedData, tx.Payload) + + expectedData := mustConvertBytes(txTest.Transaction.Data) + if !bytes.Equal(expectedData, decodedTx.Payload) { + return fmt.Errorf("Tx input data mismatch: %#v %#v", expectedData, decodedTx.Payload) } - if expectedGasLimit.Cmp(tx.GasLimit) != 0 { - return fmt.Errorf("GasLimit mismatch: %v %v", expectedGasLimit, tx.GasLimit) + + expectedGasLimit := mustConvertBigInt(txTest.Transaction.GasLimit, 16) + if expectedGasLimit.Cmp(decodedTx.GasLimit) != 0 { + return fmt.Errorf("GasLimit mismatch: %v %v", expectedGasLimit, decodedTx.GasLimit) } - if expectedGasPrice.Cmp(tx.Price) != 0 { - return fmt.Errorf("GasPrice mismatch: %v %v", expectedGasPrice, tx.Price) + + expectedGasPrice := mustConvertBigInt(txTest.Transaction.GasPrice, 16) + if expectedGasPrice.Cmp(decodedTx.Price) != 0 { + return fmt.Errorf("GasPrice mismatch: %v %v", expectedGasPrice, decodedTx.Price) } - if expectedNonce != tx.AccountNonce { - return fmt.Errorf("Nonce mismatch: %v %v", expectedNonce, tx.AccountNonce) + + expectedNonce := mustConvertUint(txTest.Transaction.Nonce, 16) + if expectedNonce != decodedTx.AccountNonce { + return fmt.Errorf("Nonce mismatch: %v %v", expectedNonce, decodedTx.AccountNonce) } - if expectedR.Cmp(tx.R) != 0 { - return fmt.Errorf("R mismatch: %v %v", expectedR, tx.R) + + expectedR := common.Bytes2Big(mustConvertBytes(txTest.Transaction.R)) + if expectedR.Cmp(decodedTx.R) != 0 { + return fmt.Errorf("R mismatch: %v %v", expectedR, decodedTx.R) } - if expectedS.Cmp(tx.S) != 0 { - return fmt.Errorf("S mismatch: %v %v", expectedS, tx.S) + + expectedS := common.Bytes2Big(mustConvertBytes(txTest.Transaction.S)) + if expectedS.Cmp(decodedTx.S) != 0 { + return fmt.Errorf("S mismatch: %v %v", expectedS, decodedTx.S) } - if expectedV != uint64(tx.V) { - return fmt.Errorf("V mismatch: %v %v", expectedV, uint64(tx.V)) + + expectedV := mustConvertUint(txTest.Transaction.V, 16) + if expectedV != uint64(decodedTx.V) { + return fmt.Errorf("V mismatch: %v %v", expectedV, uint64(decodedTx.V)) } - if tx.Recipient == nil { + + 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 != *tx.Recipient { - return fmt.Errorf("To mismatch: %v %v", expectedTo, *tx.Recipient) + if expectedTo != *decodedTx.Recipient { + return fmt.Errorf("To mismatch: %v %v", expectedTo, *decodedTx.Recipient) } } - if expectedValue.Cmp(tx.Amount) != 0 { - return fmt.Errorf("Value mismatch: %v %v", expectedValue, tx.Amount) + expectedValue := mustConvertBigInt(txTest.Transaction.Value, 16) + if expectedValue.Cmp(decodedTx.Amount) != 0 { + return fmt.Errorf("Value mismatch: %v %v", expectedValue, decodedTx.Amount) } return nil } - -func convertTestTypes(txTest TransactionTest) (sender, to common.Address, - 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) - buf = buf[:runtime.Stack(buf, false)] - err = fmt.Errorf("%v\n%s", recovered, buf) - } - }() - - sender = mustConvertAddress(txTest.Sender) - to = mustConvertAddress(txTest.Transaction.To) - - txInputData = mustConvertBytes(txTest.Transaction.Data) - rlpBytes = mustConvertBytes(txTest.Rlp) - - gasLimit = mustConvertBigInt(txTest.Transaction.GasLimit) - gasPrice = mustConvertBigInt(txTest.Transaction.GasPrice) - value = mustConvertBigInt(txTest.Transaction.Value) - - r = common.Bytes2Big(mustConvertBytes(txTest.Transaction.R)) - s = common.Bytes2Big(mustConvertBytes(txTest.Transaction.S)) - - nonce = mustConvertUint(txTest.Transaction.Nonce) - v = mustConvertUint(txTest.Transaction.V) - - return sender, to, txInputData, rlpBytes, gasLimit, gasPrice, value, r, s, nonce, v, nil -} |