forked from cerc-io/plugeth
d40a255e97
* all: move main transaction pool into a subpool * go.mod: remove superfluous updates * core/txpool: review fixes, handle txs rejected by all subpools * core/txpool: typos
602 lines
19 KiB
Go
602 lines
19 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"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"math/big"
|
|
"math/rand"
|
|
"reflect"
|
|
"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 (
|
|
testAddr = common.HexToAddress("b94f5374fce5edbc8e2a8697c15331677e6ebf0b")
|
|
|
|
emptyTx = NewTransaction(
|
|
0,
|
|
common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"),
|
|
big.NewInt(0), 0, big.NewInt(0),
|
|
nil,
|
|
)
|
|
|
|
rightvrsTx, _ = NewTransaction(
|
|
3,
|
|
testAddr,
|
|
big.NewInt(10),
|
|
2000,
|
|
big.NewInt(1),
|
|
common.FromHex("5544"),
|
|
).WithSignature(
|
|
HomesteadSigner{},
|
|
common.Hex2Bytes("98ff921201554726367d2be8c804a7ff89ccf285ebc57dff8ae4c44b9c19ac4a8887321be575c8095f789dd4c743dfe42c1820f9231f98a962b210e3ac2452a301"),
|
|
)
|
|
|
|
emptyEip2718Tx = NewTx(&AccessListTx{
|
|
ChainID: big.NewInt(1),
|
|
Nonce: 3,
|
|
To: &testAddr,
|
|
Value: big.NewInt(10),
|
|
Gas: 25000,
|
|
GasPrice: big.NewInt(1),
|
|
Data: common.FromHex("5544"),
|
|
})
|
|
|
|
signedEip2718Tx, _ = emptyEip2718Tx.WithSignature(
|
|
NewEIP2930Signer(big.NewInt(1)),
|
|
common.Hex2Bytes("c9519f4f2b30335884581971573fadf60c6204f59a911df35ee8a540456b266032f1e8e2c5dd761f9e4f88f41c8310aeaba26a8bfcdacfedfa12ec3862d3752101"),
|
|
)
|
|
)
|
|
|
|
func TestDecodeEmptyTypedTx(t *testing.T) {
|
|
input := []byte{0x80}
|
|
var tx Transaction
|
|
err := rlp.DecodeBytes(input, &tx)
|
|
if err != errShortTypedTx {
|
|
t.Fatal("wrong error:", err)
|
|
}
|
|
}
|
|
|
|
func TestTransactionSigHash(t *testing.T) {
|
|
var homestead HomesteadSigner
|
|
if homestead.Hash(emptyTx) != common.HexToHash("c775b99e7ad12f50d819fcd602390467e28141316969f4b57f0626f74fe3b386") {
|
|
t.Errorf("empty transaction hash mismatch, got %x", emptyTx.Hash())
|
|
}
|
|
if homestead.Hash(rightvrsTx) != common.HexToHash("fe7a79529ed5f7c3375d06b26b186a8644e0e16c373d7a12be41c62d6042b77a") {
|
|
t.Errorf("RightVRS transaction hash mismatch, got %x", rightvrsTx.Hash())
|
|
}
|
|
}
|
|
|
|
func TestTransactionEncode(t *testing.T) {
|
|
txb, err := rlp.EncodeToBytes(rightvrsTx)
|
|
if err != nil {
|
|
t.Fatalf("encode error: %v", err)
|
|
}
|
|
should := common.FromHex("f86103018207d094b94f5374fce5edbc8e2a8697c15331677e6ebf0b0a8255441ca098ff921201554726367d2be8c804a7ff89ccf285ebc57dff8ae4c44b9c19ac4aa08887321be575c8095f789dd4c743dfe42c1820f9231f98a962b210e3ac2452a3")
|
|
if !bytes.Equal(txb, should) {
|
|
t.Errorf("encoded RLP mismatch, got %x", txb)
|
|
}
|
|
}
|
|
|
|
func TestEIP2718TransactionSigHash(t *testing.T) {
|
|
s := NewEIP2930Signer(big.NewInt(1))
|
|
if s.Hash(emptyEip2718Tx) != common.HexToHash("49b486f0ec0a60dfbbca2d30cb07c9e8ffb2a2ff41f29a1ab6737475f6ff69f3") {
|
|
t.Errorf("empty EIP-2718 transaction hash mismatch, got %x", s.Hash(emptyEip2718Tx))
|
|
}
|
|
if s.Hash(signedEip2718Tx) != common.HexToHash("49b486f0ec0a60dfbbca2d30cb07c9e8ffb2a2ff41f29a1ab6737475f6ff69f3") {
|
|
t.Errorf("signed EIP-2718 transaction hash mismatch, got %x", s.Hash(signedEip2718Tx))
|
|
}
|
|
}
|
|
|
|
// This test checks signature operations on access list transactions.
|
|
func TestEIP2930Signer(t *testing.T) {
|
|
var (
|
|
key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
|
|
keyAddr = crypto.PubkeyToAddress(key.PublicKey)
|
|
signer1 = NewEIP2930Signer(big.NewInt(1))
|
|
signer2 = NewEIP2930Signer(big.NewInt(2))
|
|
tx0 = NewTx(&AccessListTx{Nonce: 1})
|
|
tx1 = NewTx(&AccessListTx{ChainID: big.NewInt(1), Nonce: 1})
|
|
tx2, _ = SignNewTx(key, signer2, &AccessListTx{ChainID: big.NewInt(2), Nonce: 1})
|
|
)
|
|
|
|
tests := []struct {
|
|
tx *Transaction
|
|
signer Signer
|
|
wantSignerHash common.Hash
|
|
wantSenderErr error
|
|
wantSignErr error
|
|
wantHash common.Hash // after signing
|
|
}{
|
|
{
|
|
tx: tx0,
|
|
signer: signer1,
|
|
wantSignerHash: common.HexToHash("846ad7672f2a3a40c1f959cd4a8ad21786d620077084d84c8d7c077714caa139"),
|
|
wantSenderErr: ErrInvalidChainId,
|
|
wantHash: common.HexToHash("1ccd12d8bbdb96ea391af49a35ab641e219b2dd638dea375f2bc94dd290f2549"),
|
|
},
|
|
{
|
|
tx: tx1,
|
|
signer: signer1,
|
|
wantSenderErr: ErrInvalidSig,
|
|
wantSignerHash: common.HexToHash("846ad7672f2a3a40c1f959cd4a8ad21786d620077084d84c8d7c077714caa139"),
|
|
wantHash: common.HexToHash("1ccd12d8bbdb96ea391af49a35ab641e219b2dd638dea375f2bc94dd290f2549"),
|
|
},
|
|
{
|
|
// This checks what happens when trying to sign an unsigned tx for the wrong chain.
|
|
tx: tx1,
|
|
signer: signer2,
|
|
wantSenderErr: ErrInvalidChainId,
|
|
wantSignerHash: common.HexToHash("367967247499343401261d718ed5aa4c9486583e4d89251afce47f4a33c33362"),
|
|
wantSignErr: ErrInvalidChainId,
|
|
},
|
|
{
|
|
// This checks what happens when trying to re-sign a signed tx for the wrong chain.
|
|
tx: tx2,
|
|
signer: signer1,
|
|
wantSenderErr: ErrInvalidChainId,
|
|
wantSignerHash: common.HexToHash("846ad7672f2a3a40c1f959cd4a8ad21786d620077084d84c8d7c077714caa139"),
|
|
wantSignErr: ErrInvalidChainId,
|
|
},
|
|
}
|
|
|
|
for i, test := range tests {
|
|
sigHash := test.signer.Hash(test.tx)
|
|
if sigHash != test.wantSignerHash {
|
|
t.Errorf("test %d: wrong sig hash: got %x, want %x", i, sigHash, test.wantSignerHash)
|
|
}
|
|
sender, err := Sender(test.signer, test.tx)
|
|
if !errors.Is(err, test.wantSenderErr) {
|
|
t.Errorf("test %d: wrong Sender error %q", i, err)
|
|
}
|
|
if err == nil && sender != keyAddr {
|
|
t.Errorf("test %d: wrong sender address %x", i, sender)
|
|
}
|
|
signedTx, err := SignTx(test.tx, test.signer, key)
|
|
if !errors.Is(err, test.wantSignErr) {
|
|
t.Fatalf("test %d: wrong SignTx error %q", i, err)
|
|
}
|
|
if signedTx != nil {
|
|
if signedTx.Hash() != test.wantHash {
|
|
t.Errorf("test %d: wrong tx hash after signing: got %x, want %x", i, signedTx.Hash(), test.wantHash)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestEIP2718TransactionEncode(t *testing.T) {
|
|
// RLP representation
|
|
{
|
|
have, err := rlp.EncodeToBytes(signedEip2718Tx)
|
|
if err != nil {
|
|
t.Fatalf("encode error: %v", err)
|
|
}
|
|
want := common.FromHex("b86601f8630103018261a894b94f5374fce5edbc8e2a8697c15331677e6ebf0b0a825544c001a0c9519f4f2b30335884581971573fadf60c6204f59a911df35ee8a540456b2660a032f1e8e2c5dd761f9e4f88f41c8310aeaba26a8bfcdacfedfa12ec3862d37521")
|
|
if !bytes.Equal(have, want) {
|
|
t.Errorf("encoded RLP mismatch, got %x", have)
|
|
}
|
|
}
|
|
// Binary representation
|
|
{
|
|
have, err := signedEip2718Tx.MarshalBinary()
|
|
if err != nil {
|
|
t.Fatalf("encode error: %v", err)
|
|
}
|
|
want := common.FromHex("01f8630103018261a894b94f5374fce5edbc8e2a8697c15331677e6ebf0b0a825544c001a0c9519f4f2b30335884581971573fadf60c6204f59a911df35ee8a540456b2660a032f1e8e2c5dd761f9e4f88f41c8310aeaba26a8bfcdacfedfa12ec3862d37521")
|
|
if !bytes.Equal(have, want) {
|
|
t.Errorf("encoded RLP mismatch, got %x", have)
|
|
}
|
|
}
|
|
}
|
|
|
|
func decodeTx(data []byte) (*Transaction, error) {
|
|
var tx Transaction
|
|
t, err := &tx, rlp.Decode(bytes.NewReader(data), &tx)
|
|
return t, err
|
|
}
|
|
|
|
func defaultTestKey() (*ecdsa.PrivateKey, common.Address) {
|
|
key, _ := crypto.HexToECDSA("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.Fatal(err)
|
|
}
|
|
|
|
from, err := Sender(HomesteadSigner{}, tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if addr != from {
|
|
t.Fatal("derived address doesn't match")
|
|
}
|
|
}
|
|
|
|
func TestRecipientNormal(t *testing.T) {
|
|
_, addr := defaultTestKey()
|
|
|
|
tx, err := decodeTx(common.Hex2Bytes("f85d80808094000000000000000000000000000000000000000080011ca0527c0d8f5c63f7b9f41324a7c8a563ee1190bcbf0dac8ab446291bdbf32f5c79a0552c4ef0a09a04395074dab9ed34d3fbfb843c2f2546cc30fe89ec143ca94ca6"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
from, err := Sender(HomesteadSigner{}, tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if addr != from {
|
|
t.Fatal("derived address doesn't match")
|
|
}
|
|
}
|
|
|
|
func TestTransactionPriceNonceSortLegacy(t *testing.T) {
|
|
testTransactionPriceNonceSort(t, nil)
|
|
}
|
|
|
|
func TestTransactionPriceNonceSort1559(t *testing.T) {
|
|
testTransactionPriceNonceSort(t, big.NewInt(0))
|
|
testTransactionPriceNonceSort(t, big.NewInt(5))
|
|
testTransactionPriceNonceSort(t, big.NewInt(50))
|
|
}
|
|
|
|
// 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, baseFee *big.Int) {
|
|
// Generate a batch of accounts to start with
|
|
keys := make([]*ecdsa.PrivateKey, 25)
|
|
for i := 0; i < len(keys); i++ {
|
|
keys[i], _ = crypto.GenerateKey()
|
|
}
|
|
signer := LatestSignerForChainID(common.Big1)
|
|
|
|
// Generate a batch of transactions with overlapping values, but shifted nonces
|
|
groups := map[common.Address][]*Transaction{}
|
|
expectedCount := 0
|
|
for start, key := range keys {
|
|
addr := crypto.PubkeyToAddress(key.PublicKey)
|
|
count := 25
|
|
for i := 0; i < 25; i++ {
|
|
var tx *Transaction
|
|
gasFeeCap := rand.Intn(50)
|
|
if baseFee == nil {
|
|
tx = NewTx(&LegacyTx{
|
|
Nonce: uint64(start + i),
|
|
To: &common.Address{},
|
|
Value: big.NewInt(100),
|
|
Gas: 100,
|
|
GasPrice: big.NewInt(int64(gasFeeCap)),
|
|
Data: nil,
|
|
})
|
|
} else {
|
|
tx = NewTx(&DynamicFeeTx{
|
|
Nonce: uint64(start + i),
|
|
To: &common.Address{},
|
|
Value: big.NewInt(100),
|
|
Gas: 100,
|
|
GasFeeCap: big.NewInt(int64(gasFeeCap)),
|
|
GasTipCap: big.NewInt(int64(rand.Intn(gasFeeCap + 1))),
|
|
Data: nil,
|
|
})
|
|
if count == 25 && int64(gasFeeCap) < baseFee.Int64() {
|
|
count = i
|
|
}
|
|
}
|
|
tx, err := SignTx(tx, signer, key)
|
|
if err != nil {
|
|
t.Fatalf("failed to sign tx: %s", err)
|
|
}
|
|
groups[addr] = append(groups[addr], tx)
|
|
}
|
|
expectedCount += count
|
|
}
|
|
// Sort the transactions and cross check the nonce ordering
|
|
txset := NewTransactionsByPriceAndNonce(signer, groups, baseFee)
|
|
|
|
txs := Transactions{}
|
|
for tx := txset.Peek(); tx != nil; tx = txset.Peek() {
|
|
txs = append(txs, tx)
|
|
txset.Shift()
|
|
}
|
|
if len(txs) != expectedCount {
|
|
t.Errorf("expected %d transactions, found %d", expectedCount, len(txs))
|
|
}
|
|
for i, txi := range txs {
|
|
fromi, _ := Sender(signer, txi)
|
|
|
|
// Make sure the nonce order is valid
|
|
for j, txj := range txs[i+1:] {
|
|
fromj, _ := Sender(signer, txj)
|
|
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())
|
|
}
|
|
}
|
|
// If the next tx has different from account, the price must be lower than the current one
|
|
if i+1 < len(txs) {
|
|
next := txs[i+1]
|
|
fromNext, _ := Sender(signer, next)
|
|
tip, err := txi.EffectiveGasTip(baseFee)
|
|
nextTip, nextErr := next.EffectiveGasTip(baseFee)
|
|
if err != nil || nextErr != nil {
|
|
t.Errorf("error calculating effective tip")
|
|
}
|
|
if fromi != fromNext && tip.Cmp(nextTip) < 0 {
|
|
t.Errorf("invalid gasprice ordering: tx #%d (A=%x P=%v) < tx #%d (A=%x P=%v)", i, fromi[:4], txi.GasPrice(), i+1, fromNext[:4], next.GasPrice())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Tests that if multiple transactions have the same price, the ones seen earlier
|
|
// are prioritized to avoid network spam attacks aiming for a specific ordering.
|
|
func TestTransactionTimeSort(t *testing.T) {
|
|
// Generate a batch of accounts to start with
|
|
keys := make([]*ecdsa.PrivateKey, 5)
|
|
for i := 0; i < len(keys); i++ {
|
|
keys[i], _ = crypto.GenerateKey()
|
|
}
|
|
signer := HomesteadSigner{}
|
|
|
|
// Generate a batch of transactions with overlapping prices, but different creation times
|
|
groups := map[common.Address][]*Transaction{}
|
|
for start, key := range keys {
|
|
addr := crypto.PubkeyToAddress(key.PublicKey)
|
|
|
|
tx, _ := SignTx(NewTransaction(0, common.Address{}, big.NewInt(100), 100, big.NewInt(1), nil), signer, key)
|
|
tx.time = time.Unix(0, int64(len(keys)-start))
|
|
|
|
groups[addr] = append(groups[addr], tx)
|
|
}
|
|
// Sort the transactions and cross check the nonce ordering
|
|
txset := NewTransactionsByPriceAndNonce(signer, groups, nil)
|
|
|
|
txs := Transactions{}
|
|
for tx := txset.Peek(); tx != nil; tx = txset.Peek() {
|
|
txs = append(txs, tx)
|
|
txset.Shift()
|
|
}
|
|
if len(txs) != len(keys) {
|
|
t.Errorf("expected %d transactions, found %d", len(keys), len(txs))
|
|
}
|
|
for i, txi := range txs {
|
|
fromi, _ := Sender(signer, txi)
|
|
if i+1 < len(txs) {
|
|
next := txs[i+1]
|
|
fromNext, _ := Sender(signer, next)
|
|
|
|
if txi.GasPrice().Cmp(next.GasPrice()) < 0 {
|
|
t.Errorf("invalid gasprice ordering: tx #%d (A=%x P=%v) < tx #%d (A=%x P=%v)", i, fromi[:4], txi.GasPrice(), i+1, fromNext[:4], next.GasPrice())
|
|
}
|
|
// Make sure time order is ascending if the txs have the same gas price
|
|
if txi.GasPrice().Cmp(next.GasPrice()) == 0 && txi.time.After(next.time) {
|
|
t.Errorf("invalid received time ordering: tx #%d (A=%x T=%v) > tx #%d (A=%x T=%v)", i, fromi[:4], txi.time, i+1, fromNext[:4], next.time)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestTransactionCoding tests serializing/de-serializing to/from rlp and JSON.
|
|
func TestTransactionCoding(t *testing.T) {
|
|
key, err := crypto.GenerateKey()
|
|
if err != nil {
|
|
t.Fatalf("could not generate key: %v", err)
|
|
}
|
|
var (
|
|
signer = NewEIP2930Signer(common.Big1)
|
|
addr = common.HexToAddress("0x0000000000000000000000000000000000000001")
|
|
recipient = common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87")
|
|
accesses = AccessList{{Address: addr, StorageKeys: []common.Hash{{0}}}}
|
|
)
|
|
for i := uint64(0); i < 500; i++ {
|
|
var txdata TxData
|
|
switch i % 5 {
|
|
case 0:
|
|
// Legacy tx.
|
|
txdata = &LegacyTx{
|
|
Nonce: i,
|
|
To: &recipient,
|
|
Gas: 1,
|
|
GasPrice: big.NewInt(2),
|
|
Data: []byte("abcdef"),
|
|
}
|
|
case 1:
|
|
// Legacy tx contract creation.
|
|
txdata = &LegacyTx{
|
|
Nonce: i,
|
|
Gas: 1,
|
|
GasPrice: big.NewInt(2),
|
|
Data: []byte("abcdef"),
|
|
}
|
|
case 2:
|
|
// Tx with non-zero access list.
|
|
txdata = &AccessListTx{
|
|
ChainID: big.NewInt(1),
|
|
Nonce: i,
|
|
To: &recipient,
|
|
Gas: 123457,
|
|
GasPrice: big.NewInt(10),
|
|
AccessList: accesses,
|
|
Data: []byte("abcdef"),
|
|
}
|
|
case 3:
|
|
// Tx with empty access list.
|
|
txdata = &AccessListTx{
|
|
ChainID: big.NewInt(1),
|
|
Nonce: i,
|
|
To: &recipient,
|
|
Gas: 123457,
|
|
GasPrice: big.NewInt(10),
|
|
Data: []byte("abcdef"),
|
|
}
|
|
case 4:
|
|
// Contract creation with access list.
|
|
txdata = &AccessListTx{
|
|
ChainID: big.NewInt(1),
|
|
Nonce: i,
|
|
Gas: 123457,
|
|
GasPrice: big.NewInt(10),
|
|
AccessList: accesses,
|
|
}
|
|
}
|
|
tx, err := SignNewTx(key, signer, txdata)
|
|
if err != nil {
|
|
t.Fatalf("could not sign transaction: %v", err)
|
|
}
|
|
// RLP
|
|
parsedTx, err := encodeDecodeBinary(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := assertEqual(parsedTx, tx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// JSON
|
|
parsedTx, err = encodeDecodeJSON(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := assertEqual(parsedTx, tx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func encodeDecodeJSON(tx *Transaction) (*Transaction, error) {
|
|
data, err := json.Marshal(tx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("json encoding failed: %v", err)
|
|
}
|
|
var parsedTx = &Transaction{}
|
|
if err := json.Unmarshal(data, &parsedTx); err != nil {
|
|
return nil, fmt.Errorf("json decoding failed: %v", err)
|
|
}
|
|
return parsedTx, nil
|
|
}
|
|
|
|
func encodeDecodeBinary(tx *Transaction) (*Transaction, error) {
|
|
data, err := tx.MarshalBinary()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("rlp encoding failed: %v", err)
|
|
}
|
|
var parsedTx = &Transaction{}
|
|
if err := parsedTx.UnmarshalBinary(data); err != nil {
|
|
return nil, fmt.Errorf("rlp decoding failed: %v", err)
|
|
}
|
|
return parsedTx, nil
|
|
}
|
|
|
|
func assertEqual(orig *Transaction, cpy *Transaction) error {
|
|
// compare nonce, price, gaslimit, recipient, amount, payload, V, R, S
|
|
if want, got := orig.Hash(), cpy.Hash(); want != got {
|
|
return fmt.Errorf("parsed tx differs from original tx, want %v, got %v", want, got)
|
|
}
|
|
if want, got := orig.ChainId(), cpy.ChainId(); want.Cmp(got) != 0 {
|
|
return fmt.Errorf("invalid chain id, want %d, got %d", want, got)
|
|
}
|
|
if orig.AccessList() != nil {
|
|
if !reflect.DeepEqual(orig.AccessList(), cpy.AccessList()) {
|
|
return errors.New("access list wrong!")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func TestTransactionSizes(t *testing.T) {
|
|
signer := NewLondonSigner(big.NewInt(123))
|
|
key, _ := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
|
|
to := common.HexToAddress("0x01")
|
|
for i, txdata := range []TxData{
|
|
&AccessListTx{
|
|
ChainID: big.NewInt(123),
|
|
Nonce: 0,
|
|
To: nil,
|
|
Value: big.NewInt(1000),
|
|
Gas: 21000,
|
|
GasPrice: big.NewInt(100000),
|
|
},
|
|
&LegacyTx{
|
|
Nonce: 1,
|
|
GasPrice: big.NewInt(500),
|
|
Gas: 1000000,
|
|
To: &to,
|
|
Value: big.NewInt(1),
|
|
},
|
|
&AccessListTx{
|
|
ChainID: big.NewInt(123),
|
|
Nonce: 1,
|
|
GasPrice: big.NewInt(500),
|
|
Gas: 1000000,
|
|
To: &to,
|
|
Value: big.NewInt(1),
|
|
AccessList: AccessList{
|
|
AccessTuple{
|
|
Address: common.HexToAddress("0x01"),
|
|
StorageKeys: []common.Hash{common.HexToHash("0x01")},
|
|
}},
|
|
},
|
|
&DynamicFeeTx{
|
|
ChainID: big.NewInt(123),
|
|
Nonce: 1,
|
|
Gas: 1000000,
|
|
To: &to,
|
|
Value: big.NewInt(1),
|
|
GasTipCap: big.NewInt(500),
|
|
GasFeeCap: big.NewInt(500),
|
|
},
|
|
} {
|
|
tx, err := SignNewTx(key, signer, txdata)
|
|
if err != nil {
|
|
t.Fatalf("test %d: %v", i, err)
|
|
}
|
|
bin, _ := tx.MarshalBinary()
|
|
|
|
// Check initial calc
|
|
if have, want := int(tx.Size()), len(bin); have != want {
|
|
t.Errorf("test %d: size wrong, have %d want %d", i, have, want)
|
|
}
|
|
// Check cached version too
|
|
if have, want := int(tx.Size()), len(bin); have != want {
|
|
t.Errorf("test %d: (cached) size wrong, have %d want %d", i, have, want)
|
|
}
|
|
// Check unmarshalled version too
|
|
utx := new(Transaction)
|
|
if err := utx.UnmarshalBinary(bin); err != nil {
|
|
t.Fatalf("test %d: failed to unmarshal tx: %v", i, err)
|
|
}
|
|
if have, want := int(utx.Size()), len(bin); have != want {
|
|
t.Errorf("test %d: (unmarshalled) size wrong, have %d want %d", i, have, want)
|
|
}
|
|
}
|
|
}
|