mirror of https://github.com/poanetwork/quorum.git
276 lines
8.6 KiB
Go
276 lines
8.6 KiB
Go
// Copyright 2014 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 types
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/ecdsa"
|
|
"math/big"
|
|
"math/rand"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
)
|
|
|
|
// The values in those tests are from the Transaction Tests
|
|
// at github.com/ethereum/tests.
|
|
|
|
var (
|
|
emptyTx = NewTransaction(
|
|
0,
|
|
common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"),
|
|
big.NewInt(0), big.NewInt(0), big.NewInt(0),
|
|
nil,
|
|
)
|
|
|
|
rightvrsTx, _ = NewTransaction(
|
|
3,
|
|
common.HexToAddress("b94f5374fce5edbc8e2a8697c15331677e6ebf0b"),
|
|
big.NewInt(10),
|
|
big.NewInt(2000),
|
|
big.NewInt(0),
|
|
common.FromHex("5544"),
|
|
).WithSignature(
|
|
common.Hex2Bytes("98ff921201554726367d2be8c804a7ff89ccf285ebc57dff8ae4c44b9c19ac4a8887321be575c8095f789dd4c743dfe42c1820f9231f98a962b210e3ac2452a31c"),
|
|
)
|
|
)
|
|
|
|
func TestTransactionSigHash(t *testing.T) {
|
|
if emptyTx.SigHash() != common.HexToHash("c775b99e7ad12f50d819fcd602390467e28141316969f4b57f0626f74fe3b386") {
|
|
t.Errorf("empty transaction hash mismatch, got %x", emptyTx.Hash())
|
|
}
|
|
if rightvrsTx.SigHash() != common.HexToHash("c75e06c2a1b4e254e869653871436fdfa752fd613152b474e6dd36b73a13dae2") {
|
|
t.Errorf("RightVRS transaction hash mismatch, got %x", rightvrsTx.SigHash())
|
|
}
|
|
}
|
|
|
|
func TestTransactionEncode(t *testing.T) {
|
|
txb, err := rlp.EncodeToBytes(rightvrsTx)
|
|
if err != nil {
|
|
t.Fatalf("encode error: %v", err)
|
|
}
|
|
should := common.FromHex("f86103808207d094b94f5374fce5edbc8e2a8697c15331677e6ebf0b0a8255441ca098ff921201554726367d2be8c804a7ff89ccf285ebc57dff8ae4c44b9c19ac4aa08887321be575c8095f789dd4c743dfe42c1820f9231f98a962b210e3ac2452a3")
|
|
if !bytes.Equal(txb, should) {
|
|
t.Errorf("encoded RLP mismatch, got %x", txb)
|
|
}
|
|
}
|
|
|
|
func decodeTx(data []byte) (*Transaction, error) {
|
|
var tx Transaction
|
|
return &tx, rlp.Decode(bytes.NewReader(data), &tx)
|
|
}
|
|
|
|
func defaultTestKey() (*ecdsa.PrivateKey, common.Address) {
|
|
key := crypto.ToECDSA(common.Hex2Bytes("45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8"))
|
|
addr := crypto.PubkeyToAddress(key.PublicKey)
|
|
return key, addr
|
|
}
|
|
|
|
func TestRecipientEmpty(t *testing.T) {
|
|
_, addr := defaultTestKey()
|
|
tx, err := decodeTx(common.Hex2Bytes("f8498080808080011ca09b16de9d5bdee2cf56c28d16275a4da68cd30273e2525f3959f5d62557489921a0372ebd8fb3345f7db7b5a86d42e24d36e983e259b0664ceb8c227ec9af572f3d"))
|
|
if err != nil {
|
|
t.Error(err)
|
|
t.FailNow()
|
|
}
|
|
from, err := tx.From()
|
|
if err != nil {
|
|
t.Error(err)
|
|
t.FailNow()
|
|
}
|
|
if addr != from {
|
|
t.Error("derived address doesn't match")
|
|
}
|
|
}
|
|
|
|
func TestRecipientNormal(t *testing.T) {
|
|
_, addr := defaultTestKey()
|
|
|
|
tx, err := decodeTx(common.Hex2Bytes("f85d80808094000000000000000000000000000000000000000080011ca0527c0d8f5c63f7b9f41324a7c8a563ee1190bcbf0dac8ab446291bdbf32f5c79a0552c4ef0a09a04395074dab9ed34d3fbfb843c2f2546cc30fe89ec143ca94ca6"))
|
|
if err != nil {
|
|
t.Error(err)
|
|
t.FailNow()
|
|
}
|
|
|
|
from, err := tx.From()
|
|
if err != nil {
|
|
t.Error(err)
|
|
t.FailNow()
|
|
}
|
|
|
|
if addr != from {
|
|
t.Error("derived address doesn't match")
|
|
}
|
|
}
|
|
|
|
func TestTransactionsByPriorityNonceSort(t *testing.T) {
|
|
votingContractAddr := common.HexToAddress("0x0000000000000000000000000000000000000020")
|
|
|
|
// Generate a batch of accounts to start with
|
|
keys := make([]*ecdsa.PrivateKey, 50)
|
|
for i := 0; i < len(keys); i++ {
|
|
keys[i], _ = crypto.GenerateKey()
|
|
}
|
|
|
|
// Generate a batch of transactions with overlapping values, but shifted nonces
|
|
groups := map[common.Address]Transactions{}
|
|
|
|
rand.Seed(time.Now().UnixNano())
|
|
for start, key := range keys {
|
|
addr := crypto.PubkeyToAddress(key.PublicKey)
|
|
for i := 0; i < 5; i++ {
|
|
var tx *Transaction
|
|
switch rand.Int() % 3 {
|
|
case 0:
|
|
tx, _ = NewTransaction(uint64(i), votingContractAddr, big.NewInt(100), big.NewInt(100), big.NewInt(int64(start+1)), nil).SignECDSA(key)
|
|
case 1:
|
|
tx, _ = NewTransaction(uint64(i), common.Address{}, big.NewInt(100), big.NewInt(100), big.NewInt(int64(start+1)), nil).SignECDSA(key)
|
|
default:
|
|
tx, _ = NewContractCreation(uint64(i), common.Big0, common.MaxBig, common.Big0, []byte{0}).SignECDSA(key)
|
|
}
|
|
|
|
groups[addr] = append(groups[addr], tx)
|
|
}
|
|
}
|
|
|
|
txset := NewTransactionsByPriorityAndNonce(groups)
|
|
|
|
txs := Transactions{}
|
|
for {
|
|
if tx := txset.Peek(); tx != nil {
|
|
txs = append(txs, tx)
|
|
txset.Shift()
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
|
|
for i, txi := range txs {
|
|
fromi, _ := txi.From()
|
|
|
|
// Make sure the nonce order is valid
|
|
for j, txj := range txs[i+1:] {
|
|
fromj, _ := txj.From()
|
|
if fromi == fromj && txi.Nonce() > txj.Nonce() {
|
|
t.Errorf("invalid nonce ordering: tx #%d (A=%x N=%v) < tx #%d (A=%x N=%v)", i, fromi[:4], txi.Nonce(), i+j, fromj[:4], txj.Nonce())
|
|
}
|
|
}
|
|
}
|
|
|
|
// first first non prioritised transaction
|
|
index := 0
|
|
for i, tx := range txs {
|
|
// search first non prioritized transaction
|
|
to := tx.To()
|
|
if to != nil && *to != votingContractAddr {
|
|
index = i
|
|
break
|
|
}
|
|
}
|
|
|
|
// ensure that all transaction after this point are non-prioritized
|
|
gotNonPrioritised := make(map[common.Address]bool)
|
|
for i, tx := range txs[index:] {
|
|
from, _ := tx.From()
|
|
|
|
if _, ok := gotNonPrioritised[from]; ok { // got an non-prioritised before this one which, this tx is always good
|
|
continue
|
|
} else { // didn't got a non-prioritised tx before this one, ensure this tx has no priority
|
|
to := tx.To()
|
|
if to != nil && *to == votingContractAddr {
|
|
for n, trans := range txs {
|
|
transFrom, _ := trans.From()
|
|
t.Logf("Tx[%d] nonce: %d, from: %x, to: %x", n, trans.Nonce(), transFrom, trans.To())
|
|
}
|
|
t.Fatalf("Found a priority tx on index %d that hasn't got no priority is should have", index+i)
|
|
}
|
|
gotNonPrioritised[from] = true
|
|
}
|
|
}
|
|
}
|
|
|
|
// Tests that transactions can be correctly sorted according to their price in
|
|
// decreasing order, but at the same time with increasing nonces when issued by
|
|
// the same account.
|
|
func TestTransactionPriceNonceSort(t *testing.T) {
|
|
// Generate a batch of accounts to start with
|
|
keys := make([]*ecdsa.PrivateKey, 25)
|
|
for i := 0; i < len(keys); i++ {
|
|
keys[i], _ = crypto.GenerateKey()
|
|
}
|
|
// Generate a batch of transactions with overlapping values, but shifted nonces
|
|
groups := map[common.Address]Transactions{}
|
|
for start, key := range keys {
|
|
addr := crypto.PubkeyToAddress(key.PublicKey)
|
|
for i := 0; i < 25; i++ {
|
|
tx, _ := NewTransaction(uint64(start+i), common.Address{}, big.NewInt(100), big.NewInt(100), big.NewInt(int64(start+i)), nil).SignECDSA(key)
|
|
groups[addr] = append(groups[addr], tx)
|
|
}
|
|
}
|
|
// Sort the transactions and cross check the nonce ordering
|
|
txset := NewTransactionsByPriceAndNonce(groups)
|
|
|
|
txs := Transactions{}
|
|
for {
|
|
if tx := txset.Peek(); tx != nil {
|
|
txs = append(txs, tx)
|
|
txset.Shift()
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
for i, txi := range txs {
|
|
fromi, _ := txi.From()
|
|
|
|
// Make sure the nonce order is valid
|
|
for j, txj := range txs[i+1:] {
|
|
fromj, _ := txj.From()
|
|
|
|
if fromi == fromj && txi.Nonce() > txj.Nonce() {
|
|
t.Errorf("invalid nonce ordering: tx #%d (A=%x N=%v) < tx #%d (A=%x N=%v)", i, fromi[:4], txi.Nonce(), i+j, fromj[:4], txj.Nonce())
|
|
}
|
|
}
|
|
// Find the previous and next nonce of this account
|
|
prev, next := i-1, i+1
|
|
for j := i - 1; j >= 0; j-- {
|
|
if fromj, _ := txs[j].From(); fromi == fromj {
|
|
prev = j
|
|
break
|
|
}
|
|
}
|
|
for j := i + 1; j < len(txs); j++ {
|
|
if fromj, _ := txs[j].From(); fromi == fromj {
|
|
next = j
|
|
break
|
|
}
|
|
}
|
|
// Make sure that in between the neighbor nonces, the transaction is correctly positioned price wise
|
|
for j := prev + 1; j < next; j++ {
|
|
fromj, _ := txs[j].From()
|
|
if j < i && txs[j].GasPrice().Cmp(txi.GasPrice()) < 0 {
|
|
t.Errorf("invalid gasprice ordering: tx #%d (A=%x P=%v) < tx #%d (A=%x P=%v)", j, fromj[:4], txs[j].GasPrice(), i, fromi[:4], txi.GasPrice())
|
|
}
|
|
if j > i && txs[j].GasPrice().Cmp(txi.GasPrice()) > 0 {
|
|
t.Errorf("invalid gasprice ordering: tx #%d (A=%x P=%v) > tx #%d (A=%x P=%v)", j, fromj[:4], txs[j].GasPrice(), i, fromi[:4], txi.GasPrice())
|
|
}
|
|
}
|
|
}
|
|
}
|