From 50d975302d27a0e5f8568efbf7367dc9a08a54e6 Mon Sep 17 00:00:00 2001
From: lightclient <14004106+lightclient@users.noreply.github.com>
Date: Thu, 25 Feb 2021 07:26:57 -0700
Subject: [PATCH] all: add support for EIP-2718, EIP-2930 transactions (#21502)
This adds support for EIP-2718 typed transactions as well as EIP-2930
access list transactions (tx type 1). These EIPs are scheduled for the
Berlin fork.
There very few changes to existing APIs in core/types, and several new APIs
to deal with access list transactions. In particular, there are two new
constructor functions for transactions: types.NewTx and types.SignNewTx.
Since the canonical encoding of typed transactions is not RLP-compatible,
Transaction now has new methods for encoding and decoding: MarshalBinary
and UnmarshalBinary.
The existing EIP-155 signer does not support the new transaction types.
All code dealing with transaction signatures should be updated to use the
newer EIP-2930 signer. To make this easier for future updates, we have
added new constructor functions for types.Signer: types.LatestSigner and
types.LatestSignerForChainID.
This change also adds support for the YoloV3 testnet.
Co-authored-by: Martin Holst Swende <martin@swende.se>
Co-authored-by: Felix Lange <fjl@twurst.com>
Co-authored-by: Ryan Schneider <ryanleeschneider@gmail.com>
# Conflicts:
# accounts/abi/bind/backends/simulated.go
# cmd/evm/internal/t8ntool/execution.go
# cmd/evm/internal/t8ntool/transition.go
# cmd/geth/main.go
# cmd/geth/usage.go
# core/bench_test.go
# core/state/statedb.go
# core/state_prefetcher.go
# core/state_processor.go
# core/state_transition.go
# core/tx_pool.go
# core/types/block.go
# core/types/derive_sha.go
# core/types/gen_tx_json.go
# core/types/receipt.go
# core/types/receipt_test.go
# core/types/transaction.go
# core/types/transaction_signing.go
# core/types/transaction_test.go
# ethclient/ethclient.go
# ethclient/signer.go
# graphql/graphql.go
# internal/ethapi/api.go
# internal/guide/guide_test.go
# les/benchmark.go
# les/odr_test.go
# light/odr_test.go
# light/txpool.go
# miner/worker.go
# miner/worker_test.go
# signer/core/api.go
# tests/state_test_util.go
# trie/stacktrie_test.go
# turbo/stages/blockchain_test.go
---
accounts/abi/bind/auth.go | 4 +-
accounts/abi/bind/backends/simulated.go | 8 +-
accounts/keystore/keystore.go | 17 +-
accounts/scwallet/wallet.go | 2 +-
accounts/usbwallet/trezor.go | 2 +
cmd/clef/main.go | 2 +-
cmd/evm/README.md | 17 +-
cmd/evm/internal/t8ntool/execution.go | 35 +-
cmd/evm/internal/t8ntool/flags.go | 5 +
cmd/evm/internal/t8ntool/transition.go | 140 +++++--
cmd/evm/main.go | 1 +
cmd/evm/testdata/8/alloc.json | 11 +
cmd/evm/testdata/8/env.json | 7 +
cmd/evm/testdata/8/readme.md | 63 ++++
cmd/evm/testdata/8/txs.json | 58 +++
cmd/utils/flags.go | 4 +-
core/bench_test.go | 2 +-
core/error.go | 10 +-
core/genesis.go | 6 +-
core/genesis_alloc.go | 3 +-
core/state_prefetcher.go | 33 +-
core/state_processor.go | 30 +-
core/state_transition.go | 12 +-
core/tx_pool.go | 15 +-
core/types/access_list_tx.go | 115 ++++++
core/types/block.go | 17 -
core/types/block_test.go | 62 ++-
core/types/gen_access_tuple.go | 43 +++
core/types/gen_receipt_json.go | 6 +
core/types/gen_tx_json.go | 101 -----
core/types/{derive_sha.go => hashing.go} | 0
core/types/hashing_test.go | 115 ++++++
core/types/legacy_tx.go | 111 ++++++
core/types/receipt.go | 103 ++++-
core/types/receipt_test.go | 76 +++-
core/types/transaction.go | 462 ++++++++++++++---------
core/types/transaction_marshalling.go | 187 +++++++++
core/types/transaction_signing.go | 252 +++++++++++--
core/types/transaction_test.go | 271 +++++++++++--
core/vm/interface.go | 1 +
core/vm/runtime/runtime.go | 18 +-
eth/downloader/downloader.go | 2 +-
eth/gasprice/gasprice_test.go | 2 +-
eth/tracers/api.go | 5 +-
eth/tracers/tracer.go | 2 +-
ethclient/ethclient.go | 2 +-
ethclient/ethclient_test.go | 2 +-
ethclient/signer.go | 4 +-
graphql/graphql.go | 8 +-
interfaces.go | 2 +
internal/ethapi/api.go | 169 +++++----
internal/guide/guide_test.go | 3 +-
miner/worker.go | 7 +-
miner/worker_test.go | 19 +-
params/config.go | 6 +-
params/protocol_params.go | 31 +-
signer/core/api.go | 4 +-
tests/state_test_util.go | 18 +-
tests/transaction_test_util.go | 2 +-
turbo/stages/blockchain_test.go | 102 ++++-
60 files changed, 2164 insertions(+), 653 deletions(-)
create mode 100644 cmd/evm/testdata/8/alloc.json
create mode 100644 cmd/evm/testdata/8/env.json
create mode 100644 cmd/evm/testdata/8/readme.md
create mode 100644 cmd/evm/testdata/8/txs.json
create mode 100644 core/types/access_list_tx.go
create mode 100644 core/types/gen_access_tuple.go
delete mode 100644 core/types/gen_tx_json.go
rename core/types/{derive_sha.go => hashing.go} (100%)
create mode 100644 core/types/hashing_test.go
create mode 100644 core/types/legacy_tx.go
create mode 100644 core/types/transaction_marshalling.go
diff --git a/accounts/abi/bind/auth.go b/accounts/abi/bind/auth.go
index 0607cdd819..83c80253d9 100644
--- a/accounts/abi/bind/auth.go
+++ b/accounts/abi/bind/auth.go
@@ -120,7 +120,7 @@ func NewKeyStoreTransactorWithChainID(keystore *keystore.KeyStore, account accou
if chainID == nil {
return nil, ErrNoChainID
}
- signer := types.NewEIP155Signer(chainID)
+ signer := types.LatestSignerForChainID(chainID)
return &TransactOpts{
From: account.Address,
Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
@@ -143,7 +143,7 @@ func NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainID *big.Int) (*Tr
if chainID == nil {
return nil, ErrNoChainID
}
- signer := types.NewEIP155Signer(chainID)
+ signer := types.LatestSignerForChainID(chainID)
return &TransactOpts{
From: keyAddr,
Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
diff --git a/accounts/abi/bind/backends/simulated.go b/accounts/abi/bind/backends/simulated.go
index 4e060633f5..0a8779720b 100644
--- a/accounts/abi/bind/backends/simulated.go
+++ b/accounts/abi/bind/backends/simulated.go
@@ -644,7 +644,10 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
b.mu.Lock()
defer b.mu.Unlock()
- sender, err := types.Sender(types.NewEIP155Signer(b.config.ChainID), tx)
+ // Check transaction validity.
+ block := b.blockchain.CurrentBlock()
+ signer := types.MakeSigner(b.blockchain.Config(), block.Number())
+ sender, err := types.Sender(signer, tx)
if err != nil {
return fmt.Errorf("invalid transaction: %v", err)
}
@@ -664,7 +667,7 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
return err
}
//fmt.Printf("==== Start producing block %d\n", (b.prependBlock.NumberU64() + 1))
- blocks, receipts, err := core.GenerateChain(b.config, b.prependBlock, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
+ blocks, receipts, err := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
for _, tx := range b.pendingBlock.Transactions() {
block.AddTxWithChain(b.blockchain, tx)
}
@@ -818,6 +821,7 @@ func (m callMsg) GasPrice() *uint256.Int { return m.CallMsg.GasPrice }
func (m callMsg) Gas() uint64 { return m.CallMsg.Gas }
func (m callMsg) Value() *uint256.Int { return m.CallMsg.Value }
func (m callMsg) Data() []byte { return m.CallMsg.Data }
+func (m callMsg) AccessList() types.AccessList { return m.CallMsg.AccessList }
// filterBackend implements filters.Backend to support filtering for logs without
// taking bloom-bits acceleration structures into account.
diff --git a/accounts/keystore/keystore.go b/accounts/keystore/keystore.go
index d162af7c61..e1c7d1f25d 100644
--- a/accounts/keystore/keystore.go
+++ b/accounts/keystore/keystore.go
@@ -277,11 +277,9 @@ func (ks *KeyStore) SignTx(a accounts.Account, tx *types.Transaction, chainID *b
if !found {
return nil, ErrLocked
}
- // Depending on the presence of the chain ID, sign with EIP155 or homestead
- if chainID != nil {
- return types.SignTx(tx, types.NewEIP155Signer(chainID), unlockedKey.PrivateKey)
- }
- return types.SignTx(tx, types.HomesteadSigner{}, unlockedKey.PrivateKey)
+ // Depending on the presence of the chain ID, sign with 2718 or homestead
+ signer := types.LatestSignerForChainID(chainID)
+ return types.SignTx(tx, signer, unlockedKey.PrivateKey)
}
// SignHashWithPassphrase signs hash if the private key matching the given address
@@ -304,12 +302,9 @@ func (ks *KeyStore) SignTxWithPassphrase(a accounts.Account, passphrase string,
return nil, err
}
defer zeroKey(key.PrivateKey)
-
- // Depending on the presence of the chain ID, sign with EIP155 or homestead
- if chainID != nil {
- return types.SignTx(tx, types.NewEIP155Signer(chainID), key.PrivateKey)
- }
- return types.SignTx(tx, types.HomesteadSigner{}, key.PrivateKey)
+ // Depending on the presence of the chain ID, sign with or without replay protection.
+ signer := types.LatestSignerForChainID(chainID)
+ return types.SignTx(tx, signer, key.PrivateKey)
}
// Unlock unlocks the given account indefinitely.
diff --git a/accounts/scwallet/wallet.go b/accounts/scwallet/wallet.go
index e066eba319..57c276a50e 100644
--- a/accounts/scwallet/wallet.go
+++ b/accounts/scwallet/wallet.go
@@ -700,7 +700,7 @@ func (w *Wallet) signHash(account accounts.Account, hash []byte) ([]byte, error)
// the needed details via SignTxWithPassphrase, or by other means (e.g. unlock
// the account in a keystore).
func (w *Wallet) SignTx(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
- signer := types.NewEIP155Signer(chainID)
+ signer := types.LatestSignerForChainID(chainID)
hash := signer.Hash(tx)
sig, err := w.signHash(account, hash[:])
if err != nil {
diff --git a/accounts/usbwallet/trezor.go b/accounts/usbwallet/trezor.go
index 1f97f9f81f..776daf35a3 100644
--- a/accounts/usbwallet/trezor.go
+++ b/accounts/usbwallet/trezor.go
@@ -255,9 +255,11 @@ func (w *trezorDriver) trezorSign(derivationPath []uint32, tx *types.Transaction
if chainID == nil {
signer = new(types.HomesteadSigner)
} else {
+ // Trezor backend does not support typed transactions yet.
signer = types.NewEIP155Signer(chainID)
signature[64] -= byte(chainID.Uint64()*2 + 35)
}
+
// Inject the final signature into the transaction and sanity check the sender
signed, err := tx.WithSignature(signer, signature)
if err != nil {
diff --git a/cmd/clef/main.go b/cmd/clef/main.go
index aead1fb469..e2acd82f17 100644
--- a/cmd/clef/main.go
+++ b/cmd/clef/main.go
@@ -1128,7 +1128,7 @@ func GenDoc(ctx *cli.Context) {
rlpdata := common.FromHex("0xf85d640101948a8eafb1cf62bfbeb1741769dae1a9dd47996192018026a0716bd90515acb1e68e5ac5867aa11a1e65399c3349d479f5fb698554ebc6f293a04e8a4ebfff434e971e0ef12c5bf3a881b06fd04fc3f8b8a7291fb67a26a1d4ed")
var tx types.Transaction
- rlp.DecodeBytes(rlpdata, &tx)
+ tx.UnmarshalBinary(rlpdata)
add("OnApproved - SignTransactionResult", desc, ðapi.SignTransactionResult{Raw: rlpdata, Tx: &tx})
}
diff --git a/cmd/evm/README.md b/cmd/evm/README.md
index 8f0848bde8..7742ccbbb7 100644
--- a/cmd/evm/README.md
+++ b/cmd/evm/README.md
@@ -30,7 +30,7 @@ Command line params that has to be supported are
--trace.nomemory Disable full memory dump in traces
--trace.nostack Disable stack output in traces
--trace.noreturndata Disable return data output in traces
- --output.basedir value Specifies where output files are placed. Will be created if it does not exist. (default: ".")
+ --output.basedir value Specifies where output files are placed. Will be created if it does not exist.
--output.alloc alloc Determines where to put the alloc of the post-state.
`stdout` - into the stdout output
`stderr` - into the stderr output
@@ -237,10 +237,10 @@ Example where blockhashes are provided:
cat trace-0-0x72fadbef39cd251a437eea619cfeda752271a5faaaa2147df012e112159ffb81.jsonl | grep BLOCKHASH -C2
```
```
-{"pc":0,"op":96,"gas":"0x5f58ef8","gasCost":"0x3","memory":"0x","memSize":0,"stack":[],"returnStack":[],"returnData":null,"depth":1,"refund":0,"opName":"PUSH1","error":""}
-{"pc":2,"op":64,"gas":"0x5f58ef5","gasCost":"0x14","memory":"0x","memSize":0,"stack":["0x1"],"returnStack":[],"returnData":null,"depth":1,"refund":0,"opName":"BLOCKHASH","error":""}
-{"pc":3,"op":0,"gas":"0x5f58ee1","gasCost":"0x0","memory":"0x","memSize":0,"stack":["0xdac58aa524e50956d0c0bae7f3f8bb9d35381365d07804dd5b48a5a297c06af4"],"returnStack":[],"returnData":null,"depth":1,"refund":0,"opName":"STOP","error":""}
-{"output":"","gasUsed":"0x17","time":112885}
+{"pc":0,"op":96,"gas":"0x5f58ef8","gasCost":"0x3","memory":"0x","memSize":0,"stack":[],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"PUSH1","error":""}
+{"pc":2,"op":64,"gas":"0x5f58ef5","gasCost":"0x14","memory":"0x","memSize":0,"stack":["0x1"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"BLOCKHASH","error":""}
+{"pc":3,"op":0,"gas":"0x5f58ee1","gasCost":"0x0","memory":"0x","memSize":0,"stack":["0xdac58aa524e50956d0c0bae7f3f8bb9d35381365d07804dd5b48a5a297c06af4"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"STOP","error":""}
+{"output":"","gasUsed":"0x17","time":142709}
```
In this example, the caller has not provided the required blockhash:
@@ -256,9 +256,9 @@ Error code: 4
Another thing that can be done, is to chain invocations:
```
./evm t8n --input.alloc=./testdata/1/alloc.json --input.txs=./testdata/1/txs.json --input.env=./testdata/1/env.json --output.alloc=stdout | ./evm t8n --input.alloc=stdin --input.env=./testdata/1/env.json --input.txs=./testdata/1/txs.json
-INFO [08-03|15:25:15.168] rejected tx index=1 hash="0557ba…18d673" from=0x8A8eAFb1cf62BfBeb1741769DAE1a9dd47996192 error="nonce too low"
-INFO [08-03|15:25:15.169] rejected tx index=0 hash="0557ba…18d673" from=0x8A8eAFb1cf62BfBeb1741769DAE1a9dd47996192 error="nonce too low"
-INFO [08-03|15:25:15.169] rejected tx index=1 hash="0557ba…18d673" from=0x8A8eAFb1cf62BfBeb1741769DAE1a9dd47996192 error="nonce too low"
+INFO [01-21|22:41:22.963] rejected tx index=1 hash="0557ba…18d673" from=0x8A8eAFb1cf62BfBeb1741769DAE1a9dd47996192 error="nonce too low: address 0x8A8eAFb1cf62BfBeb1741769DAE1a9dd47996192, tx: 0 state: 1"
+INFO [01-21|22:41:22.966] rejected tx index=0 hash="0557ba…18d673" from=0x8A8eAFb1cf62BfBeb1741769DAE1a9dd47996192 error="nonce too low: address 0x8A8eAFb1cf62BfBeb1741769DAE1a9dd47996192, tx: 0 state: 1"
+INFO [01-21|22:41:22.967] rejected tx index=1 hash="0557ba…18d673" from=0x8A8eAFb1cf62BfBeb1741769DAE1a9dd47996192 error="nonce too low: address 0x8A8eAFb1cf62BfBeb1741769DAE1a9dd47996192, tx: 0 state: 1"
```
What happened here, is that we first applied two identical transactions, so the second one was rejected.
@@ -267,4 +267,3 @@ the same two transactions: this time, both failed due to too low nonce.
In order to meaningfully chain invocations, one would need to provide meaningful new `env`, otherwise the
actual blocknumber (exposed to the EVM) would not increase.
-
diff --git a/cmd/evm/internal/t8ntool/execution.go b/cmd/evm/internal/t8ntool/execution.go
index 0959bc80a6..5a4fa6d359 100644
--- a/cmd/evm/internal/t8ntool/execution.go
+++ b/cmd/evm/internal/t8ntool/execution.go
@@ -145,19 +145,9 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
vmConfig.Debug = (tracer != nil)
ibs.Prepare(tx.Hash(), blockHash, txIndex)
txContext := core.NewEVMTxContext(msg)
+ snapshot := statedb.Snapshot()
+ evm := vm.NewEVM(vmContext, txContext, statedb, chainConfig, vmConfig)
- evm := vm.NewEVM(vmContext, txContext, ibs, chainConfig, vmConfig)
- if chainConfig.IsYoloV3(vmContext.BlockNumber) {
- ibs.AddAddressToAccessList(msg.From())
- if dst := msg.To(); dst != nil {
- ibs.AddAddressToAccessList(*dst)
- // If it's a create-tx, the destination will be added inside evm.create
- }
- for _, addr := range evm.ActivePrecompiles() {
- ibs.AddAddressToAccessList(addr)
- }
- }
- snapshot := ibs.Snapshot()
// (ret []byte, usedGas uint64, failed bool, err error)
msgResult, err := core.ApplyMessage(evm, msg, gaspool, true /* refunds */, false /* gasBailout */)
if err != nil {
@@ -171,28 +161,39 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
return nil, nil, NewError(ErrorMissingBlockhash, hashError)
}
gasUsed += msgResult.UsedGas
- // Create a new receipt for the transaction, storing the intermediate root and gas used by the tx
+
+ // Receipt:
{
if chainConfig.IsByzantium(vmContext.BlockNumber) {
tds.StartNewBuffer()
}
- receipt := types.NewReceipt(msgResult.Failed(), gasUsed)
+ // Create a new receipt for the transaction, storing the intermediate root and
+ // gas used by the tx.
+ receipt := &types.Receipt{Type: tx.Type(), PostState: root, CumulativeGasUsed: gasUsed}
+ if msgResult.Failed() {
+ receipt.Status = types.ReceiptStatusFailed
+ } else {
+ receipt.Status = types.ReceiptStatusSuccessful
+ }
receipt.TxHash = tx.Hash()
receipt.GasUsed = msgResult.UsedGas
- // if the transaction created a contract, store the creation address in the receipt.
+
+ // If the transaction created a contract, store the creation address in the receipt.
if msg.To() == nil {
receipt.ContractAddress = crypto.CreateAddress(evm.TxContext.Origin, tx.Nonce())
}
+
// Set the receipt logs and create a bloom for filtering
receipt.Logs = ibs.GetLogs(tx.Hash())
receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
- // These three are non-consensus fields
+ // These three are non-consensus fields:
//receipt.BlockHash
- //receipt.BlockNumber =
+ //receipt.BlockNumber
receipt.TransactionIndex = uint(txIndex)
receipts = append(receipts, receipt)
}
+
txIndex++
}
// Add mining reward?
diff --git a/cmd/evm/internal/t8ntool/flags.go b/cmd/evm/internal/t8ntool/flags.go
index 6bee5ae728..1d129c53f1 100644
--- a/cmd/evm/internal/t8ntool/flags.go
+++ b/cmd/evm/internal/t8ntool/flags.go
@@ -47,6 +47,11 @@ var (
Usage: "Specifies where output files are placed. Will be created if it does not exist.",
Value: "",
}
+ OutputBodyFlag = cli.StringFlag{
+ Name: "output.body",
+ Usage: "If set, the RLP of the transactions (block body) will be written to this file.",
+ Value: "",
+ }
OutputAllocFlag = cli.StringFlag{
Name: "output.alloc",
Usage: "Determines where to put the `alloc` of the post-state.\n" +
diff --git a/cmd/evm/internal/t8ntool/transition.go b/cmd/evm/internal/t8ntool/transition.go
index 63f26e1af6..dc00653c92 100644
--- a/cmd/evm/internal/t8ntool/transition.go
+++ b/cmd/evm/internal/t8ntool/transition.go
@@ -17,7 +17,7 @@
package t8ntool
import (
- "context"
+ "crypto/ecdsa"
"encoding/json"
"fmt"
"io/ioutil"
@@ -26,6 +26,7 @@ import (
"path"
"github.com/ledgerwatch/turbo-geth/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ledgerwatch/turbo-geth/core"
"github.com/ledgerwatch/turbo-geth/core/state"
"github.com/ledgerwatch/turbo-geth/core/types"
@@ -33,6 +34,7 @@ import (
"github.com/ledgerwatch/turbo-geth/ethdb"
"github.com/ledgerwatch/turbo-geth/log"
"github.com/ledgerwatch/turbo-geth/params"
+ "github.com/ethereum/go-ethereum/rlp"
"github.com/ledgerwatch/turbo-geth/tests"
"github.com/urfave/cli"
@@ -67,9 +69,9 @@ func (n *NumberedError) Code() int {
}
type input struct {
- Alloc core.GenesisAlloc `json:"alloc,omitempty"`
- Env *stEnv `json:"env,omitempty"`
- Txs types.Transactions `json:"txs,omitempty"`
+ Alloc core.GenesisAlloc `json:"alloc,omitempty"`
+ Env *stEnv `json:"env,omitempty"`
+ Txs []*txWithKey `json:"txs,omitempty"`
}
func Main(ctx *cli.Context) error {
@@ -138,7 +140,7 @@ func Main(ctx *cli.Context) error {
txStr = ctx.String(InputTxsFlag.Name)
inputData = &input{}
)
-
+ // Figure out the prestate alloc
if allocStr == stdinSelector || envStr == stdinSelector || txStr == stdinSelector {
decoder := json.NewDecoder(os.Stdin)
decoder.Decode(inputData) //nolint:errcheck
@@ -154,7 +156,9 @@ func Main(ctx *cli.Context) error {
return NewError(ErrorJson, fmt.Errorf("failed unmarshaling alloc-file: %v", err))
}
}
+ prestate.Pre = inputData.Alloc
+ // Set the block environment
if envStr != stdinSelector {
inFile, err1 := os.Open(envStr)
if err1 != nil {
@@ -168,26 +172,8 @@ func Main(ctx *cli.Context) error {
}
inputData.Env = &env
}
-
- if txStr != stdinSelector {
- inFile, err1 := os.Open(txStr)
- if err1 != nil {
- return NewError(ErrorIO, fmt.Errorf("failed reading txs file: %v", err1))
- }
- defer inFile.Close()
- decoder := json.NewDecoder(inFile)
- var txs1 types.Transactions
- if err = decoder.Decode(&txs1); err != nil {
- return NewError(ErrorJson, fmt.Errorf("failed unmarshaling txs-file: %v", err))
- }
- inputData.Txs = txs1
- }
-
- prestate.Pre = inputData.Alloc
prestate.Env = *inputData.Env
- txs = inputData.Txs
- // Iterate over all the tests, run them and aggregate the results
vmConfig := vm.Config{
Tracer: tracer,
Debug: (tracer != nil),
@@ -203,25 +189,106 @@ func Main(ctx *cli.Context) error {
// Set the chain id
chainConfig.ChainID = big.NewInt(ctx.Int64(ChainIDFlag.Name))
+ var txsWithKeys []*txWithKey
+ if txStr != stdinSelector {
+ inFile, err := os.Open(txStr)
+ if err != nil {
+ return NewError(ErrorIO, fmt.Errorf("failed reading txs file: %v", err))
+ }
+ defer inFile.Close()
+ decoder := json.NewDecoder(inFile)
+ if err := decoder.Decode(&txsWithKeys); err != nil {
+ return NewError(ErrorJson, fmt.Errorf("Failed unmarshaling txs-file: %v", err))
+ }
+ } else {
+ txsWithKeys = inputData.Txs
+ }
+ // We may have to sign the transactions.
+ signer := types.MakeSigner(chainConfig, big.NewInt(int64(prestate.Env.Number)))
+
+ if txs, err = signUnsignedTransactions(txsWithKeys, signer); err != nil {
+ return NewError(ErrorJson, fmt.Errorf("Failed signing transactions: %v", err))
+ }
+
+ // Iterate over all the tests, run them and aggregate the results
+
// Run the test and aggregate the result
db, result, err := prestate.Apply(vmConfig, chainConfig, txs, ctx.Int64(RewardFlag.Name), getTracer)
if err != nil {
return err
}
+ body, _ := rlp.EncodeToBytes(txs)
// Dump the excution result
- //postAlloc := state.DumpGenesisFormat(false, false, false)
collector := make(Alloc)
+ state.DumpToCollector(collector, false, false, false, nil, -1)
+ return dispatchOutput(ctx, baseDir, result, collector, body)
+
+}
+
+// txWithKey is a helper-struct, to allow us to use the types.Transaction along with
+// a `secretKey`-field, for input
+type txWithKey struct {
+ key *ecdsa.PrivateKey
+ tx *types.Transaction
+}
- tx, err1 := db.Begin(context.Background(), ethdb.RO)
- if err1 != nil {
- return fmt.Errorf("transition cannot open tx: %v", err1)
+func (t *txWithKey) UnmarshalJSON(input []byte) error {
+ // Read the secretKey, if present
+ type sKey struct {
+ Key *common.Hash `json:"secretKey"`
+ }
+ var key sKey
+ if err := json.Unmarshal(input, &key); err != nil {
+ return err
}
- defer tx.Rollback()
+ if key.Key != nil {
+ k := key.Key.Hex()[2:]
+ if ecdsaKey, err := crypto.HexToECDSA(k); err != nil {
+ return err
+ } else {
+ t.key = ecdsaKey
+ }
+ }
+ // Now, read the transaction itself
+ var tx types.Transaction
+ if err := json.Unmarshal(input, &tx); err != nil {
+ return err
+ }
+ t.tx = &tx
+ return nil
+}
dumper := state.NewDumper(tx, 0)
- dumper.DumpToCollector(collector, false, false, false, common.Address{}, -1) //nolint:errcheck
- return dispatchOutput(ctx, baseDir, result, collector)
-
+// signUnsignedTransactions converts the input txs to canonical transactions.
+//
+// The transactions can have two forms, either
+// 1. unsigned or
+// 2. signed
+// For (1), r, s, v, need so be zero, and the `secretKey` needs to be set.
+// If so, we sign it here and now, with the given `secretKey`
+// If the condition above is not met, then it's considered a signed transaction.
+//
+// To manage this, we read the transactions twice, first trying to read the secretKeys,
+// and secondly to read them with the standard tx json format
+func signUnsignedTransactions(txs []*txWithKey, signer types.Signer) (types.Transactions, error) {
+ var signedTxs []*types.Transaction
+ for i, txWithKey := range txs {
+ tx := txWithKey.tx
+ key := txWithKey.key
+ v, r, s := tx.RawSignatureValues()
+ if key != nil && v.BitLen()+r.BitLen()+s.BitLen() == 0 {
+ // This transaction needs to be signed
+ signed, err := types.SignTx(tx, signer, key)
+ if err != nil {
+ return nil, NewError(ErrorJson, fmt.Errorf("Tx %d: failed to sign tx: %v", i, err))
+ }
+ signedTxs = append(signedTxs, signed)
+ } else {
+ // Already signed
+ signedTxs = append(signedTxs, tx)
+ }
+ }
+ return signedTxs, nil
}
type Alloc map[common.Address]core.GenesisAccount
@@ -252,15 +319,17 @@ func saveFile(baseDir, filename string, data interface{}) error {
if err != nil {
return NewError(ErrorJson, fmt.Errorf("failed marshalling output: %v", err))
}
- if err = ioutil.WriteFile(path.Join(baseDir, filename), b, 0600); err != nil {
+ location := path.Join(baseDir, filename)
+ if err = ioutil.WriteFile(location, b, 0644); err != nil {
return NewError(ErrorIO, fmt.Errorf("failed writing output: %v", err))
}
+ log.Info("Wrote file", "file", location)
return nil
}
// dispatchOutput writes the output data to either stderr or stdout, or to the specified
// files
-func dispatchOutput(ctx *cli.Context, baseDir string, result *ExecutionResult, alloc Alloc) error {
+func dispatchOutput(ctx *cli.Context, baseDir string, result *ExecutionResult, alloc Alloc, body hexutil.Bytes) error {
stdOutObject := make(map[string]interface{})
stdErrObject := make(map[string]interface{})
dispatch := func(baseDir, fName, name string, obj interface{}) error {
@@ -269,6 +338,8 @@ func dispatchOutput(ctx *cli.Context, baseDir string, result *ExecutionResult, a
stdOutObject[name] = obj
case "stderr":
stdErrObject[name] = obj
+ case "":
+ // don't save
default: // save to file
if err := saveFile(baseDir, fName, obj); err != nil {
return err
@@ -282,6 +353,9 @@ func dispatchOutput(ctx *cli.Context, baseDir string, result *ExecutionResult, a
if err := dispatch(baseDir, ctx.String(OutputResultFlag.Name), "result", result); err != nil {
return err
}
+ if err := dispatch(baseDir, ctx.String(OutputBodyFlag.Name), "body", body); err != nil {
+ return err
+ }
if len(stdOutObject) > 0 {
b, err := json.MarshalIndent(stdOutObject, "", " ")
if err != nil {
diff --git a/cmd/evm/main.go b/cmd/evm/main.go
index 3bcd4c080c..f1a0772be6 100644
--- a/cmd/evm/main.go
+++ b/cmd/evm/main.go
@@ -149,6 +149,7 @@ var stateTransitionCommand = cli.Command{
t8ntool.OutputBasedir,
t8ntool.OutputAllocFlag,
t8ntool.OutputResultFlag,
+ t8ntool.OutputBodyFlag,
t8ntool.InputAllocFlag,
t8ntool.InputEnvFlag,
t8ntool.InputTxsFlag,
diff --git a/cmd/evm/testdata/8/alloc.json b/cmd/evm/testdata/8/alloc.json
new file mode 100644
index 0000000000..1d1b5f86c6
--- /dev/null
+++ b/cmd/evm/testdata/8/alloc.json
@@ -0,0 +1,11 @@
+{
+ "0x000000000000000000000000000000000000aaaa": {
+ "balance": "0x03",
+ "code": "0x5854505854",
+ "nonce": "0x1"
+ },
+ "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b": {
+ "balance": "0x100000",
+ "nonce": "0x00"
+ }
+}
\ No newline at end of file
diff --git a/cmd/evm/testdata/8/env.json b/cmd/evm/testdata/8/env.json
new file mode 100644
index 0000000000..8b91934724
--- /dev/null
+++ b/cmd/evm/testdata/8/env.json
@@ -0,0 +1,7 @@
+{
+ "currentCoinbase": "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty": "0x20000",
+ "currentGasLimit": "0x1000000000",
+ "currentNumber": "0x1000000",
+ "currentTimestamp": "0x04"
+}
\ No newline at end of file
diff --git a/cmd/evm/testdata/8/readme.md b/cmd/evm/testdata/8/readme.md
new file mode 100644
index 0000000000..778fc6151a
--- /dev/null
+++ b/cmd/evm/testdata/8/readme.md
@@ -0,0 +1,63 @@
+## EIP-2930 testing
+
+This test contains testcases for EIP-2930, which uses transactions with access lists.
+
+### Prestate
+
+The alloc portion contains one contract (`0x000000000000000000000000000000000000aaaa`), containing the
+following code: `0x5854505854`: `PC ;SLOAD; POP; PC; SLOAD`.
+
+Essentialy, this contract does `SLOAD(0)` and `SLOAD(3)`.
+
+The alloc also contains some funds on `0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b`.
+
+## Transactions
+
+There are three transactions, each invokes the contract above.
+
+1. ACL-transaction, which contains some non-used slots
+2. Regular transaction
+3. ACL-transaction, which contains the slots `1` and `3` in `0x000000000000000000000000000000000000aaaa`
+
+## Execution
+
+Running it yields:
+```
+dir=./testdata/8 && ./evm t8n --state.fork=Berlin --input.alloc=$dir/alloc.json --input.txs=$dir/txs.json --input.env=$dir/env.json --trace && cat trace-* | grep SLOAD
+{"pc":1,"op":84,"gas":"0x484be","gasCost":"0x834","memory":"0x","memSize":0,"stack":["0x0"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"SLOAD","error":""}
+{"pc":4,"op":84,"gas":"0x47c86","gasCost":"0x834","memory":"0x","memSize":0,"stack":["0x3"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"SLOAD","error":""}
+{"pc":1,"op":84,"gas":"0x49cf6","gasCost":"0x834","memory":"0x","memSize":0,"stack":["0x0"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"SLOAD","error":""}
+{"pc":4,"op":84,"gas":"0x494be","gasCost":"0x834","memory":"0x","memSize":0,"stack":["0x3"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"SLOAD","error":""}
+{"pc":1,"op":84,"gas":"0x484be","gasCost":"0x64","memory":"0x","memSize":0,"stack":["0x0"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"SLOAD","error":""}
+{"pc":4,"op":84,"gas":"0x48456","gasCost":"0x64","memory":"0x","memSize":0,"stack":["0x3"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"SLOAD","error":""}
+
+```
+
+Simlarly, we can provide the input transactions via `stdin` instead of as file:
+
+```
+dir=./testdata/8 \
+ && cat $dir/txs.json | jq "{txs: .}" \
+ | ./evm t8n --state.fork=Berlin \
+ --input.alloc=$dir/alloc.json \
+ --input.txs=stdin \
+ --input.env=$dir/env.json \
+ --trace \
+ && cat trace-* | grep SLOAD
+
+{"pc":1,"op":84,"gas":"0x484be","gasCost":"0x834","memory":"0x","memSize":0,"stack":["0x0"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"SLOAD","error":""}
+{"pc":4,"op":84,"gas":"0x47c86","gasCost":"0x834","memory":"0x","memSize":0,"stack":["0x3"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"SLOAD","error":""}
+{"pc":1,"op":84,"gas":"0x49cf6","gasCost":"0x834","memory":"0x","memSize":0,"stack":["0x0"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"SLOAD","error":""}
+{"pc":4,"op":84,"gas":"0x494be","gasCost":"0x834","memory":"0x","memSize":0,"stack":["0x3"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"SLOAD","error":""}
+{"pc":1,"op":84,"gas":"0x484be","gasCost":"0x64","memory":"0x","memSize":0,"stack":["0x0"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"SLOAD","error":""}
+{"pc":4,"op":84,"gas":"0x48456","gasCost":"0x64","memory":"0x","memSize":0,"stack":["0x3"],"returnStack":[],"returnData":"0x","depth":1,"refund":0,"opName":"SLOAD","error":""}
+```
+
+If we try to execute it on older rules:
+```
+dir=./testdata/8 && ./evm t8n --state.fork=Istanbul --input.alloc=$dir/alloc.json --input.txs=$dir/txs.json --input.env=$dir/env.json
+INFO [01-21|23:21:51.265] rejected tx index=0 hash="d2818d…6ab3da" error="tx type not supported"
+INFO [01-21|23:21:51.265] rejected tx index=1 hash="26ea00…81c01b" from=0xa94f5374Fce5edBC8E2a8697C15331677e6EbF0B error="nonce too high: address 0xa94f5374Fce5edBC8E2a8697C15331677e6EbF0B, tx: 1 state: 0"
+INFO [01-21|23:21:51.265] rejected tx index=2 hash="698d01…369cee" error="tx type not supported"
+```
+Number `1` and `3` are not applicable, and therefore number `2` has wrong nonce.
\ No newline at end of file
diff --git a/cmd/evm/testdata/8/txs.json b/cmd/evm/testdata/8/txs.json
new file mode 100644
index 0000000000..35142ba234
--- /dev/null
+++ b/cmd/evm/testdata/8/txs.json
@@ -0,0 +1,58 @@
+[
+ {
+ "gas": "0x4ef00",
+ "gasPrice": "0x1",
+ "chainId": "0x1",
+ "input": "0x",
+ "nonce": "0x0",
+ "to": "0x000000000000000000000000000000000000aaaa",
+ "value": "0x1",
+ "type" : "0x1",
+ "accessList": [
+ {"address": "0x0000000000000000000000000000000000000000",
+ "storageKeys": [
+ "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "0x0000000000000000000000000000000000000000000000000000000000000000"
+ ]
+ }
+ ],
+ "v": "0x0",
+ "r": "0x0",
+ "s": "0x0",
+ "secretKey": "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8"
+ },
+ {
+ "gas": "0x4ef00",
+ "gasPrice": "0x1",
+ "input": "0x",
+ "nonce": "0x1",
+ "to": "0x000000000000000000000000000000000000aaaa",
+ "value": "0x2",
+ "v": "0x0",
+ "r": "0x0",
+ "s": "0x0",
+ "secretKey": "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8"
+ },
+ {
+ "gas": "0x4ef00",
+ "gasPrice": "0x1",
+ "chainId": "0x1",
+ "input": "0x",
+ "nonce": "0x2",
+ "to": "0x000000000000000000000000000000000000aaaa",
+ "value": "0x1",
+ "type" : "0x1",
+ "accessList": [
+ {"address": "0x000000000000000000000000000000000000aaaa",
+ "storageKeys": [
+ "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "0x0000000000000000000000000000000000000000000000000000000000000003"
+ ]
+ }
+ ],
+ "v": "0x0",
+ "r": "0x0",
+ "s": "0x0",
+ "secretKey": "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8"
+ }
+]
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
index 9c6d005217..c6573012a2 100644
--- a/cmd/utils/flags.go
+++ b/cmd/utils/flags.go
@@ -1310,7 +1310,7 @@ func setDataDir(ctx *cli.Context, cfg *node.Config) {
case ctx.GlobalBool(GoerliFlag.Name) && cfg.DataDir == node.DefaultDataDir():
cfg.DataDir = filepath.Join(node.DefaultDataDir(), "goerli")
case ctx.GlobalBool(YoloV3Flag.Name) && cfg.DataDir == node.DefaultDataDir():
- cfg.DataDir = filepath.Join(node.DefaultDataDir(), "yolo-v2")
+ cfg.DataDir = filepath.Join(node.DefaultDataDir(), "yolo-v3")
}
}
@@ -1638,7 +1638,7 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) {
SetDNSDiscoveryDefaults(cfg, params.GoerliGenesisHash)
case ctx.GlobalBool(YoloV3Flag.Name):
if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
- cfg.NetworkId = new(big.Int).SetBytes([]byte("yolov3")).Uint64() // "yolov3"
+ cfg.NetworkId = new(big.Int).SetBytes([]byte("yolov3x")).Uint64() // "yolov3x"
}
cfg.Genesis = core.DefaultYoloV3GenesisBlock()
case ctx.GlobalBool(DeveloperFlag.Name):
diff --git a/core/bench_test.go b/core/bench_test.go
index 140d1959dc..aed7bb9dbc 100644
--- a/core/bench_test.go
+++ b/core/bench_test.go
@@ -89,7 +89,7 @@ func genValueTx(nbytes int) func(int, *BlockGen) {
return func(i int, gen *BlockGen) {
toaddr := common.Address{}
data := make([]byte, nbytes)
- gas, _ := IntrinsicGas(data, false, false, false)
+ gas, _ := IntrinsicGas(data, nil, false, false, false)
tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(benchRootAddr), toaddr, u256.Num1, gas, nil, data), types.HomesteadSigner{}, benchRootKey)
gen.AddTx(tx)
}
diff --git a/core/error.go b/core/error.go
index 5a28be7e1c..197dd81567 100644
--- a/core/error.go
+++ b/core/error.go
@@ -16,7 +16,11 @@
package core
-import "errors"
+import (
+ "errors"
+
+ "github.com/ethereum/go-ethereum/core/types"
+)
var (
// ErrKnownBlock is returned when a block to import is already known locally.
@@ -63,4 +67,8 @@ var (
// ErrIntrinsicGas is returned if the transaction is specified to use less gas
// than required to start the invocation.
ErrIntrinsicGas = errors.New("intrinsic gas too low")
+
+ // ErrTxTypeNotSupported is returned if a transaction is not supported in the
+ // current network configuration.
+ ErrTxTypeNotSupported = types.ErrTxTypeNotSupported
)
diff --git a/core/genesis.go b/core/genesis.go
index fbf7287b20..0c2c46eec6 100644
--- a/core/genesis.go
+++ b/core/genesis.go
@@ -464,11 +464,11 @@ func DefaultGoerliGenesisBlock() *Genesis {
}
func DefaultYoloV3GenesisBlock() *Genesis {
- // Full genesis: https://gist.github.com/holiman/b2c32a05ff2e2712e11c0787d987d46f
+ // Full genesis: https://gist.github.com/holiman/c6ed9269dce28304ad176314caa75e97
return &Genesis{
Config: params.YoloV3ChainConfig,
- Timestamp: 0x60117f8b,
- ExtraData: hexutil.MustDecode("0x00000000000000000000000000000000000000000000000000000000000000008a37866fd3627c9205a37c8685666f32ec07bb1b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
+ Timestamp: 0x6027dd2e,
+ ExtraData: hexutil.MustDecode("0x00000000000000000000000000000000000000000000000000000000000000001041afbcb359d5a8dc58c15b2ff51354ff8a217d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
GasLimit: 0x47b760,
Difficulty: big.NewInt(1),
Alloc: decodePrealloc(yoloV3AllocData),
diff --git a/core/genesis_alloc.go b/core/genesis_alloc.go
index 6eecbbf0e8..5b0e933d7a 100644
--- a/core/genesis_alloc.go
+++ b/core/genesis_alloc.go
@@ -25,5 +25,4 @@ const mainnetAllocData = "\xfa\x04]X\u0793\r\x83b\x011\x8e\u0189\x9agT\x06\x908'
const ropstenAllocData = "\xf9\x03\xa4\u0080\x01\xc2\x01\x01\xc2\x02\x01\xc2\x03\x01\xc2\x04\x01\xc2\x05\x01\xc2\x06\x01\xc2\a\x01\xc2\b\x01\xc2\t\x01\xc2\n\x80\xc2\v\x80\xc2\f\x80\xc2\r\x80\xc2\x0e\x80\xc2\x0f\x80\xc2\x10\x80\xc2\x11\x80\xc2\x12\x80\xc2\x13\x80\xc2\x14\x80\xc2\x15\x80\xc2\x16\x80\xc2\x17\x80\xc2\x18\x80\xc2\x19\x80\xc2\x1a\x80\xc2\x1b\x80\xc2\x1c\x80\xc2\x1d\x80\xc2\x1e\x80\xc2\x1f\x80\xc2 \x80\xc2!\x80\xc2\"\x80\xc2#\x80\xc2$\x80\xc2%\x80\xc2&\x80\xc2'\x80\xc2(\x80\xc2)\x80\xc2*\x80\xc2+\x80\xc2,\x80\xc2-\x80\xc2.\x80\xc2/\x80\xc20\x80\xc21\x80\xc22\x80\xc23\x80\xc24\x80\xc25\x80\xc26\x80\xc27\x80\xc28\x80\xc29\x80\xc2:\x80\xc2;\x80\xc2<\x80\xc2=\x80\xc2>\x80\xc2?\x80\xc2@\x80\xc2A\x80\xc2B\x80\xc2C\x80\xc2D\x80\xc2E\x80\xc2F\x80\xc2G\x80\xc2H\x80\xc2I\x80\xc2J\x80\xc2K\x80\xc2L\x80\xc2M\x80\xc2N\x80\xc2O\x80\xc2P\x80\xc2Q\x80\xc2R\x80\xc2S\x80\xc2T\x80\xc2U\x80\xc2V\x80\xc2W\x80\xc2X\x80\xc2Y\x80\xc2Z\x80\xc2[\x80\xc2\\\x80\xc2]\x80\xc2^\x80\xc2_\x80\xc2`\x80\xc2a\x80\xc2b\x80\xc2c\x80\xc2d\x80\xc2e\x80\xc2f\x80\xc2g\x80\xc2h\x80\xc2i\x80\xc2j\x80\xc2k\x80\xc2l\x80\xc2m\x80\xc2n\x80\xc2o\x80\xc2p\x80\xc2q\x80\xc2r\x80\xc2s\x80\xc2t\x80\xc2u\x80\xc2v\x80\xc2w\x80\xc2x\x80\xc2y\x80\xc2z\x80\xc2{\x80\xc2|\x80\xc2}\x80\xc2~\x80\xc2\u007f\x80\u00c1\x80\x80\u00c1\x81\x80\u00c1\x82\x80\u00c1\x83\x80\u00c1\x84\x80\u00c1\x85\x80\u00c1\x86\x80\u00c1\x87\x80\u00c1\x88\x80\u00c1\x89\x80\u00c1\x8a\x80\u00c1\x8b\x80\u00c1\x8c\x80\u00c1\x8d\x80\u00c1\x8e\x80\u00c1\x8f\x80\u00c1\x90\x80\u00c1\x91\x80\u00c1\x92\x80\u00c1\x93\x80\u00c1\x94\x80\u00c1\x95\x80\u00c1\x96\x80\u00c1\x97\x80\u00c1\x98\x80\u00c1\x99\x80\u00c1\x9a\x80\u00c1\x9b\x80\u00c1\x9c\x80\u00c1\x9d\x80\u00c1\x9e\x80\u00c1\x9f\x80\u00c1\xa0\x80\u00c1\xa1\x80\u00c1\xa2\x80\u00c1\xa3\x80\u00c1\xa4\x80\u00c1\xa5\x80\u00c1\xa6\x80\u00c1\xa7\x80\u00c1\xa8\x80\u00c1\xa9\x80\u00c1\xaa\x80\u00c1\xab\x80\u00c1\xac\x80\u00c1\xad\x80\u00c1\xae\x80\u00c1\xaf\x80\u00c1\xb0\x80\u00c1\xb1\x80\u00c1\xb2\x80\u00c1\xb3\x80\u00c1\xb4\x80\u00c1\xb5\x80\u00c1\xb6\x80\u00c1\xb7\x80\u00c1\xb8\x80\u00c1\xb9\x80\u00c1\xba\x80\u00c1\xbb\x80\u00c1\xbc\x80\u00c1\xbd\x80\u00c1\xbe\x80\u00c1\xbf\x80\u00c1\xc0\x80\u00c1\xc1\x80\u00c1\u0080\u00c1\u00c0\u00c1\u0100\u00c1\u0140\u00c1\u0180\u00c1\u01c0\u00c1\u0200\u00c1\u0240\u00c1\u0280\u00c1\u02c0\u00c1\u0300\u00c1\u0340\u00c1\u0380\u00c1\u03c0\u00c1\u0400\u00c1\u0440\u00c1\u0480\u00c1\u04c0\u00c1\u0500\u00c1\u0540\u00c1\u0580\u00c1\u05c0\u00c1\u0600\u00c1\u0640\u00c1\u0680\u00c1\u06c0\u00c1\u0700\u00c1\u0740\u00c1\u0780\u00c1\u07c0\u00c1\xe0\x80\u00c1\xe1\x80\u00c1\xe2\x80\u00c1\xe3\x80\u00c1\xe4\x80\u00c1\xe5\x80\u00c1\xe6\x80\u00c1\xe7\x80\u00c1\xe8\x80\u00c1\xe9\x80\u00c1\xea\x80\u00c1\xeb\x80\u00c1\xec\x80\u00c1\xed\x80\u00c1\xee\x80\u00c1\xef\x80\u00c1\xf0\x80\u00c1\xf1\x80\u00c1\xf2\x80\u00c1\xf3\x80\u00c1\xf4\x80\u00c1\xf5\x80\u00c1\xf6\x80\u00c1\xf7\x80\u00c1\xf8\x80\u00c1\xf9\x80\u00c1\xfa\x80\u00c1\xfb\x80\u00c1\xfc\x80\u00c1\xfd\x80\u00c1\xfe\x80\u00c1\xff\x80\u3507KT\xa8\xbd\x15)f\xd6?pk\xae\x1f\xfe\xb0A\x19!\xe5\x8d\f\x9f,\x9c\xd0Ft\xed\xea@\x00\x00\x00"
const rinkebyAllocData = "\xf9\x03\xb7\u0080\x01\xc2\x01\x01\xc2\x02\x01\xc2\x03\x01\xc2\x04\x01\xc2\x05\x01\xc2\x06\x01\xc2\a\x01\xc2\b\x01\xc2\t\x01\xc2\n\x01\xc2\v\x01\xc2\f\x01\xc2\r\x01\xc2\x0e\x01\xc2\x0f\x01\xc2\x10\x01\xc2\x11\x01\xc2\x12\x01\xc2\x13\x01\xc2\x14\x01\xc2\x15\x01\xc2\x16\x01\xc2\x17\x01\xc2\x18\x01\xc2\x19\x01\xc2\x1a\x01\xc2\x1b\x01\xc2\x1c\x01\xc2\x1d\x01\xc2\x1e\x01\xc2\x1f\x01\xc2 \x01\xc2!\x01\xc2\"\x01\xc2#\x01\xc2$\x01\xc2%\x01\xc2&\x01\xc2'\x01\xc2(\x01\xc2)\x01\xc2*\x01\xc2+\x01\xc2,\x01\xc2-\x01\xc2.\x01\xc2/\x01\xc20\x01\xc21\x01\xc22\x01\xc23\x01\xc24\x01\xc25\x01\xc26\x01\xc27\x01\xc28\x01\xc29\x01\xc2:\x01\xc2;\x01\xc2<\x01\xc2=\x01\xc2>\x01\xc2?\x01\xc2@\x01\xc2A\x01\xc2B\x01\xc2C\x01\xc2D\x01\xc2E\x01\xc2F\x01\xc2G\x01\xc2H\x01\xc2I\x01\xc2J\x01\xc2K\x01\xc2L\x01\xc2M\x01\xc2N\x01\xc2O\x01\xc2P\x01\xc2Q\x01\xc2R\x01\xc2S\x01\xc2T\x01\xc2U\x01\xc2V\x01\xc2W\x01\xc2X\x01\xc2Y\x01\xc2Z\x01\xc2[\x01\xc2\\\x01\xc2]\x01\xc2^\x01\xc2_\x01\xc2`\x01\xc2a\x01\xc2b\x01\xc2c\x01\xc2d\x01\xc2e\x01\xc2f\x01\xc2g\x01\xc2h\x01\xc2i\x01\xc2j\x01\xc2k\x01\xc2l\x01\xc2m\x01\xc2n\x01\xc2o\x01\xc2p\x01\xc2q\x01\xc2r\x01\xc2s\x01\xc2t\x01\xc2u\x01\xc2v\x01\xc2w\x01\xc2x\x01\xc2y\x01\xc2z\x01\xc2{\x01\xc2|\x01\xc2}\x01\xc2~\x01\xc2\u007f\x01\u00c1\x80\x01\u00c1\x81\x01\u00c1\x82\x01\u00c1\x83\x01\u00c1\x84\x01\u00c1\x85\x01\u00c1\x86\x01\u00c1\x87\x01\u00c1\x88\x01\u00c1\x89\x01\u00c1\x8a\x01\u00c1\x8b\x01\u00c1\x8c\x01\u00c1\x8d\x01\u00c1\x8e\x01\u00c1\x8f\x01\u00c1\x90\x01\u00c1\x91\x01\u00c1\x92\x01\u00c1\x93\x01\u00c1\x94\x01\u00c1\x95\x01\u00c1\x96\x01\u00c1\x97\x01\u00c1\x98\x01\u00c1\x99\x01\u00c1\x9a\x01\u00c1\x9b\x01\u00c1\x9c\x01\u00c1\x9d\x01\u00c1\x9e\x01\u00c1\x9f\x01\u00c1\xa0\x01\u00c1\xa1\x01\u00c1\xa2\x01\u00c1\xa3\x01\u00c1\xa4\x01\u00c1\xa5\x01\u00c1\xa6\x01\u00c1\xa7\x01\u00c1\xa8\x01\u00c1\xa9\x01\u00c1\xaa\x01\u00c1\xab\x01\u00c1\xac\x01\u00c1\xad\x01\u00c1\xae\x01\u00c1\xaf\x01\u00c1\xb0\x01\u00c1\xb1\x01\u00c1\xb2\x01\u00c1\xb3\x01\u00c1\xb4\x01\u00c1\xb5\x01\u00c1\xb6\x01\u00c1\xb7\x01\u00c1\xb8\x01\u00c1\xb9\x01\u00c1\xba\x01\u00c1\xbb\x01\u00c1\xbc\x01\u00c1\xbd\x01\u00c1\xbe\x01\u00c1\xbf\x01\u00c1\xc0\x01\u00c1\xc1\x01\u00c1\xc2\x01\u00c1\xc3\x01\u00c1\xc4\x01\u00c1\xc5\x01\u00c1\xc6\x01\u00c1\xc7\x01\u00c1\xc8\x01\u00c1\xc9\x01\u00c1\xca\x01\u00c1\xcb\x01\u00c1\xcc\x01\u00c1\xcd\x01\u00c1\xce\x01\u00c1\xcf\x01\u00c1\xd0\x01\u00c1\xd1\x01\u00c1\xd2\x01\u00c1\xd3\x01\u00c1\xd4\x01\u00c1\xd5\x01\u00c1\xd6\x01\u00c1\xd7\x01\u00c1\xd8\x01\u00c1\xd9\x01\u00c1\xda\x01\u00c1\xdb\x01\u00c1\xdc\x01\u00c1\xdd\x01\u00c1\xde\x01\u00c1\xdf\x01\u00c1\xe0\x01\u00c1\xe1\x01\u00c1\xe2\x01\u00c1\xe3\x01\u00c1\xe4\x01\u00c1\xe5\x01\u00c1\xe6\x01\u00c1\xe7\x01\u00c1\xe8\x01\u00c1\xe9\x01\u00c1\xea\x01\u00c1\xeb\x01\u00c1\xec\x01\u00c1\xed\x01\u00c1\xee\x01\u00c1\xef\x01\u00c1\xf0\x01\u00c1\xf1\x01\u00c1\xf2\x01\u00c1\xf3\x01\u00c1\xf4\x01\u00c1\xf5\x01\u00c1\xf6\x01\u00c1\xf7\x01\u00c1\xf8\x01\u00c1\xf9\x01\u00c1\xfa\x01\u00c1\xfb\x01\u00c1\xfc\x01\u00c1\xfd\x01\u00c1\xfe\x01\u00c1\xff\x01\xf6\x941\xb9\x8d\x14\x00{\xde\xe67)\x80\x86\x98\x8a\v\xbd1\x18E#\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
const goerliAllocData = "\xf9\x04\x06\u0080\x01\xc2\x01\x01\xc2\x02\x01\xc2\x03\x01\xc2\x04\x01\xc2\x05\x01\xc2\x06\x01\xc2\a\x01\xc2\b\x01\xc2\t\x01\xc2\n\x01\xc2\v\x01\xc2\f\x01\xc2\r\x01\xc2\x0e\x01\xc2\x0f\x01\xc2\x10\x01\xc2\x11\x01\xc2\x12\x01\xc2\x13\x01\xc2\x14\x01\xc2\x15\x01\xc2\x16\x01\xc2\x17\x01\xc2\x18\x01\xc2\x19\x01\xc2\x1a\x01\xc2\x1b\x01\xc2\x1c\x01\xc2\x1d\x01\xc2\x1e\x01\xc2\x1f\x01\xc2 \x01\xc2!\x01\xc2\"\x01\xc2#\x01\xc2$\x01\xc2%\x01\xc2&\x01\xc2'\x01\xc2(\x01\xc2)\x01\xc2*\x01\xc2+\x01\xc2,\x01\xc2-\x01\xc2.\x01\xc2/\x01\xc20\x01\xc21\x01\xc22\x01\xc23\x01\xc24\x01\xc25\x01\xc26\x01\xc27\x01\xc28\x01\xc29\x01\xc2:\x01\xc2;\x01\xc2<\x01\xc2=\x01\xc2>\x01\xc2?\x01\xc2@\x01\xc2A\x01\xc2B\x01\xc2C\x01\xc2D\x01\xc2E\x01\xc2F\x01\xc2G\x01\xc2H\x01\xc2I\x01\xc2J\x01\xc2K\x01\xc2L\x01\xc2M\x01\xc2N\x01\xc2O\x01\xc2P\x01\xc2Q\x01\xc2R\x01\xc2S\x01\xc2T\x01\xc2U\x01\xc2V\x01\xc2W\x01\xc2X\x01\xc2Y\x01\xc2Z\x01\xc2[\x01\xc2\\\x01\xc2]\x01\xc2^\x01\xc2_\x01\xc2`\x01\xc2a\x01\xc2b\x01\xc2c\x01\xc2d\x01\xc2e\x01\xc2f\x01\xc2g\x01\xc2h\x01\xc2i\x01\xc2j\x01\xc2k\x01\xc2l\x01\xc2m\x01\xc2n\x01\xc2o\x01\xc2p\x01\xc2q\x01\xc2r\x01\xc2s\x01\xc2t\x01\xc2u\x01\xc2v\x01\xc2w\x01\xc2x\x01\xc2y\x01\xc2z\x01\xc2{\x01\xc2|\x01\xc2}\x01\xc2~\x01\xc2\u007f\x01\u00c1\x80\x01\u00c1\x81\x01\u00c1\x82\x01\u00c1\x83\x01\u00c1\x84\x01\u00c1\x85\x01\u00c1\x86\x01\u00c1\x87\x01\u00c1\x88\x01\u00c1\x89\x01\u00c1\x8a\x01\u00c1\x8b\x01\u00c1\x8c\x01\u00c1\x8d\x01\u00c1\x8e\x01\u00c1\x8f\x01\u00c1\x90\x01\u00c1\x91\x01\u00c1\x92\x01\u00c1\x93\x01\u00c1\x94\x01\u00c1\x95\x01\u00c1\x96\x01\u00c1\x97\x01\u00c1\x98\x01\u00c1\x99\x01\u00c1\x9a\x01\u00c1\x9b\x01\u00c1\x9c\x01\u00c1\x9d\x01\u00c1\x9e\x01\u00c1\x9f\x01\u00c1\xa0\x01\u00c1\xa1\x01\u00c1\xa2\x01\u00c1\xa3\x01\u00c1\xa4\x01\u00c1\xa5\x01\u00c1\xa6\x01\u00c1\xa7\x01\u00c1\xa8\x01\u00c1\xa9\x01\u00c1\xaa\x01\u00c1\xab\x01\u00c1\xac\x01\u00c1\xad\x01\u00c1\xae\x01\u00c1\xaf\x01\u00c1\xb0\x01\u00c1\xb1\x01\u00c1\xb2\x01\u00c1\xb3\x01\u00c1\xb4\x01\u00c1\xb5\x01\u00c1\xb6\x01\u00c1\xb7\x01\u00c1\xb8\x01\u00c1\xb9\x01\u00c1\xba\x01\u00c1\xbb\x01\u00c1\xbc\x01\u00c1\xbd\x01\u00c1\xbe\x01\u00c1\xbf\x01\u00c1\xc0\x01\u00c1\xc1\x01\u00c1\xc2\x01\u00c1\xc3\x01\u00c1\xc4\x01\u00c1\xc5\x01\u00c1\xc6\x01\u00c1\xc7\x01\u00c1\xc8\x01\u00c1\xc9\x01\u00c1\xca\x01\u00c1\xcb\x01\u00c1\xcc\x01\u00c1\xcd\x01\u00c1\xce\x01\u00c1\xcf\x01\u00c1\xd0\x01\u00c1\xd1\x01\u00c1\xd2\x01\u00c1\xd3\x01\u00c1\xd4\x01\u00c1\xd5\x01\u00c1\xd6\x01\u00c1\xd7\x01\u00c1\xd8\x01\u00c1\xd9\x01\u00c1\xda\x01\u00c1\xdb\x01\u00c1\xdc\x01\u00c1\xdd\x01\u00c1\xde\x01\u00c1\xdf\x01\u00c1\xe0\x01\u00c1\xe1\x01\u00c1\xe2\x01\u00c1\xe3\x01\u00c1\xe4\x01\u00c1\xe5\x01\u00c1\xe6\x01\u00c1\xe7\x01\u00c1\xe8\x01\u00c1\xe9\x01\u00c1\xea\x01\u00c1\xeb\x01\u00c1\xec\x01\u00c1\xed\x01\u00c1\xee\x01\u00c1\xef\x01\u00c1\xf0\x01\u00c1\xf1\x01\u00c1\xf2\x01\u00c1\xf3\x01\u00c1\xf4\x01\u00c1\xf5\x01\u00c1\xf6\x01\u00c1\xf7\x01\u00c1\xf8\x01\u00c1\xf9\x01\u00c1\xfa\x01\u00c1\xfb\x01\u00c1\xfc\x01\u00c1\xfd\x01\u00c1\xfe\x01\u00c1\xff\x01\xe0\x94L*\xe4\x82Y5\x05\xf0\x16<\xde\xfc\a>\x81\xc6<\xdaA\a\x8a\x15-\x02\xc7\xe1J\xf6\x80\x00\x00\xe0\x94\xa8\xe8\xf1G2e\x8eKQ\xe8q\x191\x05:\x8ai\xba\xf2\xb1\x8a\x15-\x02\xc7\xe1J\xf6\x80\x00\x00\xe1\x94\u0665\x17\x9f\t\x1d\x85\x05\x1d<\x98'\x85\xef\xd1E\\\uc199\x8b\bE\x95\x16\x14\x01HJ\x00\x00\x00\xe1\x94\u08bdBX\xd2v\x887\xba\xa2j(\xfeq\xdc\a\x9f\x84\u01cbJG\xe3\xc1$H\xf4\xad\x00\x00\x00"
-const yoloV3AllocData = "\xf9\x05\x01\u0080\x01\xc2\x01\x01\xc2\x02\x01\xc2\x03\x01\xc2\x04\x01\xc2\x05\x01\xc2\x06\x01\xc2\a\x01\xc2\b\x01\xc2\t\x01\xc2\n\x01\xc2\v\x01\xc2\f\x01\xc2\r\x01\xc2\x0e\x01\xc2\x0f\x01\xc2\x10\x01\xc2\x11\x01\xc2\x12\x01\xc2\x13\x01\xc2\x14\x01\xc2\x15\x01\xc2\x16\x01\xc2\x17\x01\xc2\x18\x01\xc2\x19\x01\xc2\x1a\x01\xc2\x1b\x01\xc2\x1c\x01\xc2\x1d\x01\xc2\x1e\x01\xc2\x1f\x01\xc2 \x01\xc2!\x01\xc2\"\x01\xc2#\x01\xc2$\x01\xc2%\x01\xc2&\x01\xc2'\x01\xc2(\x01\xc2)\x01\xc2*\x01\xc2+\x01\xc2,\x01\xc2-\x01\xc2.\x01\xc2/\x01\xc20\x01\xc21\x01\xc22\x01\xc23\x01\xc24\x01\xc25\x01\xc26\x01\xc27\x01\xc28\x01\xc29\x01\xc2:\x01\xc2;\x01\xc2<\x01\xc2=\x01\xc2>\x01\xc2?\x01\xc2@\x01\xc2A\x01\xc2B\x01\xc2C\x01\xc2D\x01\xc2E\x01\xc2F\x01\xc2G\x01\xc2H\x01\xc2I\x01\xc2J\x01\xc2K\x01\xc2L\x01\xc2M\x01\xc2N\x01\xc2O\x01\xc2P\x01\xc2Q\x01\xc2R\x01\xc2S\x01\xc2T\x01\xc2U\x01\xc2V\x01\xc2W\x01\xc2X\x01\xc2Y\x01\xc2Z\x01\xc2[\x01\xc2\\\x01\xc2]\x01\xc2^\x01\xc2_\x01\xc2`\x01\xc2a\x01\xc2b\x01\xc2c\x01\xc2d\x01\xc2e\x01\xc2f\x01\xc2g\x01\xc2h\x01\xc2i\x01\xc2j\x01\xc2k\x01\xc2l\x01\xc2m\x01\xc2n\x01\xc2o\x01\xc2p\x01\xc2q\x01\xc2r\x01\xc2s\x01\xc2t\x01\xc2u\x01\xc2v\x01\xc2w\x01\xc2x\x01\xc2y\x01\xc2z\x01\xc2{\x01\xc2|\x01\xc2}\x01\xc2~\x01\xc2\u007f\x01\u00c1\x80\x01\u00c1\x81\x01\u00c1\x82\x01\u00c1\x83\x01\u00c1\x84\x01\u00c1\x85\x01\u00c1\x86\x01\u00c1\x87\x01\u00c1\x88\x01\u00c1\x89\x01\u00c1\x8a\x01\u00c1\x8b\x01\u00c1\x8c\x01\u00c1\x8d\x01\u00c1\x8e\x01\u00c1\x8f\x01\u00c1\x90\x01\u00c1\x91\x01\u00c1\x92\x01\u00c1\x93\x01\u00c1\x94\x01\u00c1\x95\x01\u00c1\x96\x01\u00c1\x97\x01\u00c1\x98\x01\u00c1\x99\x01\u00c1\x9a\x01\u00c1\x9b\x01\u00c1\x9c\x01\u00c1\x9d\x01\u00c1\x9e\x01\u00c1\x9f\x01\u00c1\xa0\x01\u00c1\xa1\x01\u00c1\xa2\x01\u00c1\xa3\x01\u00c1\xa4\x01\u00c1\xa5\x01\u00c1\xa6\x01\u00c1\xa7\x01\u00c1\xa8\x01\u00c1\xa9\x01\u00c1\xaa\x01\u00c1\xab\x01\u00c1\xac\x01\u00c1\xad\x01\u00c1\xae\x01\u00c1\xaf\x01\u00c1\xb0\x01\u00c1\xb1\x01\u00c1\xb2\x01\u00c1\xb3\x01\u00c1\xb4\x01\u00c1\xb5\x01\u00c1\xb6\x01\u00c1\xb7\x01\u00c1\xb8\x01\u00c1\xb9\x01\u00c1\xba\x01\u00c1\xbb\x01\u00c1\xbc\x01\u00c1\xbd\x01\u00c1\xbe\x01\u00c1\xbf\x01\u00c1\xc0\x01\u00c1\xc1\x01\u00c1\xc2\x01\u00c1\xc3\x01\u00c1\xc4\x01\u00c1\xc5\x01\u00c1\xc6\x01\u00c1\xc7\x01\u00c1\xc8\x01\u00c1\xc9\x01\u00c1\xca\x01\u00c1\xcb\x01\u00c1\xcc\x01\u00c1\xcd\x01\u00c1\xce\x01\u00c1\xcf\x01\u00c1\xd0\x01\u00c1\xd1\x01\u00c1\xd2\x01\u00c1\xd3\x01\u00c1\xd4\x01\u00c1\xd5\x01\u00c1\xd6\x01\u00c1\xd7\x01\u00c1\xd8\x01\u00c1\xd9\x01\u00c1\xda\x01\u00c1\xdb\x01\u00c1\xdc\x01\u00c1\xdd\x01\u00c1\xde\x01\u00c1\xdf\x01\u00c1\xe0\x01\u00c1\xe1\x01\u00c1\xe2\x01\u00c1\xe3\x01\u00c1\xe4\x01\u00c1\xe5\x01\u00c1\xe6\x01\u00c1\xe7\x01\u00c1\xe8\x01\u00c1\xe9\x01\u00c1\xea\x01\u00c1\xeb\x01\u00c1\xec\x01\u00c1\xed\x01\u00c1\xee\x01\u00c1\xef\x01\u00c1\xf0\x01\u00c1\xf1\x01\u00c1\xf2\x01\u00c1\xf3\x01\u00c1\xf4\x01\u00c1\xf5\x01\u00c1\xf6\x01\u00c1\xf7\x01\u00c1\xf8\x01\u00c1\xf9\x01\u00c1\xfa\x01\u00c1\xfb\x01\u00c1\xfc\x01\u00c1\xfd\x01\u00c1\xfe\x01\u00c1\xff\x01\xf6\x94\x0e\x89\xe2\xae\xdb\x1c\xfc\u06d4$\xd4\x1a\x1f!\x8fA2s\x81r\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94`\xad\xc0\xf8\x9aA\xaf#|\xe75T\xed\xe1p\xd73\xec\x14\xe0\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94y\x9d2\x9e_X4\x19\x16|\xd7\"\x96$\x85\x92n3\x8fJ\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94|\xf5\xb7\x9b\xfe)\x1ag\xab\x02\xb3\x93\xe4V\xcc\xc4\xc2f\xf7S\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94\x8a\x8e\xaf\xb1\xcfb\xbf\xbe\xb1t\x17i\xda\xe1\xa9\xddG\x99a\x92\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94\x8b\xa1\xf1\tU\x1b\xd42\x800\x12dZ\xc16\xdd\xd6M\xbar\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94\xb0*.\xda\x1b1\u007f\xbd\x16v\x01(\x83k\n\u015bV\x0e\x9d\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-
+const yoloV3AllocData = "\xf9\x05o\u0080\x01\xc2\x01\x01\xc2\x02\x01\xc2\x03\x01\xc2\x04\x01\xc2\x05\x01\xc2\x06\x01\xc2\a\x01\xc2\b\x01\xc2\t\x01\xc2\n\x01\xc2\v\x01\xc2\f\x01\xc2\r\x01\xc2\x0e\x01\xc2\x0f\x01\xc2\x10\x01\xc2\x11\x01\xc2\x12\x01\xc2\x13\x01\xc2\x14\x01\xc2\x15\x01\xc2\x16\x01\xc2\x17\x01\xc2\x18\x01\xc2\x19\x01\xc2\x1a\x01\xc2\x1b\x01\xc2\x1c\x01\xc2\x1d\x01\xc2\x1e\x01\xc2\x1f\x01\xc2 \x01\xc2!\x01\xc2\"\x01\xc2#\x01\xc2$\x01\xc2%\x01\xc2&\x01\xc2'\x01\xc2(\x01\xc2)\x01\xc2*\x01\xc2+\x01\xc2,\x01\xc2-\x01\xc2.\x01\xc2/\x01\xc20\x01\xc21\x01\xc22\x01\xc23\x01\xc24\x01\xc25\x01\xc26\x01\xc27\x01\xc28\x01\xc29\x01\xc2:\x01\xc2;\x01\xc2<\x01\xc2=\x01\xc2>\x01\xc2?\x01\xc2@\x01\xc2A\x01\xc2B\x01\xc2C\x01\xc2D\x01\xc2E\x01\xc2F\x01\xc2G\x01\xc2H\x01\xc2I\x01\xc2J\x01\xc2K\x01\xc2L\x01\xc2M\x01\xc2N\x01\xc2O\x01\xc2P\x01\xc2Q\x01\xc2R\x01\xc2S\x01\xc2T\x01\xc2U\x01\xc2V\x01\xc2W\x01\xc2X\x01\xc2Y\x01\xc2Z\x01\xc2[\x01\xc2\\\x01\xc2]\x01\xc2^\x01\xc2_\x01\xc2`\x01\xc2a\x01\xc2b\x01\xc2c\x01\xc2d\x01\xc2e\x01\xc2f\x01\xc2g\x01\xc2h\x01\xc2i\x01\xc2j\x01\xc2k\x01\xc2l\x01\xc2m\x01\xc2n\x01\xc2o\x01\xc2p\x01\xc2q\x01\xc2r\x01\xc2s\x01\xc2t\x01\xc2u\x01\xc2v\x01\xc2w\x01\xc2x\x01\xc2y\x01\xc2z\x01\xc2{\x01\xc2|\x01\xc2}\x01\xc2~\x01\xc2\u007f\x01\u00c1\x80\x01\u00c1\x81\x01\u00c1\x82\x01\u00c1\x83\x01\u00c1\x84\x01\u00c1\x85\x01\u00c1\x86\x01\u00c1\x87\x01\u00c1\x88\x01\u00c1\x89\x01\u00c1\x8a\x01\u00c1\x8b\x01\u00c1\x8c\x01\u00c1\x8d\x01\u00c1\x8e\x01\u00c1\x8f\x01\u00c1\x90\x01\u00c1\x91\x01\u00c1\x92\x01\u00c1\x93\x01\u00c1\x94\x01\u00c1\x95\x01\u00c1\x96\x01\u00c1\x97\x01\u00c1\x98\x01\u00c1\x99\x01\u00c1\x9a\x01\u00c1\x9b\x01\u00c1\x9c\x01\u00c1\x9d\x01\u00c1\x9e\x01\u00c1\x9f\x01\u00c1\xa0\x01\u00c1\xa1\x01\u00c1\xa2\x01\u00c1\xa3\x01\u00c1\xa4\x01\u00c1\xa5\x01\u00c1\xa6\x01\u00c1\xa7\x01\u00c1\xa8\x01\u00c1\xa9\x01\u00c1\xaa\x01\u00c1\xab\x01\u00c1\xac\x01\u00c1\xad\x01\u00c1\xae\x01\u00c1\xaf\x01\u00c1\xb0\x01\u00c1\xb1\x01\u00c1\xb2\x01\u00c1\xb3\x01\u00c1\xb4\x01\u00c1\xb5\x01\u00c1\xb6\x01\u00c1\xb7\x01\u00c1\xb8\x01\u00c1\xb9\x01\u00c1\xba\x01\u00c1\xbb\x01\u00c1\xbc\x01\u00c1\xbd\x01\u00c1\xbe\x01\u00c1\xbf\x01\u00c1\xc0\x01\u00c1\xc1\x01\u00c1\xc2\x01\u00c1\xc3\x01\u00c1\xc4\x01\u00c1\xc5\x01\u00c1\xc6\x01\u00c1\xc7\x01\u00c1\xc8\x01\u00c1\xc9\x01\u00c1\xca\x01\u00c1\xcb\x01\u00c1\xcc\x01\u00c1\xcd\x01\u00c1\xce\x01\u00c1\xcf\x01\u00c1\xd0\x01\u00c1\xd1\x01\u00c1\xd2\x01\u00c1\xd3\x01\u00c1\xd4\x01\u00c1\xd5\x01\u00c1\xd6\x01\u00c1\xd7\x01\u00c1\xd8\x01\u00c1\xd9\x01\u00c1\xda\x01\u00c1\xdb\x01\u00c1\xdc\x01\u00c1\xdd\x01\u00c1\xde\x01\u00c1\xdf\x01\u00c1\xe0\x01\u00c1\xe1\x01\u00c1\xe2\x01\u00c1\xe3\x01\u00c1\xe4\x01\u00c1\xe5\x01\u00c1\xe6\x01\u00c1\xe7\x01\u00c1\xe8\x01\u00c1\xe9\x01\u00c1\xea\x01\u00c1\xeb\x01\u00c1\xec\x01\u00c1\xed\x01\u00c1\xee\x01\u00c1\xef\x01\u00c1\xf0\x01\u00c1\xf1\x01\u00c1\xf2\x01\u00c1\xf3\x01\u00c1\xf4\x01\u00c1\xf5\x01\u00c1\xf6\x01\u00c1\xf7\x01\u00c1\xf8\x01\u00c1\xf9\x01\u00c1\xfa\x01\u00c1\xfb\x01\u00c1\xfc\x01\u00c1\xfd\x01\u00c1\xfe\x01\u00c1\xff\x01\xf6\x94\x0e\x89\xe2\xae\xdb\x1c\xfc\u06d4$\xd4\x1a\x1f!\x8fA2s\x81r\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94\x10A\xaf\xbc\xb3Y\u0568\xdcX\xc1[/\xf5\x13T\xff\x8a!}\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94`\xad\xc0\xf8\x9aA\xaf#|\xe75T\xed\xe1p\xd73\xec\x14\xe0\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94y\x9d2\x9e_X4\x19\x16|\xd7\"\x96$\x85\x92n3\x8fJ\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94|\xf5\xb7\x9b\xfe)\x1ag\xab\x02\xb3\x93\xe4V\xcc\xc4\xc2f\xf7S\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94\x8a\x8e\xaf\xb1\xcfb\xbf\xbe\xb1t\x17i\xda\xe1\xa9\xddG\x99a\x92\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94\x8b\xa1\xf1\tU\x1b\xd42\x800\x12dZ\xc16\xdd\xd6M\xbar\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94\xb0*.\xda\x1b1\u007f\xbd\x16v\x01(\x83k\n\u015bV\x0e\x9d\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x94\xdf\n\x88\xb2\xb6\x8cg7\x13\xa8\xec\x82`\x03go'.5s\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
diff --git a/core/state_prefetcher.go b/core/state_prefetcher.go
index 2b45b2905d..6d96eaef33 100644
--- a/core/state_prefetcher.go
+++ b/core/state_prefetcher.go
@@ -50,17 +50,24 @@ func newStatePrefetcher(config *params.ChainConfig, bc *BlockChain, engine conse
// only goal is to pre-cache transaction signatures and state trie nodes.
func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.IntraBlockState, cfg vm.Config, interrupt *uint32) {
var (
- header = block.Header()
- gaspool = new(GasPool).AddGas(block.GasLimit())
+ header = block.Header()
+ gaspool = new(GasPool).AddGas(block.GasLimit())
+ blockContext = NewEVMBlockContext(header, p.bc, nil)
+ evm = vm.NewEVM(blockContext, vm.TxContext{}, statedb, p.config, cfg)
+ signer = types.MakeSigner(p.config, header.Number)
)
for i, tx := range block.Transactions() {
// If block precaching was interrupted, abort
if interrupt != nil && atomic.LoadUint32(interrupt) == 1 {
return
}
- // Block precaching permitted to continue, execute the transaction
+ // Convert the transaction into an executable message and pre-cache its sender
+ msg, err := tx.AsMessage(signer)
+ if err != nil {
+ return // Also invalid block, bail out
+ }
statedb.Prepare(tx.Hash(), block.Hash(), i)
- if err := precacheTransaction(p.config, p.bc, nil, gaspool, statedb, header, tx, cfg); err != nil {
+ if err := precacheTransaction(msg, p.config, gaspool, statedb, header, evm); err != nil {
return // Ugh, something went horribly wrong, bail out
}
}
@@ -69,18 +76,10 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.IntraBlock
// precacheTransaction attempts to apply a transaction to the given state database
// and uses the input parameters for its environment. The goal is not to execute
// the transaction successfully, rather to warm up touched data slots.
-func precacheTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gaspool *GasPool, statedb vm.IntraBlockState, header *types.Header, tx *types.Transaction, cfg vm.Config) error {
- // Convert the transaction into an executable message and pre-cache its sender
- msg, err := tx.AsMessage(types.MakeSigner(config, header.Number))
- if err != nil {
- return err
- }
- // Create the EVM and execute the transaction
- context := NewEVMBlockContext(header, bc, author)
- txContext := NewEVMTxContext(msg)
- cfg.SkipAnalysis = SkipAnalysis(config, header.Number.Uint64())
- vm := vm.NewEVM(context, txContext, statedb, config, cfg)
-
- _, err = ApplyMessage(vm, msg, gaspool, true /* refunds */, false /* gasBailout */)
+func precacheTransaction(msg types.Message, config *params.ChainConfig, gaspool *GasPool, statedb *state.StateDB, header *types.Header, evm *vm.EVM) error {
+ // Update the evm with the new transaction context.
+ evm.Reset(NewEVMTxContext(msg), statedb)
+ // Add addresses to access list if applicable
+ _, err := ApplyMessage(evm, msg, gaspool, true, false)
return err
}
diff --git a/core/state_processor.go b/core/state_processor.go
index be9a3c52e1..8a93765d65 100644
--- a/core/state_processor.go
+++ b/core/state_processor.go
@@ -210,15 +210,16 @@ func (p *StateProcessor) PostProcess(block *types.Block, tds *state.TrieDbState,
return nil
}
-// ApplyTransaction attempts to apply a transaction to the given state database
+// applyTransaction attempts to apply a transaction to the given state database
// and uses the input parameters for its environment. It returns the receipt
// for the transaction, gas used and an error if the transaction failed,
// indicating the block was invalid.
-func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.IntraBlockState, stateWriter state.StateWriter, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, error) {
+func applyTransaction(msg types.Message, config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, evm *vm.EVM) (*types.Receipt, error) {
msg, err := tx.AsMessage(types.MakeSigner(config, header.Number))
if err != nil {
return nil, err
}
+
ctx := config.WithEIPsFlags(context.Background(), header.Number)
// Create a new context to be used in the EVM environment
context := NewEVMBlockContext(msg, header, bc, author)
@@ -231,20 +232,9 @@ func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *commo
cfg.SkipAnalysis = SkipAnalysis(config, header.Number.Uint64())
vmenv := vm.NewEVM(context, txContext, statedb, config, cfg)
- if config.IsYoloV3(header.Number) {
- statedb.AddAddressToAccessList(msg.From())
- if dst := msg.To(); dst != nil {
- statedb.AddAddressToAccessList(*dst)
- // If it's a create-tx, the destination will be added inside evm.create
- }
- for _, addr := range evm.ActivePrecompiles() {
- statedb.AddAddressToAccessList(addr)
- }
- }
-
// Update the evm with the new transaction context.
evm.Reset(txContext, statedb)
- // Apply the transaction to the current state (included in the env)
+ // If the transaction created a contract, store the creation address in the receipt.
result, err := ApplyMessage(vmenv, msg, gp, true /* refunds */, false /* gasBailout */)
if err != nil {
return nil, err
@@ -256,11 +246,17 @@ func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *commo
*usedGas += result.UsedGas
- // Create a new receipt for the transaction, storing the intermediate root and gas used by the tx
+ // Set the receipt logs and create the bloom filter.
// based on the eip phase, we're passing whether the root touch-delete accounts.
var receipt *types.Receipt
if !cfg.NoReceipts {
- receipt = types.NewReceipt(result.Failed(), *usedGas)
+ // by the tx.
+ receipt = &types.Receipt{Type: tx.Type(), PostState: root, CumulativeGasUsed: *usedGas}
+ if result.Failed() {
+ receipt.Status = types.ReceiptStatusFailed
+ } else {
+ receipt.Status = types.ReceiptStatusSuccessful
+ }
receipt.TxHash = tx.Hash()
receipt.GasUsed = result.UsedGas
// if the transaction created a contract, store the creation address in the receipt.
@@ -270,6 +266,8 @@ func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *commo
// Set the receipt logs and create a bloom for filtering
receipt.Logs = statedb.GetLogs(tx.Hash())
receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
+ receipt.BlockNumber = header.Number
+ receipt.TransactionIndex = uint(statedb.TxIndex())
}
return receipt, err
}
diff --git a/core/state_transition.go b/core/state_transition.go
index 76d247d5e0..e5d60b7731 100644
--- a/core/state_transition.go
+++ b/core/state_transition.go
@@ -70,6 +70,7 @@ type Message interface {
Nonce() uint64
CheckNonce() bool
Data() []byte
+ AccessList() types.AccessList
}
// ExecutionResult includes all output after executing given evm
@@ -108,10 +109,10 @@ func (result *ExecutionResult) Revert() []byte {
}
// IntrinsicGas computes the 'intrinsic gas' for a message with the given data.
-func IntrinsicGas(data []byte, contractCreation, isHomestead bool, isEIP2028 bool) (uint64, error) {
+func IntrinsicGas(data []byte, accessList types.AccessList, isContractCreation bool, isHomestead, isEIP2028 bool) (uint64, error) {
// Set the starting gas for the raw transaction
var gas uint64
- if contractCreation && isHomestead {
+ if isContractCreation && isHomestead {
gas = params.TxGasContractCreation
} else {
gas = params.TxGas
@@ -141,6 +142,10 @@ func IntrinsicGas(data []byte, contractCreation, isHomestead bool, isEIP2028 boo
}
gas += z * params.TxDataZeroGas
}
+ if accessList != nil {
+ gas += uint64(len(accessList)) * params.TxAccessListAddressGas
+ gas += uint64(accessList.StorageKeys()) * params.TxAccessListStorageKeyGas
+ }
return gas, nil
}
@@ -249,7 +254,7 @@ func (st *StateTransition) TransitionDb(refunds bool, gasBailout bool) (*Executi
contractCreation := msg.To() == nil
// Check clauses 4-5, subtract intrinsic gas if everything is correct
- gas, err := IntrinsicGas(st.data, contractCreation, homestead, istanbul)
+ gas, err := IntrinsicGas(st.data, st.msg.AccessList(), contractCreation, homestead, istanbul)
if err != nil {
return nil, err
}
@@ -267,6 +272,7 @@ func (st *StateTransition) TransitionDb(refunds bool, gasBailout bool) (*Executi
return nil, fmt.Errorf("%w: address %v", ErrInsufficientFundsForTransfer, msg.From().Hex())
}
}
+
var (
ret []byte
vmerr error // vm errors do not effect consensus and are therefore not assigned to err
diff --git a/core/tx_pool.go b/core/tx_pool.go
index ab303ac5db..42437b081b 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -224,6 +224,7 @@ type TxPool struct {
mu sync.RWMutex
istanbul bool // Fork indicator whether we are in the istanbul stage.
+ eip2718 bool // Fork indicator whether we are using EIP-2718 type transactions.
pendingNonces *txNoncer // Pending state tracking virtual nonces
currentState *state.IntraBlockState // Current state in the blockchain head
@@ -264,8 +265,8 @@ func NewTxPool(config TxPoolConfig, chainconfig *params.ChainConfig, chaindb eth
pool := &TxPool{
config: config,
chainconfig: chainconfig,
- chaindb: chaindb,
- signer: types.NewEIP155Signer(chainconfig.ChainID),
+ chain: chain,
+ signer: types.LatestSigner(chainconfig),
pending: make(map[common.Address]*txList),
queue: make(map[common.Address]*txList),
beats: make(map[common.Address]time.Time),
@@ -275,6 +276,7 @@ func NewTxPool(config TxPoolConfig, chainconfig *params.ChainConfig, chaindb eth
reqPromoteCh: make(chan *accountSet),
queueTxEventCh: make(chan *types.Transaction),
reorgDoneCh: make(chan chan struct{}),
+ reorgShutdownCh: make(chan struct{}),
gasPrice: new(big.Int).SetUint64(config.PriceLimit),
stopCh: make(chan struct{}),
}
@@ -540,6 +542,10 @@ func (pool *TxPool) local() map[common.Address]types.Transactions {
// validateTx checks whether a transaction is valid according to the consensus
// rules and adheres to some heuristic limits of the local node (price and size).
func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
+ // Accept only legacy transactions until EIP-2718/2930 activates.
+ if !pool.eip2718 && tx.Type() != types.LegacyTxType {
+ return ErrTxTypeNotSupported
+ }
// Reject transactions over defined size to prevent DOS attacks
if uint64(tx.Size()) > txMaxSize {
return ErrOversizedData
@@ -553,7 +559,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
if pool.currentMaxGas < tx.Gas() {
return ErrGasLimit
}
- // Make sure the transaction is signed properly
+ // Make sure the transaction is signed properly.
from, err := types.Sender(pool.signer, tx)
if err != nil {
return ErrInvalidSender
@@ -572,7 +578,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
return ErrInsufficientFunds
}
// Ensure the transaction has more gas than the basic tx fee.
- intrGas, err := IntrinsicGas(tx.Data(), tx.To() == nil, true, pool.istanbul)
+ intrGas, err := IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil, true, pool.istanbul)
if err != nil {
return err
}
@@ -1224,6 +1230,7 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
// Update all fork indicator by next pending block number.
next := new(big.Int).Add(newHead.Number, big.NewInt(1))
pool.istanbul = pool.chainconfig.IsIstanbul(next)
+ pool.eip2718 = pool.chainconfig.IsYoloV3(next)
}
// promoteExecutables moves transactions that have become processable from the
diff --git a/core/types/access_list_tx.go b/core/types/access_list_tx.go
new file mode 100644
index 0000000000..65ee95adf6
--- /dev/null
+++ b/core/types/access_list_tx.go
@@ -0,0 +1,115 @@
+// Copyright 2020 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 (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/common"
+)
+
+//go:generate gencodec -type AccessTuple -out gen_access_tuple.go
+
+// AccessList is an EIP-2930 access list.
+type AccessList []AccessTuple
+
+// AccessTuple is the element type of an access list.
+type AccessTuple struct {
+ Address common.Address `json:"address" gencodec:"required"`
+ StorageKeys []common.Hash `json:"storageKeys" gencodec:"required"`
+}
+
+// StorageKeys returns the total number of storage keys in the access list.
+func (al AccessList) StorageKeys() int {
+ sum := 0
+ for _, tuple := range al {
+ sum += len(tuple.StorageKeys)
+ }
+ return sum
+}
+
+// AccessListTx is the data of EIP-2930 access list transactions.
+type AccessListTx struct {
+ ChainID *big.Int // destination chain ID
+ Nonce uint64 // nonce of sender account
+ GasPrice *big.Int // wei per gas
+ Gas uint64 // gas limit
+ To *common.Address `rlp:"nil"` // nil means contract creation
+ Value *big.Int // wei amount
+ Data []byte // contract invocation input data
+ AccessList AccessList // EIP-2930 access list
+ V, R, S *big.Int // signature values
+}
+
+// copy creates a deep copy of the transaction data and initializes all fields.
+func (tx *AccessListTx) copy() TxData {
+ cpy := &AccessListTx{
+ Nonce: tx.Nonce,
+ To: tx.To, // TODO: copy pointed-to address
+ Data: common.CopyBytes(tx.Data),
+ Gas: tx.Gas,
+ // These are copied below.
+ AccessList: make(AccessList, len(tx.AccessList)),
+ Value: new(big.Int),
+ ChainID: new(big.Int),
+ GasPrice: new(big.Int),
+ V: new(big.Int),
+ R: new(big.Int),
+ S: new(big.Int),
+ }
+ copy(cpy.AccessList, tx.AccessList)
+ if tx.Value != nil {
+ cpy.Value.Set(tx.Value)
+ }
+ if tx.ChainID != nil {
+ cpy.ChainID.Set(tx.ChainID)
+ }
+ if tx.GasPrice != nil {
+ cpy.GasPrice.Set(tx.GasPrice)
+ }
+ if tx.V != nil {
+ cpy.V.Set(tx.V)
+ }
+ if tx.R != nil {
+ cpy.R.Set(tx.R)
+ }
+ if tx.S != nil {
+ cpy.S.Set(tx.S)
+ }
+ return cpy
+}
+
+// accessors for innerTx.
+
+func (tx *AccessListTx) txType() byte { return AccessListTxType }
+func (tx *AccessListTx) chainID() *big.Int { return tx.ChainID }
+func (tx *AccessListTx) protected() bool { return true }
+func (tx *AccessListTx) accessList() AccessList { return tx.AccessList }
+func (tx *AccessListTx) data() []byte { return tx.Data }
+func (tx *AccessListTx) gas() uint64 { return tx.Gas }
+func (tx *AccessListTx) gasPrice() *big.Int { return tx.GasPrice }
+func (tx *AccessListTx) value() *big.Int { return tx.Value }
+func (tx *AccessListTx) nonce() uint64 { return tx.Nonce }
+func (tx *AccessListTx) to() *common.Address { return tx.To }
+
+func (tx *AccessListTx) rawSignatureValues() (v, r, s *big.Int) {
+ return tx.V, tx.R, tx.S
+}
+
+func (tx *AccessListTx) setSignatureValues(chainID, v, r, s *big.Int) {
+ tx.ChainID, tx.V, tx.R, tx.S = chainID, v, r, s
+}
diff --git a/core/types/block.go b/core/types/block.go
index a57180408f..ce45a54266 100644
--- a/core/types/block.go
+++ b/core/types/block.go
@@ -23,7 +23,6 @@ import (
"io"
"math/big"
"reflect"
- "sync"
"sync/atomic"
"time"
@@ -132,22 +131,6 @@ func (h *Header) SanityCheck() error {
return nil
}
-// hasherPool holds LegacyKeccak hashers.
-var hasherPool = sync.Pool{
- New: func() interface{} {
- return sha3.NewLegacyKeccak256()
- },
-}
-
-func rlpHash(x interface{}) (h common.Hash) {
- sha := hasherPool.Get().(crypto.KeccakState)
- defer hasherPool.Put(sha)
- sha.Reset()
- rlp.Encode(sha, x) //nolint:errcheck
- sha.Read(h[:]) //nolint:errcheck
- return h
-}
-
// EmptyBody returns true if there is no additional 'body' to complete the header
// that is: no transactions and no uncles.
func (h *Header) EmptyBody() bool {
diff --git a/core/types/block_test.go b/core/types/block_test.go
index 5ab7fd882b..27921ced2e 100644
--- a/core/types/block_test.go
+++ b/core/types/block_test.go
@@ -60,6 +60,66 @@ func TestBlockEncoding(t *testing.T) {
tx1, _ = tx1.WithSignature(HomesteadSigner{}, common.Hex2Bytes("9bea4c4daac7c7c52e093e6a4c35dbbcf8856f1af7b059ba20253e70848d094f8a8fae537ce25ed8cb5af9adac3f141af69bd515bd2ba031522df09b97dd72b100"))
check("len(Transactions)", len(block.Transactions()), 1)
check("Transactions[0].Hash", block.Transactions()[0].Hash(), tx1.Hash())
+ ourBlockEnc, err := rlp.EncodeToBytes(&block)
+ if err != nil {
+ t.Fatal("encode error: ", err)
+ }
+ if !bytes.Equal(ourBlockEnc, blockEnc) {
+ t.Errorf("encoded block mismatch:\ngot: %x\nwant: %x", ourBlockEnc, blockEnc)
+ }
+}
+
+func TestEIP2718BlockEncoding(t *testing.T) {
+ blockEnc := common.FromHex("f90319f90211a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0ef1552a40b7165c3cd773806b9e0c165b75356e0314bf0706f279c729f51e017a0e6e49996c7ec59f7a23d22b83239a60151512c65613bf84a0d7da336399ebc4aa0cafe75574d59780665a97fbfd11365c7545aa8f1abf4e5e12e8243334ef7286bb901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000083020000820200832fefd882a410845506eb0796636f6f6c65737420626c6f636b206f6e20636861696ea0bd4472abb6659ebe3ee06ee4d7b72a00a9f4d001caca51342001075469aff49888a13a5a8c8f2bb1c4f90101f85f800a82c35094095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba09bea4c4daac7c7c52e093e6a4c35dbbcf8856f1af7b059ba20253e70848d094fa08a8fae537ce25ed8cb5af9adac3f141af69bd515bd2ba031522df09b97dd72b1b89e01f89b01800a8301e24194095e7baea6a6c7c4c2dfeb977efac326af552d878080f838f7940000000000000000000000000000000000000001e1a0000000000000000000000000000000000000000000000000000000000000000001a03dbacc8d0259f2508625e97fdfc57cd85fdd16e5821bc2c10bdd1a52649e8335a0476e10695b183a87b0aa292a7f4b78ef0c3fbe62aa2c42c84e1d9c3da159ef14c0")
+ var block Block
+ if err := rlp.DecodeBytes(blockEnc, &block); err != nil {
+ t.Fatal("decode error: ", err)
+ }
+
+ check := func(f string, got, want interface{}) {
+ if !reflect.DeepEqual(got, want) {
+ t.Errorf("%s mismatch: got %v, want %v", f, got, want)
+ }
+ }
+ check("Difficulty", block.Difficulty(), big.NewInt(131072))
+ check("GasLimit", block.GasLimit(), uint64(3141592))
+ check("GasUsed", block.GasUsed(), uint64(42000))
+ check("Coinbase", block.Coinbase(), common.HexToAddress("8888f1f195afa192cfee860698584c030f4c9db1"))
+ check("MixDigest", block.MixDigest(), common.HexToHash("bd4472abb6659ebe3ee06ee4d7b72a00a9f4d001caca51342001075469aff498"))
+ check("Root", block.Root(), common.HexToHash("ef1552a40b7165c3cd773806b9e0c165b75356e0314bf0706f279c729f51e017"))
+ check("Nonce", block.Nonce(), uint64(0xa13a5a8c8f2bb1c4))
+ check("Time", block.Time(), uint64(1426516743))
+ check("Size", block.Size(), common.StorageSize(len(blockEnc)))
+
+ // Create legacy tx.
+ to := common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87")
+ tx1 := NewTx(&LegacyTx{
+ Nonce: 0,
+ To: &to,
+ Value: big.NewInt(10),
+ Gas: 50000,
+ GasPrice: big.NewInt(10),
+ })
+ sig := common.Hex2Bytes("9bea4c4daac7c7c52e093e6a4c35dbbcf8856f1af7b059ba20253e70848d094f8a8fae537ce25ed8cb5af9adac3f141af69bd515bd2ba031522df09b97dd72b100")
+ tx1, _ = tx1.WithSignature(HomesteadSigner{}, sig)
+
+ // Create ACL tx.
+ addr := common.HexToAddress("0x0000000000000000000000000000000000000001")
+ tx2 := NewTx(&AccessListTx{
+ ChainID: big.NewInt(1),
+ Nonce: 0,
+ To: &to,
+ Gas: 123457,
+ GasPrice: big.NewInt(10),
+ AccessList: AccessList{{Address: addr, StorageKeys: []common.Hash{{0}}}},
+ })
+ sig2 := common.Hex2Bytes("3dbacc8d0259f2508625e97fdfc57cd85fdd16e5821bc2c10bdd1a52649e8335476e10695b183a87b0aa292a7f4b78ef0c3fbe62aa2c42c84e1d9c3da159ef1401")
+ tx2, _ = tx2.WithSignature(NewEIP2930Signer(big.NewInt(1)), sig2)
+
+ check("len(Transactions)", len(block.Transactions()), 2)
+ check("Transactions[0].Hash", block.Transactions()[0].Hash(), tx1.Hash())
+ check("Transactions[1].Hash", block.Transactions()[1].Hash(), tx2.Hash())
+ check("Transactions[1].Type()", block.Transactions()[1].Type(), uint8(AccessListTxType))
ourBlockEnc, err := rlp.EncodeToBytes(&block)
if err != nil {
@@ -118,7 +178,7 @@ func makeBenchBlock() *Block {
key, _ = crypto.GenerateKey()
txs = make([]*Transaction, 70)
receipts = make([]*Receipt, len(txs))
- signer = NewEIP155Signer(params.TestChainConfig.ChainID)
+ signer = LatestSigner(params.TestChainConfig)
uncles = make([]*Header, 3)
)
header := &Header{
diff --git a/core/types/gen_access_tuple.go b/core/types/gen_access_tuple.go
new file mode 100644
index 0000000000..fc48a84cc0
--- /dev/null
+++ b/core/types/gen_access_tuple.go
@@ -0,0 +1,43 @@
+// Code generated by github.com/fjl/gencodec. DO NOT EDIT.
+
+package types
+
+import (
+ "encoding/json"
+ "errors"
+
+ "github.com/ethereum/go-ethereum/common"
+)
+
+// MarshalJSON marshals as JSON.
+func (a AccessTuple) MarshalJSON() ([]byte, error) {
+ type AccessTuple struct {
+ Address common.Address `json:"address" gencodec:"required"`
+ StorageKeys []common.Hash `json:"storageKeys" gencodec:"required"`
+ }
+ var enc AccessTuple
+ enc.Address = a.Address
+ enc.StorageKeys = a.StorageKeys
+ return json.Marshal(&enc)
+}
+
+// UnmarshalJSON unmarshals from JSON.
+func (a *AccessTuple) UnmarshalJSON(input []byte) error {
+ type AccessTuple struct {
+ Address *common.Address `json:"address" gencodec:"required"`
+ StorageKeys []common.Hash `json:"storageKeys" gencodec:"required"`
+ }
+ var dec AccessTuple
+ if err := json.Unmarshal(input, &dec); err != nil {
+ return err
+ }
+ if dec.Address == nil {
+ return errors.New("missing required field 'address' for AccessTuple")
+ }
+ a.Address = *dec.Address
+ if dec.StorageKeys == nil {
+ return errors.New("missing required field 'storageKeys' for AccessTuple")
+ }
+ a.StorageKeys = dec.StorageKeys
+ return nil
+}
diff --git a/core/types/gen_receipt_json.go b/core/types/gen_receipt_json.go
index cd5219c8b1..cff777e25a 100644
--- a/core/types/gen_receipt_json.go
+++ b/core/types/gen_receipt_json.go
@@ -16,6 +16,7 @@ var _ = (*receiptMarshaling)(nil)
// MarshalJSON marshals as JSON.
func (r Receipt) MarshalJSON() ([]byte, error) {
type Receipt struct {
+ Type hexutil.Uint64 `json:"type,omitempty"`
PostState hexutil.Bytes `json:"root"`
Status hexutil.Uint64 `json:"status"`
CumulativeGasUsed hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"`
@@ -29,6 +30,7 @@ func (r Receipt) MarshalJSON() ([]byte, error) {
TransactionIndex hexutil.Uint `json:"transactionIndex"`
}
var enc Receipt
+ enc.Type = hexutil.Uint64(r.Type)
enc.PostState = r.PostState
enc.Status = hexutil.Uint64(r.Status)
enc.CumulativeGasUsed = hexutil.Uint64(r.CumulativeGasUsed)
@@ -46,6 +48,7 @@ func (r Receipt) MarshalJSON() ([]byte, error) {
// UnmarshalJSON unmarshals from JSON.
func (r *Receipt) UnmarshalJSON(input []byte) error {
type Receipt struct {
+ Type *hexutil.Uint64 `json:"type,omitempty"`
PostState *hexutil.Bytes `json:"root"`
Status *hexutil.Uint64 `json:"status"`
CumulativeGasUsed *hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"`
@@ -62,6 +65,9 @@ func (r *Receipt) UnmarshalJSON(input []byte) error {
if err := json.Unmarshal(input, &dec); err != nil {
return err
}
+ if dec.Type != nil {
+ r.Type = uint8(*dec.Type)
+ }
if dec.PostState != nil {
r.PostState = *dec.PostState
}
diff --git a/core/types/gen_tx_json.go b/core/types/gen_tx_json.go
deleted file mode 100644
index 59bcf1b5ec..0000000000
--- a/core/types/gen_tx_json.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// Code generated by github.com/fjl/gencodec. DO NOT EDIT.
-
-package types
-
-import (
- "encoding/json"
- "errors"
- "math/big"
-
- "github.com/ledgerwatch/turbo-geth/common"
- "github.com/ledgerwatch/turbo-geth/common/hexutil"
-)
-
-var _ = (*txdataMarshaling)(nil)
-
-// MarshalJSON marshals as JSON.
-func (t txdata) MarshalJSON() ([]byte, error) {
- type txdata struct {
- AccountNonce hexutil.Uint64 `json:"nonce" gencodec:"required"`
- Price *hexutil.Big `json:"gasPrice" gencodec:"required"`
- GasLimit hexutil.Uint64 `json:"gas" gencodec:"required"`
- Recipient *common.Address `json:"to" rlp:"nil"`
- Amount *hexutil.Big `json:"value" gencodec:"required"`
- Payload hexutil.Bytes `json:"input" gencodec:"required"`
- V *hexutil.Big `json:"v" gencodec:"required"`
- R *hexutil.Big `json:"r" gencodec:"required"`
- S *hexutil.Big `json:"s" gencodec:"required"`
- Hash *common.Hash `json:"hash" rlp:"-"`
- }
- var enc txdata
- enc.AccountNonce = hexutil.Uint64(t.AccountNonce)
- enc.Price = (*hexutil.Big)(t.Price.ToBig())
- enc.GasLimit = hexutil.Uint64(t.GasLimit)
- enc.Recipient = t.Recipient
- enc.Amount = (*hexutil.Big)(t.Amount.ToBig())
- enc.Payload = t.Payload
- enc.V = (*hexutil.Big)(t.V.ToBig())
- enc.R = (*hexutil.Big)(t.R.ToBig())
- enc.S = (*hexutil.Big)(t.S.ToBig())
- enc.Hash = t.Hash
- return json.Marshal(&enc)
-}
-
-// UnmarshalJSON unmarshals from JSON.
-func (t *txdata) UnmarshalJSON(input []byte) error {
- type txdata struct {
- AccountNonce *hexutil.Uint64 `json:"nonce" gencodec:"required"`
- Price *hexutil.Big `json:"gasPrice" gencodec:"required"`
- GasLimit *hexutil.Uint64 `json:"gas" gencodec:"required"`
- Recipient *common.Address `json:"to" rlp:"nil"`
- Amount *hexutil.Big `json:"value" gencodec:"required"`
- Payload *hexutil.Bytes `json:"input" gencodec:"required"`
- V *hexutil.Big `json:"v" gencodec:"required"`
- R *hexutil.Big `json:"r" gencodec:"required"`
- S *hexutil.Big `json:"s" gencodec:"required"`
- Hash *common.Hash `json:"hash" rlp:"-"`
- }
- var dec txdata
- if err := json.Unmarshal(input, &dec); err != nil {
- return err
- }
- if dec.AccountNonce == nil {
- return errors.New("missing required field 'nonce' for txdata")
- }
- t.AccountNonce = uint64(*dec.AccountNonce)
- if dec.Price == nil {
- return errors.New("missing required field 'gasPrice' for txdata")
- }
- t.Price.SetFromBig((*big.Int)(dec.Price))
- if dec.GasLimit == nil {
- return errors.New("missing required field 'gas' for txdata")
- }
- t.GasLimit = uint64(*dec.GasLimit)
- if dec.Recipient != nil {
- t.Recipient = dec.Recipient
- }
- if dec.Amount == nil {
- return errors.New("missing required field 'value' for txdata")
- }
- t.Amount.SetFromBig((*big.Int)(dec.Amount))
- if dec.Payload == nil {
- return errors.New("missing required field 'input' for txdata")
- }
- t.Payload = *dec.Payload
- if dec.V == nil {
- return errors.New("missing required field 'v' for txdata")
- }
- t.V.SetFromBig((*big.Int)(dec.V))
- if dec.R == nil {
- return errors.New("missing required field 'r' for txdata")
- }
- t.R.SetFromBig((*big.Int)(dec.R))
- if dec.S == nil {
- return errors.New("missing required field 's' for txdata")
- }
- t.S.SetFromBig((*big.Int)(dec.S))
- if dec.Hash != nil {
- t.Hash = dec.Hash
- }
- return nil
-}
diff --git a/core/types/derive_sha.go b/core/types/hashing.go
similarity index 100%
rename from core/types/derive_sha.go
rename to core/types/hashing.go
diff --git a/core/types/hashing_test.go b/core/types/hashing_test.go
new file mode 100644
index 0000000000..4240ec60e5
--- /dev/null
+++ b/core/types/hashing_test.go
@@ -0,0 +1,115 @@
+package types
+
+import (
+ "bytes"
+ "fmt"
+ "testing"
+
+ "github.com/holiman/uint256"
+
+ "github.com/ledgerwatch/turbo-geth/common"
+ "github.com/ledgerwatch/turbo-geth/rlp"
+ "github.com/ledgerwatch/turbo-geth/turbo/trie"
+)
+
+func genTransactions(n uint64) Transactions {
+ txs := Transactions{}
+
+ for i := uint64(0); i < n; i++ {
+ tx := NewTransaction(i, common.Address{}, uint256.NewInt().SetUint64(1000+i), 10+i, uint256.NewInt().SetUint64(1000+i), []byte(fmt.Sprintf("hello%d", i)))
+ txs = append(txs, tx)
+ }
+
+ return txs
+}
+
+func TestEncodeUint(t *testing.T) {
+ for i := 0; i < 64000; i++ {
+ bbOld := bytes.NewBuffer(make([]byte, 10))
+ bbNew := bytes.NewBuffer(make([]byte, 10))
+ bbOld.Reset()
+ bbNew.Reset()
+ _ = rlp.Encode(bbOld, uint(i))
+
+ bbNew.Reset()
+ encodeUint(uint(i), bbNew)
+
+ if !bytes.Equal(bbOld.Bytes(), bbNew.Bytes()) {
+ t.Errorf("unexpected byte sequence. got: %x (expected %x)", bbNew.Bytes(), bbOld.Bytes())
+ }
+ }
+}
+
+func TestDeriveSha(t *testing.T) {
+ tests := []DerivableList{
+ Transactions{},
+ genTransactions(1),
+ genTransactions(2),
+ genTransactions(4),
+ genTransactions(10),
+ genTransactions(100),
+ genTransactions(1000),
+ genTransactions(10000),
+ genTransactions(100000),
+ }
+
+ for _, test := range tests {
+ checkDeriveSha(t, test)
+ }
+}
+
+func checkDeriveSha(t *testing.T, list DerivableList) {
+ legacySha := legacyDeriveSha(list)
+ deriveSha := DeriveSha(list)
+ if !hashesEqual(legacySha, deriveSha) {
+ t.Errorf("unexpected hash: %v (expected: %v)\n", deriveSha.Hex(), legacySha.Hex())
+
+ }
+}
+
+func hashesEqual(h1, h2 common.Hash) bool {
+ if len(h1) != len(h2) {
+ return false
+ }
+ return h1.Hex() == h2.Hex()
+}
+
+func legacyDeriveSha(list DerivableList) common.Hash {
+ keybuf := new(bytes.Buffer)
+ trie := trie.NewTestRLPTrie(common.Hash{})
+ for i := 0; i < list.Len(); i++ {
+ keybuf.Reset()
+ _ = rlp.Encode(keybuf, uint(i))
+ trie.Update(keybuf.Bytes(), list.GetRlp(i))
+ }
+ return trie.Hash()
+}
+
+var (
+ smallTxList = genTransactions(100)
+ largeTxList = genTransactions(100000)
+)
+
+func BenchmarkLegacySmallList(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ legacyDeriveSha(smallTxList)
+ }
+}
+
+func BenchmarkCurrentSmallList(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ DeriveSha(smallTxList)
+ }
+}
+
+func BenchmarkLegacyLargeList(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ legacyDeriveSha(largeTxList)
+ }
+}
+
+func BenchmarkCurrentLargeList(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ DeriveSha(largeTxList)
+ }
+}
diff --git a/core/types/legacy_tx.go b/core/types/legacy_tx.go
new file mode 100644
index 0000000000..41ad44f379
--- /dev/null
+++ b/core/types/legacy_tx.go
@@ -0,0 +1,111 @@
+// Copyright 2020 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 (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/common"
+)
+
+// LegacyTx is the transaction data of regular Ethereum transactions.
+type LegacyTx struct {
+ Nonce uint64 // nonce of sender account
+ GasPrice *big.Int // wei per gas
+ Gas uint64 // gas limit
+ To *common.Address `rlp:"nil"` // nil means contract creation
+ Value *big.Int // wei amount
+ Data []byte // contract invocation input data
+ V, R, S *big.Int // signature values
+}
+
+// NewTransaction creates an unsigned legacy transaction.
+// Deprecated: use NewTx instead.
+func NewTransaction(nonce uint64, to common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *Transaction {
+ return NewTx(&LegacyTx{
+ Nonce: nonce,
+ To: &to,
+ Value: amount,
+ Gas: gasLimit,
+ GasPrice: gasPrice,
+ Data: data,
+ })
+}
+
+// NewContractCreation creates an unsigned legacy transaction.
+// Deprecated: use NewTx instead.
+func NewContractCreation(nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *Transaction {
+ return NewTx(&LegacyTx{
+ Nonce: nonce,
+ Value: amount,
+ Gas: gasLimit,
+ GasPrice: gasPrice,
+ Data: data,
+ })
+}
+
+// copy creates a deep copy of the transaction data and initializes all fields.
+func (tx *LegacyTx) copy() TxData {
+ cpy := &LegacyTx{
+ Nonce: tx.Nonce,
+ To: tx.To, // TODO: copy pointed-to address
+ Data: common.CopyBytes(tx.Data),
+ Gas: tx.Gas,
+ // These are initialized below.
+ Value: new(big.Int),
+ GasPrice: new(big.Int),
+ V: new(big.Int),
+ R: new(big.Int),
+ S: new(big.Int),
+ }
+ if tx.Value != nil {
+ cpy.Value.Set(tx.Value)
+ }
+ if tx.GasPrice != nil {
+ cpy.GasPrice.Set(tx.GasPrice)
+ }
+ if tx.V != nil {
+ cpy.V.Set(tx.V)
+ }
+ if tx.R != nil {
+ cpy.R.Set(tx.R)
+ }
+ if tx.S != nil {
+ cpy.S.Set(tx.S)
+ }
+ return cpy
+}
+
+// accessors for innerTx.
+
+func (tx *LegacyTx) txType() byte { return LegacyTxType }
+func (tx *LegacyTx) chainID() *big.Int { return deriveChainId(tx.V) }
+func (tx *LegacyTx) accessList() AccessList { return nil }
+func (tx *LegacyTx) data() []byte { return tx.Data }
+func (tx *LegacyTx) gas() uint64 { return tx.Gas }
+func (tx *LegacyTx) gasPrice() *big.Int { return tx.GasPrice }
+func (tx *LegacyTx) value() *big.Int { return tx.Value }
+func (tx *LegacyTx) nonce() uint64 { return tx.Nonce }
+func (tx *LegacyTx) to() *common.Address { return tx.To }
+
+func (tx *LegacyTx) rawSignatureValues() (v, r, s *big.Int) {
+ return tx.V, tx.R, tx.S
+}
+
+func (tx *LegacyTx) setSignatureValues(chainID, v, r, s *big.Int) {
+ tx.V, tx.R, tx.S = v, r, s
+}
diff --git a/core/types/receipt.go b/core/types/receipt.go
index 5eee92ab84..59bcaf1998 100644
--- a/core/types/receipt.go
+++ b/core/types/receipt.go
@@ -38,6 +38,8 @@ var (
receiptStatusSuccessfulRLP = []byte{0x01}
)
+var errEmptyTypedReceipt = errors.New("empty typed receipt bytes")
+
const (
// ReceiptStatusFailed is the status code of a transaction if execution failed.
ReceiptStatusFailed = uint64(0)
@@ -50,6 +52,7 @@ const (
// DESCRIBED: docs/programmers_guide/guide.md#organising-ethereum-state-into-a-merkle-tree
type Receipt struct {
// Consensus fields: These fields are defined by the Yellow Paper
+ Type uint8 `json:"type,omitempty"`
PostState []byte `json:"root" codec:"1"`
Status uint64 `json:"status" codec:"2"`
CumulativeGasUsed uint64 `json:"cumulativeGasUsed" gencodec:"required" codec:"3"`
@@ -70,6 +73,7 @@ type Receipt struct {
}
type receiptMarshaling struct {
+ Type hexutil.Uint64
PostState hexutil.Bytes
Status hexutil.Uint64
CumulativeGasUsed hexutil.Uint64
@@ -115,8 +119,13 @@ type v3StoredReceiptRLP struct {
}
// NewReceipt creates a barebone transaction receipt, copying the init fields.
+// Deprecated: create receipts using a struct literal instead.
func NewReceipt(failed bool, cumulativeGasUsed uint64) *Receipt {
- r := &Receipt{CumulativeGasUsed: cumulativeGasUsed}
+ r := &Receipt{
+ Type: LegacyTxType,
+ PostState: common.CopyBytes(root),
+ CumulativeGasUsed: cumulativeGasUsed,
+ }
if failed {
r.Status = ReceiptStatusFailed
} else {
@@ -128,21 +137,65 @@ func NewReceipt(failed bool, cumulativeGasUsed uint64) *Receipt {
// EncodeRLP implements rlp.Encoder, and flattens the consensus fields of a receipt
// into an RLP stream. If no post state is present, byzantium fork is assumed.
func (r *Receipt) EncodeRLP(w io.Writer) error {
- return rlp.Encode(w, &receiptRLP{r.statusEncoding(), r.CumulativeGasUsed, r.Bloom, r.Logs})
+ data := &receiptRLP{r.statusEncoding(), r.CumulativeGasUsed, r.Bloom, r.Logs}
+ if r.Type == LegacyTxType {
+ return rlp.Encode(w, data)
+ }
+ // It's an EIP-2718 typed TX receipt.
+ if r.Type != AccessListTxType {
+ return ErrTxTypeNotSupported
+ }
+ buf := encodeBufferPool.Get().(*bytes.Buffer)
+ defer encodeBufferPool.Put(buf)
+ buf.Reset()
+ buf.WriteByte(r.Type)
+ if err := rlp.Encode(buf, data); err != nil {
+ return err
+ }
+ return rlp.Encode(w, buf.Bytes())
}
// DecodeRLP implements rlp.Decoder, and loads the consensus fields of a receipt
// from an RLP stream.
func (r *Receipt) DecodeRLP(s *rlp.Stream) error {
- var dec receiptRLP
- if err := s.Decode(&dec); err != nil {
- return err
- }
- if err := r.setStatus(dec.PostStateOrStatus); err != nil {
+ kind, _, err := s.Kind()
+ switch {
+ case err != nil:
return err
+ case kind == rlp.List:
+ // It's a legacy receipt.
+ var dec receiptRLP
+ if err := s.Decode(&dec); err != nil {
+ return err
+ }
+ r.Type = LegacyTxType
+ return r.setFromRLP(dec)
+ case kind == rlp.String:
+ // It's an EIP-2718 typed tx receipt.
+ b, err := s.Bytes()
+ if err != nil {
+ return err
+ }
+ if len(b) == 0 {
+ return errEmptyTypedReceipt
+ }
+ r.Type = b[0]
+ if r.Type == AccessListTxType {
+ var dec receiptRLP
+ if err := rlp.DecodeBytes(b[1:], &dec); err != nil {
+ return err
+ }
+ return r.setFromRLP(dec)
+ }
+ return ErrTxTypeNotSupported
+ default:
+ return rlp.ErrExpectedList
}
- r.CumulativeGasUsed, r.Bloom, r.Logs = dec.CumulativeGasUsed, dec.Bloom, dec.Logs
- return nil
+}
+
+func (r *Receipt) setFromRLP(data receiptRLP) error {
+ r.CumulativeGasUsed, r.Bloom, r.Logs = data.CumulativeGasUsed, data.Bloom, data.Logs
+ return r.setStatus(data.PostStateOrStatus)
}
func (r *Receipt) setStatus(postStateOrStatus []byte) error {
@@ -173,7 +226,6 @@ func (r *Receipt) statusEncoding() []byte {
// to approximate and limit the memory consumption of various caches.
func (r *Receipt) Size() common.StorageSize {
size := common.StorageSize(unsafe.Sizeof(*r)) + common.StorageSize(len(r.PostState))
-
size += common.StorageSize(len(r.Logs)) * common.StorageSize(unsafe.Sizeof(Log{}))
for _, log := range r.Logs {
size += common.StorageSize(len(log.Topics)*common.HashLength + len(log.Data))
@@ -278,24 +330,34 @@ func decodeV3StoredReceiptRLP(r *ReceiptForStorage, blob []byte) error {
return nil
}
-// Receipts is a wrapper around a Receipt array to implement DerivableList.
+// Receipts implements DerivableList for receipts.
type Receipts []*Receipt
// Len returns the number of receipts in this list.
-func (r Receipts) Len() int { return len(r) }
-
-// GetRlp returns the RLP encoding of one receipt from the list.
-func (r Receipts) GetRlp(i int) []byte {
- bytes, err := rlp.EncodeToBytes(r[i])
- if err != nil {
- panic(err)
+func (rs Receipts) Len() int { return len(rs) }
+
+// EncodeIndex encodes the i'th receipt to w.
+func (rs Receipts) EncodeIndex(i int, w *bytes.Buffer) {
+ r := rs[i]
+ data := &receiptRLP{r.statusEncoding(), r.CumulativeGasUsed, r.Bloom, r.Logs}
+ switch r.Type {
+ case LegacyTxType:
+ rlp.Encode(w, data)
+ case AccessListTxType:
+ w.WriteByte(AccessListTxType)
+ rlp.Encode(w, data)
+ default:
+ // For unsupported types, write nothing. Since this is for
+ // DeriveSha, the error will be caught matching the derived hash
+ // to the block.
}
- return bytes
}
// DeriveFields fills the receipts with their computed fields based on consensus
// data and contextual infos like containing block and transactions.
func (r Receipts) DeriveFields(hash common.Hash, number uint64, txs Transactions, senders []common.Address) error {
+ signer := MakeSigner(config, new(big.Int).SetUint64(number))
+
logIndex := uint(0) // logIdx is unique within the block and starts from 0
if len(txs) != len(r) {
return errors.New("transaction and receipt count mismatch")
@@ -304,7 +366,8 @@ func (r Receipts) DeriveFields(hash common.Hash, number uint64, txs Transactions
return errors.New("transaction and senders count mismatch")
}
for i := 0; i < len(r); i++ {
- // The transaction hash can be retrieved from the transaction itself
+ // The transaction type and hash can be retrieved from the transaction itself
+ r[i].Type = txs[i].Type()
r[i].TxHash = txs[i].Hash()
// block location fields
diff --git a/core/types/receipt_test.go b/core/types/receipt_test.go
index 2ccf3af3e5..3762e99ec6 100644
--- a/core/types/receipt_test.go
+++ b/core/types/receipt_test.go
@@ -30,6 +30,15 @@ import (
"github.com/ledgerwatch/turbo-geth/rlp"
)
+func TestDecodeEmptyTypedReceipt(t *testing.T) {
+ input := []byte{0x80}
+ var r Receipt
+ err := rlp.DecodeBytes(input, &r)
+ if err != errEmptyTypedReceipt {
+ t.Fatal("wrong error:", err)
+ }
+}
+
func TestLegacyReceiptDecoding(t *testing.T) {
tests := []struct {
name string
@@ -118,9 +127,29 @@ func encodeAsStoredReceiptRLP(want *Receipt) ([]byte, error) {
// Tests that receipt data can be correctly derived from the contextual infos
func TestDeriveFields(t *testing.T) {
// Create a few transactions to have receipts for
+ to2 := common.HexToAddress("0x2")
+ to3 := common.HexToAddress("0x3")
txs := Transactions{
- NewContractCreation(1, u256.Num1, 1, u256.Num1, nil),
- NewTransaction(2, common.HexToAddress("0x2"), u256.Num2, 2, u256.Num2, nil),
+ NewTx(&LegacyTx{
+ Nonce: 1,
+ Value: big.NewInt(1),
+ Gas: 1,
+ GasPrice: big.NewInt(1),
+ }),
+ NewTx(&LegacyTx{
+ To: &to2,
+ Nonce: 2,
+ Value: big.NewInt(2),
+ Gas: 2,
+ GasPrice: big.NewInt(2),
+ }),
+ NewTx(&AccessListTx{
+ To: &to3,
+ Nonce: 3,
+ Value: big.NewInt(3),
+ Gas: 3,
+ GasPrice: big.NewInt(3),
+ }),
}
// Create the corresponding receipts
receipts := Receipts{
@@ -146,6 +175,18 @@ func TestDeriveFields(t *testing.T) {
ContractAddress: common.BytesToAddress([]byte{0x02, 0x22, 0x22}),
GasUsed: 2,
},
+ &Receipt{
+ Type: AccessListTxType,
+ PostState: common.Hash{3}.Bytes(),
+ CumulativeGasUsed: 6,
+ Logs: []*Log{
+ {Address: common.BytesToAddress([]byte{0x33})},
+ {Address: common.BytesToAddress([]byte{0x03, 0x33})},
+ },
+ TxHash: txs[2].Hash(),
+ ContractAddress: common.BytesToAddress([]byte{0x03, 0x33, 0x33}),
+ GasUsed: 3,
+ },
}
// Clear all the computed fields and re-derive them
number := big.NewInt(1)
@@ -160,6 +201,9 @@ func TestDeriveFields(t *testing.T) {
logIndex := uint(0)
for i := range receipts {
+ if receipts[i].Type != txs[i].Type() {
+ t.Errorf("receipts[%d].Type = %d, want %d", i, receipts[i].Type, txs[i].Type())
+ }
if receipts[i].TxHash != txs[i].Hash() {
t.Errorf("receipts[%d].TxHash = %s, want %s", i, receipts[i].TxHash.String(), txs[i].Hash().String())
}
@@ -207,6 +251,34 @@ func TestDeriveFields(t *testing.T) {
}
}
+// TestTypedReceiptEncodingDecoding reproduces a flaw that existed in the receipt
+// rlp decoder, which failed due to a shadowing error.
+func TestTypedReceiptEncodingDecoding(t *testing.T) {
+ var payload = common.FromHex("f9043eb9010c01f90108018262d4b9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0b9010c01f901080182cd14b9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0b9010d01f901090183013754b9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0b9010d01f90109018301a194b9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0")
+ check := func(bundle []*Receipt) {
+ t.Helper()
+ for i, receipt := range bundle {
+ if got, want := receipt.Type, uint8(1); got != want {
+ t.Fatalf("bundle %d: got %x, want %x", i, got, want)
+ }
+ }
+ }
+ {
+ var bundle []*Receipt
+ rlp.DecodeBytes(payload, &bundle)
+ check(bundle)
+ }
+ {
+ var bundle []*Receipt
+ r := bytes.NewReader(payload)
+ s := rlp.NewStream(r, uint64(len(payload)))
+ if err := s.Decode(&bundle); err != nil {
+ t.Fatal(err)
+ }
+ check(bundle)
+ }
+}
+
func clearComputedFieldsOnReceipts(t *testing.T, receipts Receipts) {
t.Helper()
diff --git a/core/types/transaction.go b/core/types/transaction.go
index e1a25403e4..c6b6fd48ca 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -17,6 +17,7 @@
package types
import (
+ "bytes"
"container/heap"
"errors"
"io"
@@ -25,22 +26,28 @@ import (
"time"
"github.com/holiman/uint256"
-
- "github.com/ledgerwatch/turbo-geth/common"
- "github.com/ledgerwatch/turbo-geth/common/hexutil"
- "github.com/ledgerwatch/turbo-geth/crypto"
- "github.com/ledgerwatch/turbo-geth/rlp"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/rlp"
)
-// go:generate gencodec -type txdata -field-override txdataMarshaling -out gen_tx_json.go
-
var (
- ErrInvalidSig = errors.New("invalid transaction v, r, s values")
+ ErrInvalidSig = errors.New("invalid transaction v, r, s values")
+ ErrUnexpectedProtection = errors.New("transaction type does not supported EIP-155 protected signatures")
+ ErrInvalidTxType = errors.New("transaction type not valid in this context")
+ ErrTxTypeNotSupported = errors.New("transaction type not supported")
+ errEmptyTypedTx = errors.New("empty typed transaction bytes")
+)
+
+// Transaction types.
+const (
+ LegacyTxType = iota
+ AccessListTxType
)
+// Transaction is an Ethereum transaction.
type Transaction struct {
- data txdata // Consensus contents of a transaction
- time time.Time // Time first seen locally (spam avoidance)
+ inner TxData // Consensus contents of a transaction
+ time time.Time // Time first seen locally (spam avoidance)
// caches
hash atomic.Value
@@ -48,138 +55,245 @@ type Transaction struct {
from atomic.Value
}
-type txdata struct {
- AccountNonce uint64 `json:"nonce" gencodec:"required"`
- Price uint256.Int `json:"gasPrice" gencodec:"required"`
- GasLimit uint64 `json:"gas" gencodec:"required"`
- Recipient *common.Address `json:"to" rlp:"nil"` // nil means contract creation
- Amount uint256.Int `json:"value" gencodec:"required"`
- Payload []byte `json:"input" gencodec:"required"`
+// NewTx creates a new transaction.
+func NewTx(inner TxData) *Transaction {
+ tx := new(Transaction)
+ tx.setDecoded(inner.copy(), 0)
+ return tx
+}
+
+// TxData is the underlying data of a transaction.
+//
+// This is implemented by LegacyTx and AccessListTx.
+type TxData interface {
+ txType() byte // returns the type ID
+ copy() TxData // creates a deep copy and initializes all fields
- // Signature values
- V uint256.Int `json:"v" gencodec:"required"`
- R uint256.Int `json:"r" gencodec:"required"`
- S uint256.Int `json:"s" gencodec:"required"`
+ chainID() *big.Int
+ accessList() AccessList
+ data() []byte
+ gas() uint64
+ gasPrice() *big.Int
+ value() *big.Int
+ nonce() uint64
+ to() *common.Address
- // This is only used when marshaling to JSON.
- Hash *common.Hash `json:"hash" rlp:"-"`
+ rawSignatureValues() (v, r, s *big.Int)
+ setSignatureValues(chainID, v, r, s *big.Int)
}
-type txdataMarshaling struct {
- AccountNonce hexutil.Uint64
- Price *hexutil.Big
- GasLimit hexutil.Uint64
- Amount *hexutil.Big
- Payload hexutil.Bytes
- V *hexutil.Big
- R *hexutil.Big
- S *hexutil.Big
+// EncodeRLP implements rlp.Encoder
+func (tx *Transaction) EncodeRLP(w io.Writer) error {
+ if tx.Type() == LegacyTxType {
+ return rlp.Encode(w, tx.inner)
+ }
+ // It's an EIP-2718 typed TX envelope.
+ buf := encodeBufferPool.Get().(*bytes.Buffer)
+ defer encodeBufferPool.Put(buf)
+ buf.Reset()
+ if err := tx.encodeTyped(buf); err != nil {
+ return err
+ }
+ return rlp.Encode(w, buf.Bytes())
}
-func NewTransaction(nonce uint64, to common.Address, amount *uint256.Int, gasLimit uint64, gasPrice *uint256.Int, data []byte) *Transaction {
- return newTransaction(nonce, &to, amount, gasLimit, gasPrice, data)
+// encodeTyped writes the canonical encoding of a typed transaction to w.
+func (tx *Transaction) encodeTyped(w *bytes.Buffer) error {
+ w.WriteByte(tx.Type())
+ return rlp.Encode(w, tx.inner)
}
-func NewContractCreation(nonce uint64, amount *uint256.Int, gasLimit uint64, gasPrice *uint256.Int, data []byte) *Transaction {
- return newTransaction(nonce, nil, amount, gasLimit, gasPrice, data)
+// MarshalBinary returns the canonical encoding of the transaction.
+// For legacy transactions, it returns the RLP encoding. For EIP-2718 typed
+// transactions, it returns the type and payload.
+func (tx *Transaction) MarshalBinary() ([]byte, error) {
+ if tx.Type() == LegacyTxType {
+ return rlp.EncodeToBytes(tx.inner)
+ }
+ var buf bytes.Buffer
+ err := tx.encodeTyped(&buf)
+ return buf.Bytes(), err
}
-func newTransaction(nonce uint64, to *common.Address, amount *uint256.Int, gasLimit uint64, gasPrice *uint256.Int, data []byte) *Transaction {
- if len(data) > 0 {
- data = common.CopyBytes(data)
+// DecodeRLP implements rlp.Decoder
+func (tx *Transaction) DecodeRLP(s *rlp.Stream) error {
+ kind, size, err := s.Kind()
+ switch {
+ case err != nil:
+ return err
+ case kind == rlp.List:
+ // It's a legacy transaction.
+ var inner LegacyTx
+ err := s.Decode(&inner)
+ if err == nil {
+ tx.setDecoded(&inner, int(rlp.ListSize(size)))
+ }
+ return err
+ case kind == rlp.String:
+ // It's an EIP-2718 typed TX envelope.
+ var b []byte
+ if b, err = s.Bytes(); err != nil {
+ return err
+ }
+ inner, err := tx.decodeTyped(b)
+ if err == nil {
+ tx.setDecoded(inner, len(b))
+ }
+ return err
+ default:
+ return rlp.ErrExpectedList
}
- d := txdata{
- AccountNonce: nonce,
- Recipient: to,
- Payload: data,
- GasLimit: gasLimit,
+}
+
+// UnmarshalBinary decodes the canonical encoding of transactions.
+// It supports legacy RLP transactions and EIP2718 typed transactions.
+func (tx *Transaction) UnmarshalBinary(b []byte) error {
+ if len(b) > 0 && b[0] > 0x7f {
+ // It's a legacy transaction.
+ var data LegacyTx
+ err := rlp.DecodeBytes(b, &data)
+ if err != nil {
+ return err
+ }
+ tx.setDecoded(&data, len(b))
+ return nil
}
- if amount != nil {
- d.Amount.Set(amount)
+ // It's an EIP2718 typed transaction envelope.
+ inner, err := tx.decodeTyped(b)
+ if err != nil {
+ return err
}
- if gasPrice != nil {
- d.Price.Set(gasPrice)
+ tx.setDecoded(inner, len(b))
+ return nil
+}
+
+// decodeTyped decodes a typed transaction from the canonical format.
+func (tx *Transaction) decodeTyped(b []byte) (TxData, error) {
+ if len(b) == 0 {
+ return nil, errEmptyTypedTx
}
- return &Transaction{
- data: d,
- time: time.Now(),
+ switch b[0] {
+ case AccessListTxType:
+ var inner AccessListTx
+ err := rlp.DecodeBytes(b[1:], &inner)
+ return &inner, err
+ default:
+ return nil, ErrTxTypeNotSupported
}
}
-// ChainID returns which chain id this transaction was signed for (if at all)
-func (tx *Transaction) ChainID() *uint256.Int {
- return deriveChainID(&tx.data.V)
+// setDecoded sets the inner transaction and size after decoding.
+func (tx *Transaction) setDecoded(inner TxData, size int) {
+ tx.inner = inner
+ tx.time = time.Now()
+ if size > 0 {
+ tx.size.Store(common.StorageSize(size))
+ }
}
-// Protected returns whether the transaction is protected from replay protection.
-func (tx *Transaction) Protected() bool {
- return isProtectedV(&tx.data.V)
+func sanityCheckSignature(v *big.Int, r *big.Int, s *big.Int, maybeProtected bool) error {
+ if isProtectedV(v) && !maybeProtected {
+ return ErrUnexpectedProtection
+ }
+
+ var plainV byte
+ if isProtectedV(v) {
+ chainID := deriveChainId(v).Uint64()
+ plainV = byte(v.Uint64() - 35 - 2*chainID)
+ } else if maybeProtected {
+ // Only EIP-155 signatures can be optionally protected. Since
+ // we determined this v value is not protected, it must be a
+ // raw 27 or 28.
+ plainV = byte(v.Uint64() - 27)
+ } else {
+ // If the signature is not optionally protected, we assume it
+ // must already be equal to the recovery id.
+ plainV = byte(v.Uint64())
+ }
+ if !crypto.ValidateSignatureValues(plainV, r, s, false) {
+ return ErrInvalidSig
+ }
+
+ return nil
}
-func isProtectedV(V *uint256.Int) bool {
- v, overflow := V.Uint64WithOverflow()
- if !overflow {
- return v != 27 && v != 28
+func isProtectedV(V *big.Int) bool {
+ if V.BitLen() <= 8 {
+ v := V.Uint64()
+ return v != 27 && v != 28 && v != 1 && v != 0
}
// anything not 27 or 28 is considered protected
return true
}
-// EncodeRLP implements rlp.Encoder
-func (tx *Transaction) EncodeRLP(w io.Writer) error {
- return rlp.Encode(w, &tx.data)
+// Protected says whether the transaction is replay-protected.
+func (tx *Transaction) Protected() bool {
+ switch tx := tx.inner.(type) {
+ case *LegacyTx:
+ return tx.V != nil && isProtectedV(tx.V)
+ default:
+ return true
+ }
}
-// DecodeRLP implements rlp.Decoder
-func (tx *Transaction) DecodeRLP(s *rlp.Stream) error {
- _, size, _ := s.Kind()
- err := s.Decode(&tx.data)
- if err == nil {
- tx.size.Store(common.StorageSize(rlp.ListSize(size)))
- tx.time = time.Now()
- }
- return err
+// Type returns the transaction type.
+func (tx *Transaction) Type() uint8 {
+ return tx.inner.txType()
}
-// MarshalJSON encodes the web3 RPC transaction format.
-func (tx *Transaction) MarshalJSON() ([]byte, error) {
- hash := tx.Hash()
- data := tx.data
- data.Hash = &hash
- return data.MarshalJSON()
+// ChainId returns the EIP155 chain ID of the transaction. The return value will always be
+// non-nil. For legacy transactions which are not replay-protected, the return value is
+// zero.
+func (tx *Transaction) ChainId() *big.Int {
+ return tx.inner.chainID()
}
-// UnmarshalJSON decodes the web3 RPC transaction format.
-func (tx *Transaction) UnmarshalJSON(input []byte) error {
- var dec txdata
- if err := dec.UnmarshalJSON(input); err != nil {
- return err
- }
- withSignature := dec.V.Sign() != 0 || dec.R.Sign() != 0 || dec.S.Sign() != 0
- if withSignature {
- var V byte
- if isProtectedV(&dec.V) {
- chainID := deriveChainID(&dec.V).Uint64()
- V = byte(dec.V.Uint64() - 35 - 2*chainID)
- } else {
- V = byte(dec.V.Uint64() - 27)
- }
- if !crypto.ValidateSignatureValues(V, &dec.R, &dec.S, false) {
- return ErrInvalidSig
- }
- }
- *tx = Transaction{
- data: dec,
- time: time.Now(),
+// Data returns the input data of the transaction.
+func (tx *Transaction) Data() []byte { return tx.inner.data() }
+
+// AccessList returns the access list of the transaction.
+func (tx *Transaction) AccessList() AccessList { return tx.inner.accessList() }
+
+// Gas returns the gas limit of the transaction.
+func (tx *Transaction) Gas() uint64 { return tx.inner.gas() }
+
+// GasPrice returns the gas price of the transaction.
+func (tx *Transaction) GasPrice() *big.Int { return new(big.Int).Set(tx.inner.gasPrice()) }
+
+// Value returns the ether amount of the transaction.
+func (tx *Transaction) Value() *big.Int { return new(big.Int).Set(tx.inner.value()) }
+
+// Nonce returns the sender account nonce of the transaction.
+func (tx *Transaction) Nonce() uint64 { return tx.inner.nonce() }
+
+// To returns the recipient address of the transaction.
+// For contract-creation transactions, To returns nil.
+func (tx *Transaction) To() *common.Address {
+ // Copy the pointed-to address.
+ ito := tx.inner.to()
+ if ito == nil {
+ return nil
}
- return nil
+ cpy := *ito
+ return &cpy
+}
+
+// Cost returns gas * gasPrice + value.
+func (tx *Transaction) Cost() *big.Int {
+ total := new(big.Int).Mul(tx.GasPrice(), new(big.Int).SetUint64(tx.Gas()))
+ total.Add(total, tx.Value())
+ return total
}
-func (tx *Transaction) Data() []byte { return common.CopyBytes(tx.data.Payload) }
-func (tx *Transaction) Gas() uint64 { return tx.data.GasLimit }
-func (tx *Transaction) GasPrice() *uint256.Int { return new(uint256.Int).Set(&tx.data.Price) }
+// RawSignatureValues returns the V, R, S signature values of the transaction.
+// The return values should not be modified by the caller.
+func (tx *Transaction) RawSignatureValues() (v, r, s *big.Int) {
+ return tx.inner.rawSignatureValues()
+}
+
+// GasPriceCmp compares the gas prices of two transactions.
func (tx *Transaction) GasPriceCmp(other *Transaction) int {
- return tx.data.Price.Cmp(&other.data.Price)
+ return tx.inner.gasPrice().Cmp(other.GasPrice())
}
func (tx *Transaction) GasPriceIntCmp(other *uint256.Int) int {
return tx.data.Price.Cmp(other)
@@ -188,25 +302,25 @@ func (tx *Transaction) Value() *uint256.Int { return new(uint256.Int).Set(&tx.da
func (tx *Transaction) Nonce() uint64 { return tx.data.AccountNonce }
func (tx *Transaction) CheckNonce() bool { return true }
-// To returns the recipient address of the transaction.
-// It returns nil if the transaction is a contract creation.
-func (tx *Transaction) To() *common.Address {
- if tx.data.Recipient == nil {
- return nil
- }
- to := *tx.data.Recipient
- return &to
+// GasPriceIntCmp compares the gas price of the transaction against the given price.
+func (tx *Transaction) GasPriceIntCmp(other *big.Int) int {
+ return tx.inner.gasPrice().Cmp(other)
}
-// Hash hashes the RLP encoding of tx.
-// It uniquely identifies the transaction.
+// Hash returns the transaction hash.
func (tx *Transaction) Hash() common.Hash {
if hash := tx.hash.Load(); hash != nil {
return hash.(common.Hash)
}
- v := rlpHash(tx)
- tx.hash.Store(v)
- return v
+
+ var h common.Hash
+ if tx.Type() == LegacyTxType {
+ h = rlpHash(tx.inner)
+ } else {
+ h = prefixedRlpHash(tx.Type(), tx.inner)
+ }
+ tx.hash.Store(h)
+ return h
}
// Size returns the true RLP encoded storage size of the transaction, either by
@@ -216,43 +330,11 @@ func (tx *Transaction) Size() common.StorageSize {
return size.(common.StorageSize)
}
c := writeCounter(0)
- rlp.Encode(&c, &tx.data)
+ rlp.Encode(&c, &tx.inner)
tx.size.Store(common.StorageSize(c))
return common.StorageSize(c)
}
-// AsMessage returns the transaction as a core.Message.
-//
-// AsMessage requires a signer to derive the sender.
-//
-// XXX Rename message to something less arbitrary?
-func (tx *Transaction) AsMessage(s Signer) (Message, error) {
- msg := Message{
- nonce: tx.data.AccountNonce,
- gasLimit: tx.data.GasLimit,
- gasPrice: tx.data.Price,
- to: tx.data.Recipient,
- amount: tx.data.Amount,
- data: tx.data.Payload,
- checkNonce: true,
- }
-
- var err error
- msg.from, err = Sender(s, tx)
- if tx.Protected() && tx.ChainID().Cmp(s.ChainID()) != 0 {
- return msg, ErrInvalidChainId
- }
- return msg, err
-}
-
-func (tx *Transaction) SetFrom(from common.Address) {
- tx.from.Store(from)
-}
-
-func (tx *Transaction) HasFrom() bool {
- return tx.from.Load() != nil
-}
-
// WithSignature returns a new transaction with the given signature.
// This signature needs to be in the [R || S || V] format where V is 0 or 1.
func (tx *Transaction) WithSignature(signer Signer, sig []byte) (*Transaction, error) {
@@ -260,40 +342,27 @@ func (tx *Transaction) WithSignature(signer Signer, sig []byte) (*Transaction, e
if err != nil {
return nil, err
}
- cpy := &Transaction{
- data: tx.data,
- time: tx.time,
- }
- cpy.data.R, cpy.data.S, cpy.data.V = *r, *s, *v
- return cpy, nil
+ cpy := tx.inner.copy()
+ cpy.setSignatureValues(signer.ChainID(), v, r, s)
+ return &Transaction{inner: cpy, time: tx.time}, nil
}
-// Cost returns amount + gasprice * gaslimit.
-func (tx *Transaction) Cost() *big.Int {
- total := new(big.Int).Mul(tx.data.Price.ToBig(), new(big.Int).SetUint64(tx.data.GasLimit))
- total.Add(total, tx.data.Amount.ToBig())
- return total
-}
-
-// RawSignatureValues returns the V, R, S signature values of the transaction.
-// The return values should not be modified by the caller.
-func (tx *Transaction) RawSignatureValues() (v, r, s *uint256.Int) {
- return &tx.data.V, &tx.data.R, &tx.data.S
-}
-
-// Transactions is a Transaction slice type for basic sorting.
+// Transactions implements DerivableList for transactions.
type Transactions []*Transaction
// Len returns the length of s.
func (s Transactions) Len() int { return len(s) }
-// Swap swaps the i'th and the j'th element in s.
-func (s Transactions) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
-
-// GetRlp implements Rlpable and returns the i'th element of s in rlp.
-func (s Transactions) GetRlp(i int) []byte {
- enc, _ := rlp.EncodeToBytes(s[i])
- return enc
+// EncodeIndex encodes the i'th transaction to w. Note that this does not check for errors
+// because we assume that *Transaction will only ever contain valid txs that were either
+// constructed by decoding or via public API in this package.
+func (s Transactions) EncodeIndex(i int, w *bytes.Buffer) {
+ tx := s[i]
+ if tx.Type() == LegacyTxType {
+ rlp.Encode(w, tx.inner)
+ } else {
+ tx.encodeTyped(w)
+ }
}
// TxDifference returns a new set which is the difference between a and b.
@@ -320,7 +389,7 @@ func TxDifference(a, b Transactions) Transactions {
type TxByNonce Transactions
func (s TxByNonce) Len() int { return len(s) }
-func (s TxByNonce) Less(i, j int) bool { return s[i].data.AccountNonce < s[j].data.AccountNonce }
+func (s TxByNonce) Less(i, j int) bool { return s[i].Nonce() < s[j].Nonce() }
func (s TxByNonce) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
// TxByPriceAndTime implements both the sort and the heap interface, making it useful
@@ -331,7 +400,7 @@ func (s TxByPriceAndTime) Len() int { return len(s) }
func (s TxByPriceAndTime) Less(i, j int) bool {
// If the prices are equal, use the time the transaction was first seen for
// deterministic sorting
- cmp := s[i].data.Price.Cmp(&s[j].data.Price)
+ cmp := s[i].GasPrice().Cmp(s[j].GasPrice())
if cmp == 0 {
return s[i].time.Before(s[j].time)
}
@@ -369,13 +438,13 @@ func NewTransactionsByPriceAndNonce(signer Signer, txs map[common.Address]Transa
// Initialize a price and received time based heap with the head transactions
heads := make(TxByPriceAndTime, 0, len(txs))
for from, accTxs := range txs {
- heads = append(heads, accTxs[0])
// Ensure the sender address is from the signer
- acc, _ := Sender(signer, accTxs[0])
- txs[acc] = accTxs[1:]
- if from != acc {
+ if acc, _ := Sender(signer, accTxs[0]); acc != from {
delete(txs, from)
+ continue
}
+ heads = append(heads, accTxs[0])
+ txs[from] = accTxs[1:]
}
heap.Init(&heads)
@@ -424,10 +493,11 @@ type Message struct {
gasLimit uint64
gasPrice uint256.Int
data []byte
+ accessList AccessList
checkNonce bool
}
-func NewMessage(from common.Address, to *common.Address, nonce uint64, amount *uint256.Int, gasLimit uint64, gasPrice *uint256.Int, data []byte, checkNonce bool) Message {
+func NewMessage(from common.Address, to *common.Address, nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte, accessList AccessList, checkNonce bool) Message {
return Message{
from: from,
to: to,
@@ -436,10 +506,29 @@ func NewMessage(from common.Address, to *common.Address, nonce uint64, amount *u
gasLimit: gasLimit,
gasPrice: *gasPrice,
data: data,
+ accessList: accessList,
checkNonce: checkNonce,
}
}
+// AsMessage returns the transaction as a core.Message.
+func (tx *Transaction) AsMessage(s Signer) (Message, error) {
+ msg := Message{
+ nonce: tx.Nonce(),
+ gasLimit: tx.Gas(),
+ gasPrice: new(big.Int).Set(tx.GasPrice()),
+ to: tx.To(),
+ amount: tx.Value(),
+ data: tx.Data(),
+ accessList: tx.AccessList(),
+ checkNonce: true,
+ }
+
+ var err error
+ msg.from, err = Sender(s, tx)
+ return msg, err
+}
+
func (m Message) From() common.Address { return m.from }
func (m Message) To() *common.Address { return m.to }
func (m Message) GasPrice() *uint256.Int { return &m.gasPrice }
@@ -447,4 +536,5 @@ func (m Message) Value() *uint256.Int { return &m.amount }
func (m Message) Gas() uint64 { return m.gasLimit }
func (m Message) Nonce() uint64 { return m.nonce }
func (m Message) Data() []byte { return m.data }
+func (m Message) AccessList() AccessList { return m.accessList }
func (m Message) CheckNonce() bool { return m.checkNonce }
diff --git a/core/types/transaction_marshalling.go b/core/types/transaction_marshalling.go
new file mode 100644
index 0000000000..184a17d5b5
--- /dev/null
+++ b/core/types/transaction_marshalling.go
@@ -0,0 +1,187 @@
+package types
+
+import (
+ "encoding/json"
+ "errors"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+// txJSON is the JSON representation of transactions.
+type txJSON struct {
+ Type hexutil.Uint64 `json:"type"`
+
+ // Common transaction fields:
+ Nonce *hexutil.Uint64 `json:"nonce"`
+ GasPrice *hexutil.Big `json:"gasPrice"`
+ Gas *hexutil.Uint64 `json:"gas"`
+ Value *hexutil.Big `json:"value"`
+ Data *hexutil.Bytes `json:"input"`
+ V *hexutil.Big `json:"v"`
+ R *hexutil.Big `json:"r"`
+ S *hexutil.Big `json:"s"`
+ To *common.Address `json:"to"`
+
+ // Access list transaction fields:
+ ChainID *hexutil.Big `json:"chainId,omitempty"`
+ AccessList *AccessList `json:"accessList,omitempty"`
+
+ // Only used for encoding:
+ Hash common.Hash `json:"hash"`
+}
+
+// MarshalJSON marshals as JSON with a hash.
+func (t *Transaction) MarshalJSON() ([]byte, error) {
+ var enc txJSON
+ // These are set for all tx types.
+ enc.Hash = t.Hash()
+ enc.Type = hexutil.Uint64(t.Type())
+
+ // Other fields are set conditionally depending on tx type.
+ switch tx := t.inner.(type) {
+ case *LegacyTx:
+ enc.Nonce = (*hexutil.Uint64)(&tx.Nonce)
+ enc.Gas = (*hexutil.Uint64)(&tx.Gas)
+ enc.GasPrice = (*hexutil.Big)(tx.GasPrice)
+ enc.Value = (*hexutil.Big)(tx.Value)
+ enc.Data = (*hexutil.Bytes)(&tx.Data)
+ enc.To = t.To()
+ enc.V = (*hexutil.Big)(tx.V)
+ enc.R = (*hexutil.Big)(tx.R)
+ enc.S = (*hexutil.Big)(tx.S)
+ case *AccessListTx:
+ enc.ChainID = (*hexutil.Big)(tx.ChainID)
+ enc.AccessList = &tx.AccessList
+ enc.Nonce = (*hexutil.Uint64)(&tx.Nonce)
+ enc.Gas = (*hexutil.Uint64)(&tx.Gas)
+ enc.GasPrice = (*hexutil.Big)(tx.GasPrice)
+ enc.Value = (*hexutil.Big)(tx.Value)
+ enc.Data = (*hexutil.Bytes)(&tx.Data)
+ enc.To = t.To()
+ enc.V = (*hexutil.Big)(tx.V)
+ enc.R = (*hexutil.Big)(tx.R)
+ enc.S = (*hexutil.Big)(tx.S)
+ }
+ return json.Marshal(&enc)
+}
+
+// UnmarshalJSON unmarshals from JSON.
+func (t *Transaction) UnmarshalJSON(input []byte) error {
+ var dec txJSON
+ if err := json.Unmarshal(input, &dec); err != nil {
+ return err
+ }
+
+ // Decode / verify fields according to transaction type.
+ var inner TxData
+ switch dec.Type {
+ case LegacyTxType:
+ var itx LegacyTx
+ inner = &itx
+ if dec.To != nil {
+ itx.To = dec.To
+ }
+ if dec.Nonce == nil {
+ return errors.New("missing required field 'nonce' in transaction")
+ }
+ itx.Nonce = uint64(*dec.Nonce)
+ if dec.GasPrice == nil {
+ return errors.New("missing required field 'gasPrice' in transaction")
+ }
+ itx.GasPrice = (*big.Int)(dec.GasPrice)
+ if dec.Gas == nil {
+ return errors.New("missing required field 'gas' in transaction")
+ }
+ itx.Gas = uint64(*dec.Gas)
+ if dec.Value == nil {
+ return errors.New("missing required field 'value' in transaction")
+ }
+ itx.Value = (*big.Int)(dec.Value)
+ if dec.Data == nil {
+ return errors.New("missing required field 'input' in transaction")
+ }
+ itx.Data = *dec.Data
+ if dec.V == nil {
+ return errors.New("missing required field 'v' in transaction")
+ }
+ itx.V = (*big.Int)(dec.V)
+ if dec.R == nil {
+ return errors.New("missing required field 'r' in transaction")
+ }
+ itx.R = (*big.Int)(dec.R)
+ if dec.S == nil {
+ return errors.New("missing required field 's' in transaction")
+ }
+ itx.S = (*big.Int)(dec.S)
+ withSignature := itx.V.Sign() != 0 || itx.R.Sign() != 0 || itx.S.Sign() != 0
+ if withSignature {
+ if err := sanityCheckSignature(itx.V, itx.R, itx.S, true); err != nil {
+ return err
+ }
+ }
+
+ case AccessListTxType:
+ var itx AccessListTx
+ inner = &itx
+ // Access list is optional for now.
+ if dec.AccessList != nil {
+ itx.AccessList = *dec.AccessList
+ }
+ if dec.ChainID == nil {
+ return errors.New("missing required field 'chainId' in transaction")
+ }
+ itx.ChainID = (*big.Int)(dec.ChainID)
+ if dec.To != nil {
+ itx.To = dec.To
+ }
+ if dec.Nonce == nil {
+ return errors.New("missing required field 'nonce' in transaction")
+ }
+ itx.Nonce = uint64(*dec.Nonce)
+ if dec.GasPrice == nil {
+ return errors.New("missing required field 'gasPrice' in transaction")
+ }
+ itx.GasPrice = (*big.Int)(dec.GasPrice)
+ if dec.Gas == nil {
+ return errors.New("missing required field 'gas' in transaction")
+ }
+ itx.Gas = uint64(*dec.Gas)
+ if dec.Value == nil {
+ return errors.New("missing required field 'value' in transaction")
+ }
+ itx.Value = (*big.Int)(dec.Value)
+ if dec.Data == nil {
+ return errors.New("missing required field 'input' in transaction")
+ }
+ itx.Data = *dec.Data
+ if dec.V == nil {
+ return errors.New("missing required field 'v' in transaction")
+ }
+ itx.V = (*big.Int)(dec.V)
+ if dec.R == nil {
+ return errors.New("missing required field 'r' in transaction")
+ }
+ itx.R = (*big.Int)(dec.R)
+ if dec.S == nil {
+ return errors.New("missing required field 's' in transaction")
+ }
+ itx.S = (*big.Int)(dec.S)
+ withSignature := itx.V.Sign() != 0 || itx.R.Sign() != 0 || itx.S.Sign() != 0
+ if withSignature {
+ if err := sanityCheckSignature(itx.V, itx.R, itx.S, false); err != nil {
+ return err
+ }
+ }
+
+ default:
+ return ErrTxTypeNotSupported
+ }
+
+ // Now set the inner transaction.
+ t.setDecoded(inner, 0)
+
+ // TODO: check hash here?
+ return nil
+}
diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go
index ba177d84a2..9793afcf43 100644
--- a/core/types/transaction_signing.go
+++ b/core/types/transaction_signing.go
@@ -24,21 +24,21 @@ import (
"github.com/holiman/uint256"
- "github.com/ledgerwatch/turbo-geth/common"
- "github.com/ledgerwatch/turbo-geth/common/u256"
- "github.com/ledgerwatch/turbo-geth/crypto"
- "github.com/ledgerwatch/turbo-geth/crypto/secp256k1"
- "github.com/ledgerwatch/turbo-geth/params"
-)
+var ErrInvalidChainId = errors.New("invalid chain id for signer")
-var (
- ErrInvalidChainId = errors.New("invalid chain id for signer")
-)
+// sigCache is used to cache the derived sender and contains
+// the signer used to derive it.
+type sigCache struct {
+ signer Signer
+ from common.Address
+}
// MakeSigner returns a Signer based on the given chain config and block number.
func MakeSigner(config *params.ChainConfig, blockNumber *big.Int) Signer {
var signer Signer
switch {
+ case config.IsYoloV3(blockNumber):
+ signer = NewEIP2930Signer(config.ChainID)
case config.IsEIP155(blockNumber):
signer = NewEIP155Signer(config.ChainID)
case config.IsHomestead(blockNumber):
@@ -49,7 +49,40 @@ func MakeSigner(config *params.ChainConfig, blockNumber *big.Int) Signer {
return signer
}
-// SignTx signs the transaction using the given signer and private key
+// LatestSigner returns the 'most permissive' Signer available for the given chain
+// configuration. Specifically, this enables support of EIP-155 replay protection and
+// EIP-2930 access list transactions when their respective forks are scheduled to occur at
+// any block number in the chain config.
+//
+// Use this in transaction-handling code where the current block number is unknown. If you
+// have the current block number available, use MakeSigner instead.
+func LatestSigner(config *params.ChainConfig) Signer {
+ if config.ChainID != nil {
+ if config.YoloV3Block != nil {
+ return NewEIP2930Signer(config.ChainID)
+ }
+ if config.EIP155Block != nil {
+ return NewEIP155Signer(config.ChainID)
+ }
+ }
+ return HomesteadSigner{}
+}
+
+// LatestSignerForChainID returns the 'most permissive' Signer available. Specifically,
+// this enables support for EIP-155 replay protection and all implemented EIP-2718
+// transaction types if chainID is non-nil.
+//
+// Use this in transaction-handling code where the current block number and fork
+// configuration are unknown. If you have a ChainConfig, use LatestSigner instead.
+// If you have a ChainConfig and know the current block number, use MakeSigner instead.
+func LatestSignerForChainID(chainID *big.Int) Signer {
+ if chainID == nil {
+ return HomesteadSigner{}
+ }
+ return NewEIP2930Signer(chainID)
+}
+
+// SignTx signs the transaction using the given signer and private key.
func SignTx(tx *Transaction, s Signer, prv *ecdsa.PrivateKey) (*Transaction, error) {
h := s.Hash(tx)
sig, err := crypto.Sign(h[:], prv)
@@ -59,6 +92,27 @@ func SignTx(tx *Transaction, s Signer, prv *ecdsa.PrivateKey) (*Transaction, err
return tx.WithSignature(s, sig)
}
+// SignNewTx creates a transaction and signs it.
+func SignNewTx(prv *ecdsa.PrivateKey, s Signer, txdata TxData) (*Transaction, error) {
+ tx := NewTx(txdata)
+ h := s.Hash(tx)
+ sig, err := crypto.Sign(h[:], prv)
+ if err != nil {
+ return nil, err
+ }
+ return tx.WithSignature(s, sig)
+}
+
+// MustSignNewTx creates a transaction and signs it.
+// This panics if the transaction cannot be signed.
+func MustSignNewTx(prv *ecdsa.PrivateKey, s Signer, txdata TxData) *Transaction {
+ tx, err := SignNewTx(prv, s, txdata)
+ if err != nil {
+ panic(err)
+ }
+ return tx
+}
+
// Sender returns the address derived from the signature (V, R, S) using secp256k1
// elliptic curve and an error if it failed deriving or upon an incorrect
// signature.
@@ -78,8 +132,12 @@ func Sender(signer Signer, tx *Transaction) (common.Address, error) {
return addr, nil
}
-// Signer encapsulates transaction signature handling. Note that this interface is not a
-// stable API and may change at any time to accommodate new protocol rules.
+// Signer encapsulates transaction signature handling. The name of this type is slightly
+// misleading because Signers don't actually sign, they're just for validating and
+// processing of signatures.
+//
+// Note that this interface is not a stable API and may change at any time to accommodate
+// new protocol rules.
type Signer interface {
// Sender returns the sender address of the transaction.
Sender(tx *Transaction) (common.Address, error)
@@ -89,15 +147,115 @@ type Signer interface {
// SignatureValues returns the raw R, S, V values corresponding to the
// given signature.
SignatureValues(tx *Transaction, sig []byte) (r, s, v *uint256.Int, err error)
- // Hash returns the hash to be signed.
+ ChainID() *big.Int
+
+ // Hash returns 'signature hash', i.e. the transaction hash that is signed by the
+ // private key. This hash does not uniquely identify the transaction.
Hash(tx *Transaction) common.Hash
+
// Equal returns true if the given signer is the same as the receiver.
Equal(Signer) bool
- // Return 0 for pre-EIP155 signers
- ChainID() *uint256.Int
}
-// EIP155Transaction implements Signer using the EIP155 rules.
+type eip2930Signer struct{ EIP155Signer }
+
+// NewEIP2930Signer returns a signer that accepts EIP-2930 access list transactions,
+// EIP-155 replay protected transactions, and legacy Homestead transactions.
+func NewEIP2930Signer(chainId *big.Int) Signer {
+ return eip2930Signer{NewEIP155Signer(chainId)}
+}
+
+func (s eip2930Signer) ChainID() *big.Int {
+ return s.chainId
+}
+
+func (s eip2930Signer) Equal(s2 Signer) bool {
+ x, ok := s2.(eip2930Signer)
+ return ok && x.chainId.Cmp(s.chainId) == 0
+}
+
+func (s eip2930Signer) Sender(tx *Transaction) (common.Address, error) {
+ V, R, S := tx.RawSignatureValues()
+ switch tx.Type() {
+ case LegacyTxType:
+ if !tx.Protected() {
+ return HomesteadSigner{}.Sender(tx)
+ }
+ V = new(big.Int).Sub(V, s.chainIdMul)
+ V.Sub(V, big8)
+ case AccessListTxType:
+ // ACL txs are defined to use 0 and 1 as their recovery id, add
+ // 27 to become equivalent to unprotected Homestead signatures.
+ V = new(big.Int).Add(V, big.NewInt(27))
+ default:
+ return common.Address{}, ErrTxTypeNotSupported
+ }
+ if tx.ChainId().Cmp(s.chainId) != 0 {
+ return common.Address{}, ErrInvalidChainId
+ }
+ return recoverPlain(s.Hash(tx), R, S, V, true)
+}
+
+func (s eip2930Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big.Int, err error) {
+ switch txdata := tx.inner.(type) {
+ case *LegacyTx:
+ R, S, V = decodeSignature(sig)
+ if s.chainId.Sign() != 0 {
+ V = big.NewInt(int64(sig[64] + 35))
+ V.Add(V, s.chainIdMul)
+ }
+ case *AccessListTx:
+ // Check that chain ID of tx matches the signer. We also accept ID zero here,
+ // because it indicates that the chain ID was not specified in the tx.
+ if txdata.ChainID.Sign() != 0 && txdata.ChainID.Cmp(s.chainId) != 0 {
+ return nil, nil, nil, ErrInvalidChainId
+ }
+ R, S, _ = decodeSignature(sig)
+ V = big.NewInt(int64(sig[64]))
+ default:
+ return nil, nil, nil, ErrTxTypeNotSupported
+ }
+ return R, S, V, nil
+}
+
+// Hash returns the hash to be signed by the sender.
+// It does not uniquely identify the transaction.
+func (s eip2930Signer) Hash(tx *Transaction) common.Hash {
+ switch tx.Type() {
+ case LegacyTxType:
+ return rlpHash([]interface{}{
+ tx.Nonce(),
+ tx.GasPrice(),
+ tx.Gas(),
+ tx.To(),
+ tx.Value(),
+ tx.Data(),
+ s.chainId, uint(0), uint(0),
+ })
+ case AccessListTxType:
+ return prefixedRlpHash(
+ tx.Type(),
+ []interface{}{
+ s.chainId,
+ tx.Nonce(),
+ tx.GasPrice(),
+ tx.Gas(),
+ tx.To(),
+ tx.Value(),
+ tx.Data(),
+ tx.AccessList(),
+ })
+ default:
+ // This _should_ not happen, but in case someone sends in a bad
+ // json struct via RPC, it's probably more prudent to return an
+ // empty hash instead of killing the node with a panic
+ //panic("Unsupported transaction type: %d", tx.typ)
+ return common.Hash{}
+ }
+}
+
+// EIP155Signer implements Signer using the EIP-155 rules. This accepts transactions which
+// are replay-protected as well as unprotected homestead transactions.
type EIP155Signer struct {
chainID, chainIDMul *uint256.Int
}
@@ -113,6 +271,10 @@ func NewEIP155Signer(chainId *big.Int) EIP155Signer {
}
}
+func (s EIP155Signer) ChainID() *big.Int {
+ return s.chainId
+}
+
func (s EIP155Signer) Equal(s2 Signer) bool {
eip155, ok := s2.(EIP155Signer)
return ok && eip155.chainID.Cmp(s.chainID) == 0
@@ -123,12 +285,16 @@ func (s EIP155Signer) Sender(tx *Transaction) (common.Address, error) {
}
func (s EIP155Signer) SenderWithContext(context *secp256k1.Context, tx *Transaction) (common.Address, error) {
+ if tx.Type() != LegacyTxType {
+return common.Address{}, ErrTxTypeNotSupported
+}
if !tx.Protected() {
return HomesteadSigner{}.Sender(tx)
}
if !tx.ChainID().Eq(s.chainID) {
return common.Address{}, ErrInvalidChainId
}
+ V, R, S := tx.RawSignatureValues()
V := new(uint256.Int).Sub(&tx.data.V, s.chainIDMul)
V.Sub(V, u256.Num8)
return recoverPlain(context, s.Hash(tx), &tx.data.R, &tx.data.S, V, true)
@@ -137,10 +303,10 @@ func (s EIP155Signer) SenderWithContext(context *secp256k1.Context, tx *Transact
// SignatureValues returns signature values. This signature
// needs to be in the [R || S || V] format where V is 0 or 1.
func (s EIP155Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *uint256.Int, err error) {
- R, S, V, err = HomesteadSigner{}.SignatureValues(tx, sig)
- if err != nil {
- return nil, nil, nil, err
+ if tx.Type() != LegacyTxType {
+ return nil, nil, nil, ErrTxTypeNotSupported
}
+ R, S, V = decodeSignature(sig)
if s.chainID.Sign() != 0 {
V = uint256.NewInt().SetUint64(uint64(sig[64] + 35))
V.Add(V, s.chainIDMul)
@@ -170,6 +336,10 @@ func (s EIP155Signer) ChainID() *uint256.Int {
// homestead rules.
type HomesteadSigner struct{ FrontierSigner }
+func (s HomesteadSigner) ChainID() *big.Int {
+ return nil
+}
+
func (hs HomesteadSigner) Equal(s2 Signer) bool {
_, ok := s2.(HomesteadSigner)
return ok
@@ -182,6 +352,10 @@ func (hs HomesteadSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v
}
func (hs HomesteadSigner) Sender(tx *Transaction) (common.Address, error) {
+ if tx.Type() != LegacyTxType {
+ return common.Address{}, ErrTxTypeNotSupported
+ }
+ v, r, s := tx.RawSignatureValues()
return hs.SenderWithContext(secp256k1.DefaultContext, tx)
}
@@ -196,15 +370,21 @@ func (fs FrontierSigner) Equal(s2 Signer) bool {
return ok
}
+func (fs FrontierSigner) Sender(tx *Transaction) (common.Address, error) {
+ if tx.Type() != LegacyTxType {
+ return common.Address{}, ErrTxTypeNotSupported
+ }
+ v, r, s := tx.RawSignatureValues()
+ return recoverPlain(fs.Hash(tx), r, s, v, false)
+}
+
// SignatureValues returns signature values. This signature
// needs to be in the [R || S || V] format where V is 0 or 1.
-func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *uint256.Int, err error) {
- if len(sig) != crypto.SignatureLength {
- panic(fmt.Sprintf("wrong size for signature: got %d, want %d", len(sig), crypto.SignatureLength))
+func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *big.Int, err error) {
+ if tx.Type() != LegacyTxType {
+ return nil, nil, nil, ErrTxTypeNotSupported
}
- r = new(uint256.Int).SetBytes(sig[:32])
- s = new(uint256.Int).SetBytes(sig[32:64])
- v = new(uint256.Int).SetBytes([]byte{sig[64] + 27})
+ r, s, v = decodeSignature(sig)
return r, s, v, nil
}
@@ -212,17 +392,23 @@ func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *
// It does not uniquely identify the transaction.
func (fs FrontierSigner) Hash(tx *Transaction) common.Hash {
return rlpHash([]interface{}{
- tx.data.AccountNonce,
- tx.data.Price,
- tx.data.GasLimit,
- tx.data.Recipient,
- tx.data.Amount,
- tx.data.Payload,
+ tx.Nonce(),
+ tx.GasPrice(),
+ tx.Gas(),
+ tx.To(),
+ tx.Value(),
+ tx.Data(),
})
}
-func (fs FrontierSigner) Sender(tx *Transaction) (common.Address, error) {
- return fs.SenderWithContext(secp256k1.DefaultContext, tx)
+func decodeSignature(sig []byte) (r, s, v *big.Int) {
+ if len(sig) != crypto.SignatureLength {
+ panic(fmt.Sprintf("wrong size for signature: got %d, want %d", len(sig), crypto.SignatureLength))
+ }
+ r = new(big.Int).SetBytes(sig[:32])
+ s = new(big.Int).SetBytes(sig[32:64])
+ v = new(big.Int).SetBytes([]byte{sig[64] + 27})
+ return r, s, v
}
func (fs FrontierSigner) SenderWithContext(context *secp256k1.Context, tx *Transaction) (common.Address, error) {
diff --git a/core/types/transaction_test.go b/core/types/transaction_test.go
index 12ef026f6e..af4aac712b 100644
--- a/core/types/transaction_test.go
+++ b/core/types/transaction_test.go
@@ -34,6 +34,8 @@ import (
// 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"),
@@ -43,7 +45,7 @@ var (
rightvrsTx, _ = NewTransaction(
3,
- common.HexToAddress("b94f5374fce5edbc8e2a8697c15331677e6ebf0b"),
+ testAddr,
uint256.NewInt().SetUint64(10),
2000,
uint256.NewInt().SetUint64(1),
@@ -52,8 +54,32 @@ var (
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 != errEmptyTypedTx {
+ t.Fatal("wrong error:", err)
+ }
+}
+
func TestTransactionSigHash(t *testing.T) {
var homestead HomesteadSigner
if homestead.Hash(emptyTx) != common.HexToHash("c775b99e7ad12f50d819fcd602390467e28141316969f4b57f0626f74fe3b386") {
@@ -75,10 +101,121 @@ func TestTransactionEncode(t *testing.T) {
}
}
+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 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 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
}
@@ -221,50 +358,128 @@ func TestTransactionTimeSort(t *testing.T) {
}
}
-// TestTransactionJSON tests serializing/de-serializing to/from JSON.
-func TestTransactionJSON(t *testing.T) {
+// 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)
}
- signer := NewEIP155Signer(common.Big1)
-
- transactions := make([]*Transaction, 0, 50)
- for i := uint64(0); i < 25; i++ {
- var tx *Transaction
- switch i % 2 {
+ 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:
- tx = NewTransaction(i, common.Address{1}, u256.Num0, 1, u256.Num2, []byte("abcdef"))
+ // Legacy tx.
+ txdata = &LegacyTx{
+ Nonce: i,
+ To: &recipient,
+ Gas: 1,
+ GasPrice: big.NewInt(2),
+ Data: []byte("abcdef"),
+ }
case 1:
- tx = NewContractCreation(i, u256.Num0, 1, u256.Num2, []byte("abcdef"))
+ // 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,
+ }
}
- transactions = append(transactions, tx)
-
- signedTx, err := SignTx(tx, signer, key)
+ tx, err := SignNewTx(key, signer, txdata)
if err != nil {
t.Fatalf("could not sign transaction: %v", err)
}
-
- transactions = append(transactions, signedTx)
- }
-
- for _, tx := range transactions {
- data, err := json.Marshal(tx)
+ // RLP
+ parsedTx, err := encodeDecodeBinary(tx)
if err != nil {
- t.Fatalf("json.Marshal failed: %v", err)
+ t.Fatal(err)
}
+ assertEqual(parsedTx, tx)
- var parsedTx *Transaction
- if err := json.Unmarshal(data, &parsedTx); err != nil {
- t.Fatalf("json.Unmarshal failed: %v", err)
+ // JSON
+ parsedTx, err = encodeDecodeJSON(tx)
+ if err != nil {
+ t.Fatal(err)
}
+ assertEqual(parsedTx, tx)
+ }
+}
+
+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
+}
- // compare nonce, price, gaslimit, recipient, amount, payload, V, R, S
- if tx.Hash() != parsedTx.Hash() {
- t.Errorf("parsed tx differs from original tx, want %v, got %v", tx, parsedTx)
+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 fmt.Errorf("access list wrong!")
}
if tx.ChainID().Cmp(parsedTx.ChainID()) != 0 {
t.Errorf("invalid chain id, want %d, got %d", tx.ChainID(), parsedTx.ChainID())
}
}
+ return nil
}
diff --git a/core/vm/interface.go b/core/vm/interface.go
index 465cd8ff58..a705ec349b 100644
--- a/core/vm/interface.go
+++ b/core/vm/interface.go
@@ -59,6 +59,7 @@ type IntraBlockState interface {
// is defined according to EIP161 (balance = nonce = code = 0).
Empty(common.Address) bool
+ PrepareAccessList(sender common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList)
AddressInAccessList(addr common.Address) bool
SlotInAccessList(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool)
// AddAddressToAccessList adds the given address to the access list. This operation is safe to perform
diff --git a/core/vm/runtime/runtime.go b/core/vm/runtime/runtime.go
index cef4e3663e..87f0779fd0 100644
--- a/core/vm/runtime/runtime.go
+++ b/core/vm/runtime/runtime.go
@@ -120,11 +120,7 @@ func Execute(code, input []byte, cfg *Config, blockNr uint64) ([]byte, *state.In
sender = vm.AccountRef(cfg.Origin)
)
if cfg.ChainConfig.IsYoloV3(vmenv.Context.BlockNumber) {
- cfg.State.AddAddressToAccessList(cfg.Origin)
- cfg.State.AddAddressToAccessList(address)
- for _, addr := range vmenv.ActivePrecompiles() {
- cfg.State.AddAddressToAccessList(addr)
- }
+ cfg.State.PrepareAccessList(cfg.Origin, &address, vmenv.ActivePrecompiles(), nil)
}
cfg.State.CreateAccount(address, true)
// set the receiver's (the executing contract) code for execution.
@@ -160,10 +156,7 @@ func Create(input []byte, cfg *Config, blockNr uint64) ([]byte, common.Address,
sender = vm.AccountRef(cfg.Origin)
)
if cfg.ChainConfig.IsYoloV3(vmenv.Context.BlockNumber) {
- cfg.State.AddAddressToAccessList(cfg.Origin)
- for _, addr := range vmenv.ActivePrecompiles() {
- cfg.State.AddAddressToAccessList(addr)
- }
+ cfg.State.PrepareAccessList(cfg.Origin, nil, vmenv.ActivePrecompiles(), nil)
}
// Call the code with the given configuration.
@@ -187,12 +180,9 @@ func Call(address common.Address, input []byte, cfg *Config) ([]byte, uint64, er
vmenv := NewEnv(cfg)
sender := cfg.State.GetOrNewStateObject(cfg.Origin)
+ statedb := cfg.State
if cfg.ChainConfig.IsYoloV3(vmenv.Context.BlockNumber) {
- cfg.State.AddAddressToAccessList(cfg.Origin)
- cfg.State.AddAddressToAccessList(address)
- for _, addr := range vmenv.ActivePrecompiles() {
- cfg.State.AddAddressToAccessList(addr)
- }
+ statedb.PrepareAccessList(cfg.Origin, &address, vmenv.ActivePrecompiles(), nil)
}
// Call the code with the given configuration.
diff --git a/eth/downloader/downloader.go b/eth/downloader/downloader.go
index 783b6511f2..2c02859fdd 100644
--- a/eth/downloader/downloader.go
+++ b/eth/downloader/downloader.go
@@ -1492,7 +1492,7 @@ func (d *Downloader) fetchParts(deliveryCh chan dataPack, deliver func(dataPack)
case err == nil:
peer.log.Trace("Delivered new batch of data", "type", kind, "count", packet.Stats())
default:
- peer.log.Trace("Failed to deliver retrieved data", "type", kind, "err", err)
+ peer.log.Debug("Failed to deliver retrieved data", "type", kind, "err", err)
}
}
// Blocks assembled, try to update the progress
diff --git a/eth/gasprice/gasprice_test.go b/eth/gasprice/gasprice_test.go
index 9451accd4f..4400eb97ad 100644
--- a/eth/gasprice/gasprice_test.go
+++ b/eth/gasprice/gasprice_test.go
@@ -65,7 +65,7 @@ func newTestBackend(t *testing.T) *testBackend {
Config: params.TestChainConfig,
Alloc: core.GenesisAlloc{addr: {Balance: big.NewInt(math.MaxInt64)}},
}
- signer = types.NewEIP155Signer(gspec.Config.ChainID)
+ signer = types.LatestSigner(gspec.Config)
)
engine := ethash.NewFaker()
db := ethdb.NewMemDatabase()
diff --git a/eth/tracers/api.go b/eth/tracers/api.go
index 76706140a6..44f522926a 100644
--- a/eth/tracers/api.go
+++ b/eth/tracers/api.go
@@ -751,14 +751,15 @@ func (api *API) traceTx(ctx context.Context, message core.Message, vmctx vm.Bloc
default:
tracer = vm.NewStructLogger(config.LogConfig)
}
+
// Run the transaction with tracing enabled.
vmenv := vm.NewEVM(vmctx, txContext, statedb, api.backend.ChainConfig(), vm.Config{Debug: true, Tracer: tracer})
-
result, err := core.ApplyMessage(vmenv, message, new(core.GasPool).AddGas(message.Gas()))
if err != nil {
return nil, fmt.Errorf("tracing failed: %v", err)
}
- // Depending on the tracer type, format and return the output
+
+ // Depending on the tracer type, format and return the output.
switch tracer := tracer.(type) {
case *vm.StructLogger:
// If the result contains a revert reason, return it.
diff --git a/eth/tracers/tracer.go b/eth/tracers/tracer.go
index 982e368aa6..0b9ed51908 100644
--- a/eth/tracers/tracer.go
+++ b/eth/tracers/tracer.go
@@ -563,7 +563,7 @@ func (jst *Tracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost
if data, ok := jst.ctx["input"].([]byte); ok {
input = data
}
- intrinsicGas, err := core.IntrinsicGas(input, jst.ctx["type"] == "CREATE", isHomestead, isIstanbul)
+ intrinsicGas, err := core.IntrinsicGas(input, nil, jst.ctx["type"] == "CREATE", isHomestead, isIstanbul)
if err != nil {
return err
}
diff --git a/ethclient/ethclient.go b/ethclient/ethclient.go
index e5c10df588..b0ea6db3aa 100644
--- a/ethclient/ethclient.go
+++ b/ethclient/ethclient.go
@@ -524,7 +524,7 @@ func (ec *Client) EstimateGas(ctx context.Context, msg ethereum.CallMsg) (uint64
// If the transaction was a contract creation use the TransactionReceipt method to get the
// contract address after the transaction has been mined.
func (ec *Client) SendTransaction(ctx context.Context, tx *types.Transaction) error {
- data, err := rlp.EncodeToBytes(tx)
+ data, err := tx.MarshalBinary()
if err != nil {
return err
}
diff --git a/ethclient/ethclient_test.go b/ethclient/ethclient_test.go
index cc498b50ba..6061a69012 100644
--- a/ethclient/ethclient_test.go
+++ b/ethclient/ethclient_test.go
@@ -570,7 +570,7 @@ func sendTransaction(ec *Client) error {
}
// Create transaction
tx := types.NewTransaction(0, common.Address{1}, big.NewInt(1), 22000, big.NewInt(1), nil)
- signer := types.NewEIP155Signer(chainID)
+ signer := types.LatestSignerForChainID(chainID)
signature, err := crypto.Sign(signer.Hash(tx).Bytes(), testKey)
if err != nil {
return err
diff --git a/ethclient/signer.go b/ethclient/signer.go
index 44ac4e7070..bfbc977bf0 100644
--- a/ethclient/signer.go
+++ b/ethclient/signer.go
@@ -58,8 +58,8 @@ func (s *senderFromServer) SenderWithContext(_ *secp256k1.Context, tx *types.Tra
return s.addr, nil
}
-func (s *senderFromServer) ChainID() *uint256.Int {
- return u256.Num0
+func (s *senderFromServer) ChainID() *big.Int {
+ panic("can't sign with senderFromServer")
}
func (s *senderFromServer) Hash(tx *types.Transaction) common.Hash {
diff --git a/graphql/graphql.go b/graphql/graphql.go
index e02b67cf91..0dbe552f36 100644
--- a/graphql/graphql.go
+++ b/graphql/graphql.go
@@ -250,12 +250,8 @@ func (t *Transaction) From(ctx context.Context, args BlockNumberArgs) (*Account,
if err != nil || tx == nil {
return nil, err
}
- var signer types.Signer = types.HomesteadSigner{}
- if tx.Protected() {
- signer = types.NewEIP155Signer(tx.ChainID().ToBig())
- }
+ signer := types.LatestSigner(t.backend.ChainConfig())
from, _ := types.Sender(signer, tx)
-
return &Account{
backend: t.backend,
address: from,
@@ -1026,7 +1022,7 @@ func (r *Resolver) Transaction(ctx context.Context, args struct{ Hash common.Has
func (r *Resolver) SendRawTransaction(ctx context.Context, args struct{ Data hexutil.Bytes }) (common.Hash, error) {
tx := new(types.Transaction)
- if err := rlp.DecodeBytes(args.Data, tx); err != nil {
+ if err := tx.UnmarshalBinary(args.Data); err != nil {
return common.Hash{}, err
}
hash, err := ethapi.SubmitTransaction(ctx, r.backend, tx)
diff --git a/interfaces.go b/interfaces.go
index e81cab834b..3426260b0b 100644
--- a/interfaces.go
+++ b/interfaces.go
@@ -121,6 +121,8 @@ type CallMsg struct {
GasPrice *uint256.Int // wei <-> gas exchange ratio
Value *uint256.Int // amount of wei sent along with the call
Data []byte // input data, usually an ABI-encoded contract method invocation
+
+ AccessList types.AccessList // EIP-2930 access list.
}
// A ContractCaller provides contract calls, essentially transactions that are executed by
diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go
index e9379f38e4..8385640ec2 100644
--- a/internal/ethapi/api.go
+++ b/internal/ethapi/api.go
@@ -411,7 +411,7 @@ func (s *PrivateAccountAPI) SignTransaction(ctx context.Context, args SendTxArgs
log.Warn("Failed transaction sign attempt", "from", args.From, "to", args.To, "value", args.Value.ToInt(), "err", err)
return nil, err
}
- data, err := rlp.EncodeToBytes(signed)
+ data, err := signed.MarshalBinary()
if err != nil {
return nil, err
}
@@ -685,15 +685,16 @@ func (s *PublicBlockChainAPI) GetStorageAt(ctx context.Context, address common.A
// CallArgs represents the arguments for a call.
type CallArgs struct {
- From *common.Address `json:"from"`
- To *common.Address `json:"to"`
- Gas *hexutil.Uint64 `json:"gas"`
- GasPrice *hexutil.Big `json:"gasPrice"`
- Value *hexutil.Big `json:"value"`
+ From *common.Address `json:"from"`
+ To *common.Address `json:"to"`
+ Gas *hexutil.Uint64 `json:"gas"`
+ GasPrice *hexutil.Big `json:"gasPrice"`
+ Value *hexutil.Big `json:"value"`
// We accept "data" and "input" for backwards-compatibility reasons. "input" is the
// newer name and should be preferred by clients.
Data *hexutil.Bytes `json:"data"`
Input *hexutil.Bytes `json:"input"`
+ AccessList *types.AccessList `json:"accessList"`
}
// ToMessage converts CallArgs to the Message type used by the core evm
@@ -720,12 +721,14 @@ func (args *CallArgs) ToMessage(globalGasCap uint64) types.Message {
if args.GasPrice != nil {
gasPrice.SetFromBig(args.GasPrice.ToInt())
}
-
value := new(uint256.Int)
if args.Value != nil {
value.SetFromBig(args.Value.ToInt())
}
-
+ var accessList types.AccessList
+ if args.AccessList != nil {
+ accessList = *args.AccessList
+ }
var input []byte
if args.Input != nil {
input = *args.Input
@@ -733,7 +736,7 @@ func (args *CallArgs) ToMessage(globalGasCap uint64) types.Message {
input = *args.Data
}
- msg := types.NewMessage(addr, args.To, 0, value, gas, gasPrice, input, false)
+ msg := types.NewMessage(addr, args.To, 0, value, gas, gasPrice, input, data, accessList, false)
return msg
}
@@ -813,13 +816,13 @@ func DoCall(ctx context.Context, b Backend, args CallArgs, blockNrOrHash rpc.Blo
evm.Cancel()
}()
- // Setup the gas pool (also for unmetered requests)
- // and apply the message.
+ // Execute the message.
gp := new(core.GasPool).AddGas(math.MaxUint64)
result, err := core.ApplyMessage(evm, msg, gp, true /* refunds */, false /* gasBailout */)
if err := vmError(); err != nil {
return nil, err
}
+
// If the timer caused an abort, return an appropriate error message
if evm.Cancelled() {
return nil, fmt.Errorf("execution aborted (timeout = %v)", timeout)
@@ -1144,33 +1147,43 @@ func (s *PublicBlockChainAPI) rpcMarshalBlock(ctx context.Context, b *types.Bloc
// RPCTransaction represents a transaction that will serialize to the RPC representation of a transaction
type RPCTransaction struct {
- BlockHash *common.Hash `json:"blockHash"`
- BlockNumber *hexutil.Big `json:"blockNumber"`
- From common.Address `json:"from"`
- Gas hexutil.Uint64 `json:"gas"`
- GasPrice *hexutil.Big `json:"gasPrice"`
- Hash common.Hash `json:"hash"`
- Input hexutil.Bytes `json:"input"`
- Nonce hexutil.Uint64 `json:"nonce"`
- To *common.Address `json:"to"`
- TransactionIndex *hexutil.Uint64 `json:"transactionIndex"`
- Value *hexutil.Big `json:"value"`
- V *hexutil.Big `json:"v"`
- R *hexutil.Big `json:"r"`
- S *hexutil.Big `json:"s"`
+ BlockHash *common.Hash `json:"blockHash"`
+ BlockNumber *hexutil.Big `json:"blockNumber"`
+ From common.Address `json:"from"`
+ Gas hexutil.Uint64 `json:"gas"`
+ GasPrice *hexutil.Big `json:"gasPrice"`
+ Hash common.Hash `json:"hash"`
+ Input hexutil.Bytes `json:"input"`
+ Nonce hexutil.Uint64 `json:"nonce"`
+ To *common.Address `json:"to"`
+ TransactionIndex *hexutil.Uint64 `json:"transactionIndex"`
+ Value *hexutil.Big `json:"value"`
+ Type hexutil.Uint64 `json:"type"`
+ Accesses *types.AccessList `json:"accessList,omitempty"`
+ ChainID *hexutil.Big `json:"chainId,omitempty"`
+ V *hexutil.Big `json:"v"`
+ R *hexutil.Big `json:"r"`
+ S *hexutil.Big `json:"s"`
}
// newRPCTransaction returns a transaction that will serialize to the RPC
// representation, with the given location metadata set (if available).
func newRPCTransaction(tx *types.Transaction, blockHash common.Hash, blockNumber uint64, index uint64) *RPCTransaction {
- var signer types.Signer = types.FrontierSigner{}
+ // Determine the signer. For replay-protected transactions, use the most permissive
+ // signer, because we assume that signers are backwards-compatible with old
+ // transactions. For non-protected transactions, the homestead signer signer is used
+ // because the return value of ChainId is zero for those transactions.
+ var signer types.Signer
if tx.Protected() {
- signer = types.NewEIP155Signer(tx.ChainID().ToBig())
+ signer = types.LatestSignerForChainID(tx.ChainId())
+ } else {
+ signer = types.HomesteadSigner{}
}
+
from, _ := types.Sender(signer, tx)
v, r, s := tx.RawSignatureValues()
-
result := &RPCTransaction{
+ Type: hexutil.Uint64(tx.Type()),
From: from,
Gas: hexutil.Uint64(tx.Gas()),
GasPrice: (*hexutil.Big)(tx.GasPrice().ToBig()),
@@ -1188,6 +1201,11 @@ func newRPCTransaction(tx *types.Transaction, blockHash common.Hash, blockNumber
result.BlockNumber = (*hexutil.Big)(new(big.Int).SetUint64(blockNumber))
result.TransactionIndex = (*hexutil.Uint64)(&index)
}
+ if tx.Type() == types.AccessListTxType {
+ al := tx.AccessList()
+ result.Accesses = &al
+ result.ChainID = (*hexutil.Big)(tx.ChainId())
+ }
return result
}
@@ -1211,7 +1229,7 @@ func newRPCRawTransactionFromBlockIndex(b *types.Block, index uint64) hexutil.By
if index >= uint64(len(txs)) {
return nil
}
- blob, _ := rlp.EncodeToBytes(txs[index])
+ blob, _ := txs[index].MarshalBinary()
return blob
}
@@ -1229,11 +1247,15 @@ func newRPCTransactionFromBlockHash(b *types.Block, hash common.Hash) *RPCTransa
type PublicTransactionPoolAPI struct {
b Backend
nonceLock *AddrLocker
+ signer types.Signer
}
// NewPublicTransactionPoolAPI creates a new RPC service with methods specific for the transaction pool.
func NewPublicTransactionPoolAPI(b Backend, nonceLock *AddrLocker) *PublicTransactionPoolAPI {
- return &PublicTransactionPoolAPI{b, nonceLock}
+ // The signer used by the API should always be the 'latest' known one because we expect
+ // signers to be backwards-compatible with old transactions.
+ signer := types.LatestSigner(b.ChainConfig())
+ return &PublicTransactionPoolAPI{b, nonceLock, signer}
}
// GetBlockTransactionCountByNumber returns the number of transactions in the block with the given block number.
@@ -1338,7 +1360,7 @@ func (s *PublicTransactionPoolAPI) GetRawTransactionByHash(ctx context.Context,
}
}
// Serialize to RLP and return
- return rlp.EncodeToBytes(tx)
+ return tx.MarshalBinary()
}
// GetTransactionReceipt returns the transaction receipt for the given transaction hash.
@@ -1356,10 +1378,9 @@ func (s *PublicTransactionPoolAPI) GetTransactionReceipt(ctx context.Context, ha
}
receipt := receipts[index]
- var signer types.Signer = types.FrontierSigner{}
- if tx.Protected() {
- signer = types.NewEIP155Signer(tx.ChainID().ToBig())
- }
+ // Derive the sender.
+ bigblock := new(big.Int).SetUint64(blockNumber)
+ signer := types.MakeSigner(s.b.ChainConfig(), bigblock)
from, _ := types.Sender(signer, tx)
// Fill in the derived information in the logs
@@ -1386,6 +1407,7 @@ func (s *PublicTransactionPoolAPI) GetTransactionReceipt(ctx context.Context, ha
"contractAddress": nil,
"logs": receipt.Logs,
"logsBloom": receipt.Bloom,
+ "type": hexutil.Uint(tx.Type()),
}
// Assign receipt status or post state.
@@ -1429,9 +1451,13 @@ type SendTxArgs struct {
// newer name and should be preferred by clients.
Data *hexutil.Bytes `json:"data"`
Input *hexutil.Bytes `json:"input"`
+
+ // For non-legacy transactions
+ AccessList *types.AccessList `json:"accessList,omitempty"`
+ ChainID *hexutil.Big `json:"chainId,omitempty"`
}
-// setDefaults is a helper function that fills in default values for unspecified tx fields.
+// setDefaults fills in default values for unspecified tx fields.
func (args *SendTxArgs) setDefaults(ctx context.Context, b Backend) error {
if args.GasPrice == nil {
price, err := b.SuggestPrice(ctx)
@@ -1465,6 +1491,7 @@ func (args *SendTxArgs) setDefaults(ctx context.Context, b Backend) error {
return errors.New(`contract creation without any data provided`)
}
}
+
// Estimate the gas usage if necessary.
if args.Gas == nil {
// For backwards-compatibility reason, we try both input and data
@@ -1474,11 +1501,12 @@ func (args *SendTxArgs) setDefaults(ctx context.Context, b Backend) error {
input = args.Data
}
callArgs := CallArgs{
- From: &args.From, // From shouldn't be nil
- To: args.To,
- GasPrice: args.GasPrice,
- Value: args.Value,
- Data: input,
+ From: &args.From, // From shouldn't be nil
+ To: args.To,
+ GasPrice: args.GasPrice,
+ Value: args.Value,
+ Data: input,
+ AccessList: args.AccessList,
}
pendingBlockNr := rpc.BlockNumberOrHashWithNumber(rpc.PendingBlockNumber)
estimated, err := DoEstimateGas(ctx, b, callArgs, pendingBlockNr, b.RPCGasCap())
@@ -1488,9 +1516,15 @@ func (args *SendTxArgs) setDefaults(ctx context.Context, b Backend) error {
args.Gas = &estimated
log.Trace("Estimate gas usage automatically", "gas", args.Gas)
}
+ if args.ChainID == nil {
+ id := (*hexutil.Big)(b.ChainConfig().ChainID)
+ args.ChainID = id
+ }
return nil
}
+// toTransaction converts the arguments to a transaction.
+// This assumes that setDefaults has been called.
func (args *SendTxArgs) toTransaction() *types.Transaction {
var input []byte
if args.Input != nil {
@@ -1498,12 +1532,30 @@ func (args *SendTxArgs) toTransaction() *types.Transaction {
} else if args.Data != nil {
input = *args.Data
}
- value, _ := uint256.FromBig((*big.Int)(args.Value))
- gasPrice, _ := uint256.FromBig((*big.Int)(args.GasPrice))
- if args.To == nil {
- return types.NewContractCreation(uint64(*args.Nonce), value, uint64(*args.Gas), gasPrice, input)
+
+ var data types.TxData
+ if args.AccessList == nil {
+ data = &types.LegacyTx{
+ To: args.To,
+ Nonce: uint64(*args.Nonce),
+ Gas: uint64(*args.Gas),
+ GasPrice: (*big.Int)(args.GasPrice),
+ Value: (*big.Int)(args.Value),
+ Data: input,
+ }
+ } else {
+ data = &types.AccessListTx{
+ To: args.To,
+ ChainID: (*big.Int)(args.ChainID),
+ Nonce: uint64(*args.Nonce),
+ Gas: uint64(*args.Gas),
+ GasPrice: (*big.Int)(args.GasPrice),
+ Value: (*big.Int)(args.Value),
+ Data: input,
+ AccessList: *args.AccessList,
+ }
}
- return types.NewTransaction(uint64(*args.Nonce), *args.To, value, uint64(*args.Gas), gasPrice, input)
+ return types.NewTx(data)
}
// SubmitTransaction is a helper function that submits tx to txPool and logs a message.
@@ -1577,7 +1629,7 @@ func (s *PublicTransactionPoolAPI) FillTransaction(ctx context.Context, args Sen
}
// Assemble the transaction and obtain rlp
tx := args.toTransaction()
- data, err := rlp.EncodeToBytes(tx)
+ data, err := tx.MarshalBinary()
if err != nil {
return nil, err
}
@@ -1586,9 +1638,9 @@ func (s *PublicTransactionPoolAPI) FillTransaction(ctx context.Context, args Sen
// SendRawTransaction will add the signed transaction to the transaction pool.
// The sender is responsible for signing the transaction and using the correct nonce.
-func (s *PublicTransactionPoolAPI) SendRawTransaction(ctx context.Context, encodedTx hexutil.Bytes) (common.Hash, error) {
+func (s *PublicTransactionPoolAPI) SendRawTransaction(ctx context.Context, input hexutil.Bytes) (common.Hash, error) {
tx := new(types.Transaction)
- if err := rlp.DecodeBytes(encodedTx, tx); err != nil {
+ if err := tx.UnmarshalBinary(input); err != nil {
return common.Hash{}, err
}
return SubmitTransaction(ctx, s.b, tx)
@@ -1649,7 +1701,7 @@ func (s *PublicTransactionPoolAPI) SignTransaction(ctx context.Context, args Sen
if err != nil {
return nil, err
}
- data, err := rlp.EncodeToBytes(tx)
+ data, err := tx.MarshalBinary()
if err != nil {
return nil, err
}
@@ -1671,11 +1723,7 @@ func (s *PublicTransactionPoolAPI) PendingTransactions() ([]*RPCTransaction, err
}
transactions := make([]*RPCTransaction, 0, len(pending))
for _, tx := range pending {
- var signer types.Signer = types.HomesteadSigner{}
- if tx.Protected() {
- signer = types.NewEIP155Signer(tx.ChainID().ToBig())
- }
- from, _ := types.Sender(signer, tx)
+ from, _ := types.Sender(s.signer, tx)
if _, exists := accounts[from]; exists {
transactions = append(transactions, newRPCPendingTransaction(tx))
}
@@ -1712,13 +1760,9 @@ func (s *PublicTransactionPoolAPI) Resend(ctx context.Context, sendArgs SendTxAr
return common.Hash{}, err
}
for _, p := range pending {
- var signer types.Signer = types.HomesteadSigner{}
- if p.Protected() {
- signer = types.NewEIP155Signer(p.ChainID().ToBig())
- }
- wantSigHash := signer.Hash(matchTx)
-
- if pFrom, err := types.Sender(signer, p); err == nil && pFrom == sendArgs.From && signer.Hash(p) == wantSigHash {
+ wantSigHash := s.signer.Hash(matchTx)
+ pFrom, err := types.Sender(s.signer, p)
+ if err == nil && pFrom == sendArgs.From && s.signer.Hash(p) == wantSigHash {
// Match. Re-sign and send the transaction.
if gasPrice != nil && (*big.Int)(gasPrice).Sign() != 0 {
sendArgs.GasPrice = gasPrice
@@ -1736,7 +1780,6 @@ func (s *PublicTransactionPoolAPI) Resend(ctx context.Context, sendArgs SendTxAr
return signedTx.Hash(), nil
}
}
-
return common.Hash{}, fmt.Errorf("transaction %#x not found", matchTx.Hash())
}
diff --git a/internal/guide/guide_test.go b/internal/guide/guide_test.go
index 99adc3c8e2..7bc2df4d4e 100644
--- a/internal/guide/guide_test.go
+++ b/internal/guide/guide_test.go
@@ -75,7 +75,8 @@ func TestAccountManagement(t *testing.T) {
if err != nil {
t.Fatalf("Failed to create signer account: %v", err)
}
- tx, chain := new(types.Transaction), big.NewInt(1)
+ tx := types.NewTransaction(0, common.Address{}, big.NewInt(0), 0, big.NewInt(0), nil)
+ chain := big.NewInt(1)
// Sign a transaction with a single authorization
if _, err := ks.SignTxWithPassphrase(signer, "Signer password", tx, chain); err != nil {
diff --git a/miner/worker.go b/miner/worker.go
index b3820f9a0f..7d6ae8c733 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -685,7 +685,7 @@ func (w *worker) makeCurrent(ctx consensus.Cancel, parent *types.Block, header *
}
env := &environment{
- signer: types.NewEIP155Signer(w.chainConfig.ChainID),
+ signer: types.MakeSigner(w.chainConfig, header.Number),
state: stateV,
tds: tds,
ancestors: mapset.NewSet(),
@@ -869,6 +869,11 @@ func (w *worker) commitTransactions(txs *types.TransactionsByPriceAndNonce, coin
w.current.tcount++
txs.Shift()
+ case errors.Is(err, core.ErrTxTypeNotSupported):
+ // Pop the unsupported transaction without shifting in the next from the account
+ log.Trace("Skipping unsupported transaction type", "sender", from, "type", tx.Type())
+ txs.Pop()
+
default:
// Strange error, discard the transaction and get the next in line (note, the
// nonce-too-high clause will prevent us from executing in vain).
diff --git a/miner/worker_test.go b/miner/worker_test.go
index 2a71b8a0d9..b2a55edb45 100644
--- a/miner/worker_test.go
+++ b/miner/worker_test.go
@@ -83,10 +83,25 @@ func init() {
Period: 10,
Epoch: 30000,
}
- tx1, _ := types.SignTx(types.NewTransaction(0, testUserAddress, uint256.NewInt().SetUint64(1000), params.TxGas, nil, nil), types.HomesteadSigner{}, testBankKey)
+
+ signer := types.LatestSigner(params.TestChainConfig)
+ tx1 := types.MustSignNewTx(testBankKey, signer, &types.AccessListTx{
+ ChainID: params.TestChainConfig.ChainID,
+ Nonce: 0,
+ To: &testUserAddress,
+ Value: big.NewInt(1000),
+ Gas: params.TxGas,
+ })
pendingTxs = append(pendingTxs, tx1)
- tx2, _ := types.SignTx(types.NewTransaction(1, testUserAddress, uint256.NewInt().SetUint64(1000), params.TxGas, nil, nil), types.HomesteadSigner{}, testBankKey)
+
+ tx2 := types.MustSignNewTx(testBankKey, signer, &types.LegacyTx{
+ Nonce: 1,
+ To: &testUserAddress,
+ Value: big.NewInt(1000),
+ Gas: params.TxGas,
+ })
newTxs = append(newTxs, tx2)
+
rand.Seed(time.Now().UnixNano())
}
diff --git a/params/config.go b/params/config.go
index de65435a22..5fe2675a2a 100644
--- a/params/config.go
+++ b/params/config.go
@@ -215,7 +215,7 @@ var (
// YoloV3ChainConfig contains the chain parameters to run a node on the YOLOv3 test network.
YoloV3ChainConfig = &ChainConfig{
- ChainID: big.NewInt(133519467574834),
+ ChainID: new(big.Int).SetBytes([]byte("yolov3x")),
HomesteadBlock: big.NewInt(0),
DAOForkBlock: nil,
DAOForkSupport: true,
@@ -246,9 +246,9 @@ var (
//
// This configuration is intentionally not using keyed fields to force anyone
// adding flags to the config to also have to set these fields.
- AllCliqueProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, nil, nil, nil, &CliqueConfig{Period: 0, Epoch: 30000}}
+ AllCliqueProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, big.NewInt(0), nil, nil, &CliqueConfig{Period: 0, Epoch: 30000}}
- TestChainConfig = &ChainConfig{big.NewInt(1), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, nil, nil, new(EthashConfig), nil}
+ TestChainConfig = &ChainConfig{big.NewInt(1), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, big.NewInt(0), nil, new(EthashConfig), nil}
TestRules = TestChainConfig.Rules(new(big.Int))
)
diff --git a/params/protocol_params.go b/params/protocol_params.go
index ffb901ec3d..88f1a06e12 100644
--- a/params/protocol_params.go
+++ b/params/protocol_params.go
@@ -60,20 +60,23 @@ const (
JumpdestGas uint64 = 1 // Once per JUMPDEST operation.
EpochDuration uint64 = 30000 // Duration between proof-of-work epochs.
- CreateDataGas uint64 = 200 //
- CallCreateDepth uint64 = 1024 // Maximum depth of call/create stack.
- ExpGas uint64 = 10 // Once per EXP instruction
- LogGas uint64 = 375 // Per LOG* operation.
- CopyGas uint64 = 3 //
- StackLimit uint64 = 1024 // Maximum size of VM stack allowed.
- TierStepGas uint64 = 0 // Once per operation, for a selection of them.
- LogTopicGas uint64 = 375 // Multiplied by the * of the LOG*, per LOG transaction. e.g. LOG0 incurs 0 * c_txLogTopicGas, LOG4 incurs 4 * c_txLogTopicGas.
- CreateGas uint64 = 32000 // Once per CREATE operation & contract-creation transaction.
- Create2Gas uint64 = 32000 // Once per CREATE2 operation
- SelfdestructRefundGas uint64 = 24000 // Refunded following a selfdestruct operation.
- MemoryGas uint64 = 3 // Times the address of the (highest referenced byte in memory + 1). NOTE: referencing happens on read, write and in instructions such as RETURN and CALL.
- TxDataNonZeroGasFrontier uint64 = 68 // Per byte of data attached to a transaction that is not equal to zero. NOTE: Not payable on data of calls between transactions.
- TxDataNonZeroGasEIP2028 uint64 = 16 // Per byte of non zero data attached to a transaction after EIP 2028 (part in Istanbul)
+ CreateDataGas uint64 = 200 //
+ CallCreateDepth uint64 = 1024 // Maximum depth of call/create stack.
+ ExpGas uint64 = 10 // Once per EXP instruction
+ LogGas uint64 = 375 // Per LOG* operation.
+ CopyGas uint64 = 3 //
+ StackLimit uint64 = 1024 // Maximum size of VM stack allowed.
+ TierStepGas uint64 = 0 // Once per operation, for a selection of them.
+ LogTopicGas uint64 = 375 // Multiplied by the * of the LOG*, per LOG transaction. e.g. LOG0 incurs 0 * c_txLogTopicGas, LOG4 incurs 4 * c_txLogTopicGas.
+ CreateGas uint64 = 32000 // Once per CREATE operation & contract-creation transaction.
+ Create2Gas uint64 = 32000 // Once per CREATE2 operation
+ SelfdestructRefundGas uint64 = 24000 // Refunded following a selfdestruct operation.
+ MemoryGas uint64 = 3 // Times the address of the (highest referenced byte in memory + 1). NOTE: referencing happens on read, write and in instructions such as RETURN and CALL.
+
+ TxDataNonZeroGasFrontier uint64 = 68 // Per byte of data attached to a transaction that is not equal to zero. NOTE: Not payable on data of calls between transactions.
+ TxDataNonZeroGasEIP2028 uint64 = 16 // Per byte of non zero data attached to a transaction after EIP 2028 (part in Istanbul)
+ TxAccessListAddressGas uint64 = 2400 // Per address specified in EIP 2930 access list
+ TxAccessListStorageKeyGas uint64 = 1900 // Per storage key specified in EIP 2930 access list
// These have been changed during the course of the chain
CallGasFrontier uint64 = 40 // Once per CALL operation & message call transaction.
diff --git a/signer/core/api.go b/signer/core/api.go
index 4f51e6c69c..fcbf1ba200 100644
--- a/signer/core/api.go
+++ b/signer/core/api.go
@@ -576,11 +576,11 @@ func (api *SignerAPI) SignTransaction(ctx context.Context, args SendTxArgs, meth
return nil, err
}
- rlpdata, err := rlp.EncodeToBytes(signedTx)
+ data, err := signedTx.MarshalBinary()
if err != nil {
return nil, err
}
- response := ethapi.SignTransactionResult{Raw: rlpdata, Tx: signedTx}
+ response := ethapi.SignTransactionResult{Raw: data, Tx: signedTx}
// Finally, send the signed tx to the UI
api.UI.OnApprovedTx(response)
diff --git a/tests/state_test_util.go b/tests/state_test_util.go
index a73d42951a..eaa3f565c5 100644
--- a/tests/state_test_util.go
+++ b/tests/state_test_util.go
@@ -195,27 +195,21 @@ func (t *StateTest) RunNoVerify(ctx context.Context, subtest StateSubtest, vmcon
if err != nil {
return nil, nil, common.Hash{}, err
}
+
+ // Prepare the EVM.
txContext := core.NewEVMTxContext(msg)
context := core.NewEVMBlockContext(block.Header(), nil, &t.json.Env.Coinbase)
context.GetHash = vmTestBlockHash
evm := vm.NewEVM(context, txContext, statedb, config, vmconfig)
- if config.IsYoloV3(context.BlockNumber) {
- statedb.AddAddressToAccessList(msg.From())
- if dst := msg.To(); dst != nil {
- statedb.AddAddressToAccessList(*dst)
- // If it's a create-tx, the destination will be added inside evm.create
- }
- for _, addr := range evm.ActivePrecompiles() {
- statedb.AddAddressToAccessList(addr)
- }
- }
+ // Execute the message.
+ snapshot := statedb.Snapshot()
gaspool := new(core.GasPool)
gaspool.AddGas(block.GasLimit())
- snapshot := statedb.Snapshot()
if _, err = core.ApplyMessage(evm, msg, gaspool, true /* refunds */, false /* gasBailout */); err != nil {
statedb.RevertToSnapshot(snapshot)
}
+
// Commit block
if err = statedb.FinalizeTx(ctx, tds.TrieStateWriter()); err != nil {
return nil, nil, common.Hash{}, err
@@ -337,7 +331,7 @@ func (tx *stTransaction) toMessage(ps stPostState) (core.Message, error) {
return nil, fmt.Errorf("invalid tx data %q", dataHex)
}
- msg := types.NewMessage(from, to, tx.Nonce, value, gasLimit, tx.GasPrice, data, true)
+ msg := types.NewMessage(from, to, tx.Nonce, value, gasLimit, tx.GasPrice, data, nil, true)
return msg, nil
}
diff --git a/tests/transaction_test_util.go b/tests/transaction_test_util.go
index a721e8aa45..f15d561c78 100644
--- a/tests/transaction_test_util.go
+++ b/tests/transaction_test_util.go
@@ -55,7 +55,7 @@ func (tt *TransactionTest) Run(config *params.ChainConfig) error {
return nil, nil, err
}
// Intrinsic gas
- requiredGas, err := core.IntrinsicGas(tx.Data(), tx.To() == nil, isHomestead, isIstanbul)
+ requiredGas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil, isHomestead, isIstanbul)
if err != nil {
return nil, nil, err
}
diff --git a/turbo/stages/blockchain_test.go b/turbo/stages/blockchain_test.go
index 462e34eabf..873cac7cef 100644
--- a/turbo/stages/blockchain_test.go
+++ b/turbo/stages/blockchain_test.go
@@ -695,7 +695,7 @@ func TestFastVsFullChains(t *testing.T) {
Alloc: core.GenesisAlloc{address: {Balance: funds}},
}
genesis = gspec.MustCommit(gendb)
- signer = types.NewEIP155Signer(gspec.Config.ChainID)
+ signer = types.LatestSigner(gspec.Config)
)
blocks, receipts, err1 := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), gendb, 1024, func(i int, block *core.BlockGen) {
block.SetCoinbase(common.Address{0x00})
@@ -979,7 +979,7 @@ func TestChainTxReorgs(t *testing.T) {
},
}
genesis = gspec.MustCommit(db)
- signer = types.NewEIP155Signer(gspec.Config.ChainID)
+ signer = types.LatestSigner(gspec.Config)
)
genesisDb := db.MemCopy()
@@ -1095,7 +1095,7 @@ func TestLogReorgs(t *testing.T) {
code = common.Hex2Bytes("60606040525b7f24ec1d3ff24c2f6ff210738839dbc339cd45a5294d85c79361016243157aae7b60405180905060405180910390a15b600a8060416000396000f360606040526008565b00")
gspec = &core.Genesis{Config: params.TestChainConfig, Alloc: core.GenesisAlloc{addr1: {Balance: big.NewInt(10000000000000)}}}
genesis = gspec.MustCommit(db)
- signer = types.NewEIP155Signer(gspec.Config.ChainID)
+ signer = types.LatestSigner(gspec.Config)
)
genesisDB := db.MemCopy()
defer genesisDB.Close()
@@ -1172,7 +1172,7 @@ func TestLogRebirth(t *testing.T) {
addr1 = crypto.PubkeyToAddress(key1.PublicKey)
gspec = &core.Genesis{Config: params.TestChainConfig, Alloc: core.GenesisAlloc{addr1: {Balance: big.NewInt(10000000000000)}}}
genesis = gspec.MustCommit(db)
- signer = types.NewEIP155Signer(gspec.Config.ChainID)
+ signer = types.LatestSigner(gspec.Config)
engine = ethash.NewFaker()
blockchain, _ = core.NewBlockChain(db, nil, gspec.Config, engine, vm.Config{}, nil, txCacher)
)
@@ -1254,9 +1254,9 @@ func TestSideLogRebirth(t *testing.T) {
var (
key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
addr1 = crypto.PubkeyToAddress(key1.PublicKey)
- gspec = &core.Genesis{Config: params.TestChainConfig, Alloc: core.GenesisAlloc{addr1: {Balance: big.NewInt(10000000000000)}}}
- genesis = gspec.MustCommit(db)
- signer = types.NewEIP155Signer(gspec.Config.ChainID)
+ gspec = &core.Genesis{Config: params.TestChainConfig, Alloc: GenesisAlloc{addr1: {Balance: big.NewInt(10000000000000)}}}
+ genesis = gspec.MustCommit(db)
+ signer = types.LatestSigner(gspec.Config)
)
txCacher := core.NewTxSenderCacher(1)
@@ -1336,7 +1336,7 @@ func TestReorgSideEvent(t *testing.T) {
Alloc: core.GenesisAlloc{addr1: {Balance: big.NewInt(10000000000000)}},
}
genesis = gspec.MustCommit(db)
- signer = types.NewEIP155Signer(gspec.Config.ChainID)
+ signer = types.LatestSigner(gspec.Config)
)
genesisDb := db.MemCopy()
defer genesisDb.Close()
@@ -1515,7 +1515,7 @@ func TestEIP155Transition(t *testing.T) {
}
block.AddTx(tx)
- tx, err = basicTx(types.NewEIP155Signer(gspec.Config.ChainID))
+ tx, err = basicTx(types.LatestSigner(gspec.Config))
if err != nil {
t.Fatal(err)
}
@@ -1527,7 +1527,7 @@ func TestEIP155Transition(t *testing.T) {
}
block.AddTx(tx)
- tx, err = basicTx(types.NewEIP155Signer(gspec.Config.ChainID))
+ tx, err = basicTx(types.LatestSigner(gspec.Config))
if err != nil {
t.Fatal(err)
}
@@ -1568,7 +1568,7 @@ func TestEIP155Transition(t *testing.T) {
}
)
if i == 0 {
- tx, err = basicTx(types.NewEIP155Signer(big.NewInt(2)))
+ tx, err = basicTx(types.LatestSigner(config))
if err != nil {
t.Fatal(err)
}
@@ -1774,7 +1774,7 @@ func TestEIP161AccountRemoval(t *testing.T) {
var (
tx *types.Transaction
err error
- signer = types.NewEIP155Signer(gspec.Config.ChainID)
+ signer = types.LatestSigner(gspec.Config)
)
switch i {
case 0:
@@ -3400,3 +3400,81 @@ func TestInitThenFailCreateContract(t *testing.T) {
}
}
}
+
+// TestEIP2718Transition tests that an EIP-2718 transaction will be accepted
+// after the fork block has passed. This is verified by sending an EIP-2930
+// access list transaction, which specifies a single slot access, and then
+// checking that the gas usage of a hot SLOAD and a cold SLOAD are calculated
+// correctly.
+func TestEIP2718Transition(t *testing.T) {
+ var (
+ aa = common.HexToAddress("0x000000000000000000000000000000000000aaaa")
+
+ // Generate a canonical chain to act as the main dataset
+ engine = ethash.NewFaker()
+ db = rawdb.NewMemoryDatabase()
+
+ // A sender who makes transactions, has some funds
+ key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+ address = crypto.PubkeyToAddress(key.PublicKey)
+ funds = big.NewInt(1000000000)
+ gspec = &Genesis{
+ Config: params.YoloV3ChainConfig,
+ Alloc: GenesisAlloc{
+ address: {Balance: funds},
+ // The address 0xAAAA sloads 0x00 and 0x01
+ aa: {
+ Code: []byte{
+ byte(vm.PC),
+ byte(vm.PC),
+ byte(vm.SLOAD),
+ byte(vm.SLOAD),
+ },
+ Nonce: 0,
+ Balance: big.NewInt(0),
+ },
+ },
+ }
+ genesis = gspec.MustCommit(db)
+ )
+
+ blocks, _ := GenerateChain(gspec.Config, genesis, engine, db, 1, func(i int, b *BlockGen) {
+ b.SetCoinbase(common.Address{1})
+
+ // One transaction to 0xAAAA
+ signer := types.LatestSigner(gspec.Config)
+ tx, _ := types.SignNewTx(key, signer, &types.AccessListTx{
+ ChainID: gspec.Config.ChainID,
+ Nonce: 0,
+ To: &aa,
+ Gas: 30000,
+ GasPrice: big.NewInt(1),
+ AccessList: types.AccessList{{
+ Address: aa,
+ StorageKeys: []common.Hash{{0}},
+ }},
+ })
+ b.AddTx(tx)
+ })
+
+ // Import the canonical chain
+ diskdb := rawdb.NewMemoryDatabase()
+ gspec.MustCommit(diskdb)
+
+ chain, err := NewBlockChain(diskdb, nil, gspec.Config, engine, vm.Config{}, nil, nil)
+ if err != nil {
+ t.Fatalf("failed to create tester chain: %v", err)
+ }
+ if n, err := chain.InsertChain(blocks); err != nil {
+ t.Fatalf("block %d: failed to insert into chain: %v", n, err)
+ }
+
+ block := chain.GetBlockByNumber(1)
+
+ // Expected gas is intrinsic + 2 * pc + hot load + cold load, since only one load is in the access list
+ expected := params.TxGas + params.TxAccessListAddressGas + params.TxAccessListStorageKeyGas + vm.GasQuickStep*2 + vm.WarmStorageReadCostEIP2929 + vm.ColdSloadCostEIP2929
+ if block.GasUsed() != expected {
+ t.Fatalf("incorrect amount of gas spent: expected %d, got %d", expected, block.GasUsed())
+
+ }
+}
--
GitLab