op-geth
+4751
-332
This is an overview of the changes in op-geth,
a fork of go-ethereum, part of the OP-stack.
The OP-stack architecture is modular, following the Consensus/Execution split of post-Merge Ethereum L1:
op-nodeimplements most rollup-specific functionality as Consensus-Layer, similar to a L1 beacon-node.op-gethimplements the Execution-Layer, with minimal changes for a secure Ethereum-equivalent application environment.
Related op-stack specifications:
Core modifications
+822
-57
State-transition modifications
+515
-21
Deposit Transaction type
+197
-0
The Bedrock upgrade introduces a Deposit transaction-type (0x7E) to enable both users and the
rollup system itself to change the L2 state based on L1 events and system rules as
specified.
diff --git go-ethereum/core/types/deposit_tx.go op-geth/core/types/deposit_tx.go
new file mode 100644
index 0000000000000000000000000000000000000000..4131ee7af037275dcacd795baab4e0d55a1acb07
--- /dev/null
+++ op-geth/core/types/deposit_tx.go
@@ -0,0 +1,103 @@
+// Copyright 2021 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package types
+
+import (
+ "bytes"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/rlp"
+)
+
+const DepositTxType = 0x7E
+
+type DepositTx struct {
+ // SourceHash uniquely identifies the source of the deposit
+ SourceHash common.Hash
+ // From is exposed through the types.Signer, not through TxData
+ From common.Address
+ // nil means contract creation
+ To *common.Address `rlp:"nil"`
+ // Mint is minted on L2, locked on L1, nil if no minting.
+ Mint *big.Int `rlp:"nil"`
+ // Value is transferred from L2 balance, executed after Mint (if any)
+ Value *big.Int
+ // gas limit
+ Gas uint64
+ // Field indicating if this transaction is exempt from the L2 gas limit.
+ IsSystemTransaction bool
+ // Normal Tx data
+ Data []byte
+}
+
+// copy creates a deep copy of the transaction data and initializes all fields.
+func (tx *DepositTx) copy() TxData {
+ cpy := &DepositTx{
+ SourceHash: tx.SourceHash,
+ From: tx.From,
+ To: copyAddressPtr(tx.To),
+ Mint: nil,
+ Value: new(big.Int),
+ Gas: tx.Gas,
+ IsSystemTransaction: tx.IsSystemTransaction,
+ Data: common.CopyBytes(tx.Data),
+ }
+ if tx.Mint != nil {
+ cpy.Mint = new(big.Int).Set(tx.Mint)
+ }
+ if tx.Value != nil {
+ cpy.Value.Set(tx.Value)
+ }
+ return cpy
+}
+
+// accessors for innerTx.
+func (tx *DepositTx) txType() byte { return DepositTxType }
+func (tx *DepositTx) chainID() *big.Int { return common.Big0 }
+func (tx *DepositTx) accessList() AccessList { return nil }
+func (tx *DepositTx) data() []byte { return tx.Data }
+func (tx *DepositTx) gas() uint64 { return tx.Gas }
+func (tx *DepositTx) gasFeeCap() *big.Int { return new(big.Int) }
+func (tx *DepositTx) gasTipCap() *big.Int { return new(big.Int) }
+func (tx *DepositTx) gasPrice() *big.Int { return new(big.Int) }
+func (tx *DepositTx) value() *big.Int { return tx.Value }
+func (tx *DepositTx) nonce() uint64 { return 0 }
+func (tx *DepositTx) to() *common.Address { return tx.To }
+func (tx *DepositTx) isSystemTx() bool { return tx.IsSystemTransaction }
+
+func (tx *DepositTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int {
+ return dst.Set(new(big.Int))
+}
+
+func (tx *DepositTx) effectiveNonce() *uint64 { return nil }
+
+func (tx *DepositTx) rawSignatureValues() (v, r, s *big.Int) {
+ return common.Big0, common.Big0, common.Big0
+}
+
+func (tx *DepositTx) setSignatureValues(chainID, v, r, s *big.Int) {
+ // this is a noop for deposit transactions
+}
+
+func (tx *DepositTx) encode(b *bytes.Buffer) error {
+ return rlp.Encode(b, tx)
+}
+
+func (tx *DepositTx) decode(input []byte) error {
+ return rlp.DecodeBytes(input, tx)
+}
diff --git go-ethereum/core/types/transaction_marshalling.go op-geth/core/types/transaction_marshalling.go
index e5d71a85d6b1c693ea7efe5235c554d8a4829f89..b15ac26c5da9f21945b4d0d44d46f15a93195d74 100644
--- go-ethereum/core/types/transaction_marshalling.go
+++ op-geth/core/types/transaction_marshalling.go
@@ -19,10 +19,12 @@
import (
"encoding/json"
"errors"
+ "io"
"math/big"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/rlp"
"github.com/holiman/uint256"
)
@@ -46,6 +48,12 @@ V *hexutil.Big `json:"v"`
R *hexutil.Big `json:"r"`
S *hexutil.Big `json:"s"`
YParity *hexutil.Uint64 `json:"yParity,omitempty"`
+
+ // Deposit transaction fields
+ SourceHash *common.Hash `json:"sourceHash,omitempty"`
+ From *common.Address `json:"from,omitempty"`
+ Mint *hexutil.Big `json:"mint,omitempty"`
+ IsSystemTx *bool `json:"isSystemTx,omitempty"`
// Only used for encoding:
Hash common.Hash `json:"hash"`
@@ -142,6 +150,18 @@ enc.R = (*hexutil.Big)(itx.R.ToBig())
enc.S = (*hexutil.Big)(itx.S.ToBig())
yparity := itx.V.Uint64()
enc.YParity = (*hexutil.Uint64)(&yparity)
+ case *DepositTx:
+ enc.Gas = (*hexutil.Uint64)(&itx.Gas)
+ enc.Value = (*hexutil.Big)(itx.Value)
+ enc.Input = (*hexutil.Bytes)(&itx.Data)
+ enc.To = tx.To()
+ enc.SourceHash = &itx.SourceHash
+ enc.From = &itx.From
+ if itx.Mint != nil {
+ enc.Mint = (*hexutil.Big)(itx.Mint)
+ }
+ enc.IsSystemTx = &itx.IsSystemTransaction
+ // other fields will show up as null.
}
return json.Marshal(&enc)
}
@@ -404,6 +424,54 @@ return err
}
}
+ case DepositTxType:
+ if dec.AccessList != nil || dec.MaxFeePerGas != nil ||
+ dec.MaxPriorityFeePerGas != nil {
+ return errors.New("unexpected field(s) in deposit transaction")
+ }
+ if dec.GasPrice != nil && dec.GasPrice.ToInt().Cmp(common.Big0) != 0 {
+ return errors.New("deposit transaction GasPrice must be 0")
+ }
+ if (dec.V != nil && dec.V.ToInt().Cmp(common.Big0) != 0) ||
+ (dec.R != nil && dec.R.ToInt().Cmp(common.Big0) != 0) ||
+ (dec.S != nil && dec.S.ToInt().Cmp(common.Big0) != 0) {
+ return errors.New("deposit transaction signature must be 0 or unset")
+ }
+ var itx DepositTx
+ inner = &itx
+ if dec.To != nil {
+ itx.To = dec.To
+ }
+ if dec.Gas == nil {
+ return errors.New("missing required field 'gas' for txdata")
+ }
+ itx.Gas = uint64(*dec.Gas)
+ if dec.Value == nil {
+ return errors.New("missing required field 'value' in transaction")
+ }
+ itx.Value = (*big.Int)(dec.Value)
+ // mint may be omitted or nil if there is nothing to mint.
+ itx.Mint = (*big.Int)(dec.Mint)
+ if dec.Input == nil {
+ return errors.New("missing required field 'input' in transaction")
+ }
+ itx.Data = *dec.Input
+ if dec.From == nil {
+ return errors.New("missing required field 'from' in transaction")
+ }
+ itx.From = *dec.From
+ if dec.SourceHash == nil {
+ return errors.New("missing required field 'sourceHash' in transaction")
+ }
+ itx.SourceHash = *dec.SourceHash
+ // IsSystemTx may be omitted. Defaults to false.
+ if dec.IsSystemTx != nil {
+ itx.IsSystemTransaction = *dec.IsSystemTx
+ }
+
+ if dec.Nonce != nil {
+ inner = &depositTxWithNonce{DepositTx: itx, EffectiveNonce: uint64(*dec.Nonce)}
+ }
default:
return ErrTxTypeNotSupported
}
@@ -414,3 +482,15 @@
// TODO: check hash here?
return nil
}
+
+type depositTxWithNonce struct {
+ DepositTx
+ EffectiveNonce uint64
+}
+
+// EncodeRLP ensures that RLP encoding this transaction excludes the nonce. Otherwise, the tx Hash would change
+func (tx *depositTxWithNonce) EncodeRLP(w io.Writer) error {
+ return rlp.Encode(w, tx.DepositTx)
+}
+
+func (tx *depositTxWithNonce) effectiveNonce() *uint64 { return &tx.EffectiveNonce }
diff --git go-ethereum/core/types/transaction_signing.go op-geth/core/types/transaction_signing.go
index 9e26642f753db4f0b370aef0ce84f327defbf7b7..f0fb643cadb1fa53c84e5147ccb69e3019b776c0 100644
--- go-ethereum/core/types/transaction_signing.go
+++ op-geth/core/types/transaction_signing.go
@@ -256,6 +256,14 @@ return londonSigner{eip2930Signer{NewEIP155Signer(chainId)}}
}
func (s londonSigner) Sender(tx *Transaction) (common.Address, error) {
+ if tx.Type() == DepositTxType {
+ switch tx.inner.(type) {
+ case *DepositTx:
+ return tx.inner.(*DepositTx).From, nil
+ case *depositTxWithNonce:
+ return tx.inner.(*depositTxWithNonce).From, nil
+ }
+ }
if tx.Type() != DynamicFeeTxType {
return s.eip2930Signer.Sender(tx)
}
@@ -275,6 +283,9 @@ return ok && x.chainId.Cmp(s.chainId) == 0
}
func (s londonSigner) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big.Int, err error) {
+ if tx.Type() == DepositTxType {
+ return nil, nil, nil, fmt.Errorf("deposits do not have a signature")
+ }
txdata, ok := tx.inner.(*DynamicFeeTx)
if !ok {
return s.eip2930Signer.SignatureValues(tx, sig)
@@ -292,6 +303,9 @@
// Hash returns the hash to be signed by the sender.
// It does not uniquely identify the transaction.
func (s londonSigner) Hash(tx *Transaction) common.Hash {
+ if tx.Type() == DepositTxType {
+ panic("deposits cannot be signed and do not have a signing hash")
+ }
if tx.Type() != DynamicFeeTxType {
return s.eip2930Signer.Hash(tx)
}
Transaction properties
+82
-0
The Transaction type now exposes the deposit-transaction and L1-cost properties required for the rollup.
diff --git go-ethereum/core/types/transaction.go op-geth/core/types/transaction.go
index 6f83c21d8f8a1c1a30ce99c2ea9f086e53ec84fc..fc00327ea622cf3ce3f2d9de6c85612880fb856b 100644
--- go-ethereum/core/types/transaction.go
+++ op-geth/core/types/transaction.go
@@ -27,6 +27,7 @@
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/math"
"github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/rlp"
)
@@ -56,6 +57,9 @@ // caches
hash atomic.Value
size atomic.Value
from atomic.Value
+
+ // cache of RollupGasData details to compute the gas the tx takes on L1 for its share of rollup data
+ rollupGas atomic.Value
}
// NewTx creates a new transaction.
@@ -82,6 +86,7 @@ gasFeeCap() *big.Int
value() *big.Int
nonce() uint64
to() *common.Address
+ isSystemTx() bool
rawSignatureValues() (v, r, s *big.Int)
setSignatureValues(chainID, v, r, s *big.Int)
@@ -202,6 +207,8 @@ case DynamicFeeTxType:
inner = new(DynamicFeeTx)
case BlobTxType:
inner = new(BlobTx)
+ case DepositTxType:
+ inner = new(DepositTx)
default:
return nil, ErrTxTypeNotSupported
}
@@ -299,12 +306,56 @@
// Nonce returns the sender account nonce of the transaction.
func (tx *Transaction) Nonce() uint64 { return tx.inner.nonce() }
+// EffectiveNonce returns the nonce that was actually used as part of transaction execution
+// Returns nil if the effective nonce is not known
+func (tx *Transaction) EffectiveNonce() *uint64 {
+ type txWithEffectiveNonce interface {
+ effectiveNonce() *uint64
+ }
+
+ if itx, ok := tx.inner.(txWithEffectiveNonce); ok {
+ return itx.effectiveNonce()
+ }
+ nonce := tx.inner.nonce()
+ return &nonce
+}
+
// To returns the recipient address of the transaction.
// For contract-creation transactions, To returns nil.
func (tx *Transaction) To() *common.Address {
return copyAddressPtr(tx.inner.to())
}
+// SourceHash returns the hash that uniquely identifies the source of the deposit tx,
+// e.g. a user deposit event, or a L1 info deposit included in a specific L2 block height.
+// Non-deposit transactions return a zeroed hash.
+func (tx *Transaction) SourceHash() common.Hash {
+ if dep, ok := tx.inner.(*DepositTx); ok {
+ return dep.SourceHash
+ }
+ return common.Hash{}
+}
+
+// Mint returns the ETH to mint in the deposit tx.
+// This returns nil if there is nothing to mint, or if this is not a deposit tx.
+func (tx *Transaction) Mint() *big.Int {
+ if dep, ok := tx.inner.(*DepositTx); ok {
+ return dep.Mint
+ }
+ return nil
+}
+
+// IsDepositTx returns true if the transaction is a deposit tx type.
+func (tx *Transaction) IsDepositTx() bool {
+ return tx.Type() == DepositTxType
+}
+
+// IsSystemTx returns true for deposits that are system transactions. These transactions
+// are executed in an unmetered environment & do not contribute to the block gas limit.
+func (tx *Transaction) IsSystemTx() bool {
+ return tx.inner.isSystemTx()
+}
+
// Cost returns (gas * gasPrice) + (blobGas * blobGasPrice) + value.
func (tx *Transaction) Cost() *big.Int {
total := new(big.Int).Mul(tx.GasPrice(), new(big.Int).SetUint64(tx.Gas()))
@@ -315,6 +366,30 @@ total.Add(total, tx.Value())
return total
}
+// RollupDataGas is the amount of gas it takes to confirm the tx on L1 as a rollup
+func (tx *Transaction) RollupDataGas() RollupGasData {
+ if tx.Type() == DepositTxType {
+ return RollupGasData{}
+ }
+ if v := tx.rollupGas.Load(); v != nil {
+ return v.(RollupGasData)
+ }
+ data, err := tx.MarshalBinary()
+ if err != nil { // Silent error, invalid txs will not be marshalled/unmarshalled for batch submission anyway.
+ log.Error("failed to encode tx for L1 cost computation", "err", err)
+ }
+ var out RollupGasData
+ for _, byt := range data {
+ if byt == 0 {
+ out.Zeroes++
+ } else {
+ out.Ones++
+ }
+ }
+ tx.rollupGas.Store(out)
+ return out
+}
+
// 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) {
@@ -345,6 +420,9 @@ // EffectiveGasTip returns the effective miner gasTipCap for the given base fee.
// Note: if the effective gasTipCap is negative, this method returns both error
// the actual negative value, _and_ ErrGasFeeCapTooLow
func (tx *Transaction) EffectiveGasTip(baseFee *big.Int) (*big.Int, error) {
+ if tx.Type() == DepositTxType {
+ return new(big.Int), nil
+ }
if baseFee == nil {
return tx.GasTipCap(), nil
}
diff --git go-ethereum/core/types/tx_access_list.go op-geth/core/types/tx_access_list.go
index 730a77b752866afb5e6ba3d7ea8f4a5af6456d00..59880b0eabb182cd889a27b58d6c449187f4701a 100644
--- go-ethereum/core/types/tx_access_list.go
+++ op-geth/core/types/tx_access_list.go
@@ -107,6 +107,7 @@ func (tx *AccessListTx) gasFeeCap() *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) isSystemTx() bool { return false }
func (tx *AccessListTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int {
return dst.Set(tx.GasPrice)
diff --git go-ethereum/core/types/tx_dynamic_fee.go op-geth/core/types/tx_dynamic_fee.go
index 8b5b514fdec5b58fc8058e582a0a7c355e0ccba8..9c52cde57754d4826e6d673f297238ce02212657 100644
--- go-ethereum/core/types/tx_dynamic_fee.go
+++ op-geth/core/types/tx_dynamic_fee.go
@@ -96,6 +96,7 @@ func (tx *DynamicFeeTx) gasPrice() *big.Int { return tx.GasFeeCap }
func (tx *DynamicFeeTx) value() *big.Int { return tx.Value }
func (tx *DynamicFeeTx) nonce() uint64 { return tx.Nonce }
func (tx *DynamicFeeTx) to() *common.Address { return tx.To }
+func (tx *DynamicFeeTx) isSystemTx() bool { return false }
func (tx *DynamicFeeTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int {
if baseFee == nil {
diff --git go-ethereum/core/types/tx_legacy.go op-geth/core/types/tx_legacy.go
index 71025b78fc060692c1d034f84b59b4cdc8e6cf65..bcb65c39349a3a1bef78948af48a30a1e14c71ba 100644
--- go-ethereum/core/types/tx_legacy.go
+++ op-geth/core/types/tx_legacy.go
@@ -103,6 +103,7 @@ func (tx *LegacyTx) gasFeeCap() *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) isSystemTx() bool { return false }
func (tx *LegacyTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int {
return dst.Set(tx.GasPrice)
diff --git go-ethereum/core/types/tx_blob.go op-geth/core/types/tx_blob.go
index da4a9b72f17aaa1a438e0b89ce591550e76cb8d9..2f135a490e64cce4adc4d7bb91ec5bf64ac45197 100644
--- go-ethereum/core/types/tx_blob.go
+++ op-geth/core/types/tx_blob.go
@@ -161,6 +161,7 @@ func (tx *BlobTx) value() *big.Int { return tx.Value.ToBig() }
func (tx *BlobTx) nonce() uint64 { return tx.Nonce }
func (tx *BlobTx) to() *common.Address { tmp := tx.To; return &tmp }
func (tx *BlobTx) blobGas() uint64 { return params.BlobTxBlobGasPerBlob * uint64(len(tx.BlobHashes)) }
+func (tx *BlobTx) isSystemTx() bool { return false }
func (tx *BlobTx) effectiveGasPrice(dst *big.Int, baseFee *big.Int) *big.Int {
if baseFee == nil {
L1 cost computation
+111
-6
Transactions must pay an additional L1 cost based on the amount of rollup-data-gas they consume, estimated based on gas-price-oracle information and encoded tx size.”
diff --git go-ethereum/core/vm/evm.go op-geth/core/vm/evm.go
index 088b18aaa4ff8839f43ee1f11f8dd5b23215c509..de94912f21f05ffa047fc419e0391b65ce18d9f8 100644
--- go-ethereum/core/vm/evm.go
+++ op-geth/core/vm/evm.go
@@ -20,11 +20,12 @@ import (
"math/big"
"sync/atomic"
+ "github.com/holiman/uint256"
+
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/params"
- "github.com/holiman/uint256"
)
type (
@@ -65,6 +66,8 @@ // Transfer transfers ether from one account to the other
Transfer TransferFunc
// GetHash returns the hash corresponding to n
GetHash GetHashFunc
+ // L1CostFunc returns the L1 cost of the rollup message, the function may be nil, or return nil
+ L1CostFunc types.L1CostFunc
// Block information
Coinbase common.Address // Provides information for COINBASE
diff --git go-ethereum/core/evm.go op-geth/core/evm.go
index c4801dc797db51cb5b064090c6bd61ac4ca53802..b0ac3276e0ecbe3753adeaf87a6dd3efce5775e6 100644
--- go-ethereum/core/evm.go
+++ op-geth/core/evm.go
@@ -24,6 +24,7 @@ "github.com/ethereum/go-ethereum/consensus"
"github.com/ethereum/go-ethereum/consensus/misc/eip4844"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/params"
)
// ChainContext supports retrieving headers and consensus parameters from the
@@ -37,7 +38,7 @@ GetHeader(common.Hash, uint64) *types.Header
}
// NewEVMBlockContext creates a new context for use in the EVM.
-func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common.Address) vm.BlockContext {
+func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common.Address, config *params.ChainConfig, statedb types.StateGetter) vm.BlockContext {
var (
beneficiary common.Address
baseFee *big.Int
@@ -72,6 +73,7 @@ BaseFee: baseFee,
BlobBaseFee: blobBaseFee,
GasLimit: header.GasLimit,
Random: random,
+ L1CostFunc: types.NewL1CostFunc(config, statedb),
}
}
diff --git go-ethereum/core/types/rollup_l1_cost.go op-geth/core/types/rollup_l1_cost.go
new file mode 100644
index 0000000000000000000000000000000000000000..521dfc10d7a7f086456cea4d16b2a756a0dbc777
--- /dev/null
+++ op-geth/core/types/rollup_l1_cost.go
@@ -0,0 +1,83 @@
+// Copyright 2022 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"
+ "github.com/ethereum/go-ethereum/params"
+)
+
+type RollupGasData struct {
+ Zeroes, Ones uint64
+}
+
+func (r RollupGasData) DataGas(time uint64, cfg *params.ChainConfig) (gas uint64) {
+ gas = r.Zeroes * params.TxDataZeroGas
+ if cfg.IsRegolith(time) {
+ gas += r.Ones * params.TxDataNonZeroGasEIP2028
+ } else {
+ gas += (r.Ones + 68) * params.TxDataNonZeroGasEIP2028
+ }
+ return gas
+}
+
+type StateGetter interface {
+ GetState(common.Address, common.Hash) common.Hash
+}
+
+// L1CostFunc is used in the state transition to determine the cost of a rollup message.
+// Returns nil if there is no cost.
+type L1CostFunc func(blockNum uint64, blockTime uint64, dataGas RollupGasData, isDepositTx bool) *big.Int
+
+var (
+ L1BaseFeeSlot = common.BigToHash(big.NewInt(1))
+ OverheadSlot = common.BigToHash(big.NewInt(5))
+ ScalarSlot = common.BigToHash(big.NewInt(6))
+)
+
+var L1BlockAddr = common.HexToAddress("0x4200000000000000000000000000000000000015")
+
+// NewL1CostFunc returns a function used for calculating L1 fee cost.
+// This depends on the oracles because gas costs can change over time.
+// It returns nil if there is no applicable cost function.
+func NewL1CostFunc(config *params.ChainConfig, statedb StateGetter) L1CostFunc {
+ cacheBlockNum := ^uint64(0)
+ var l1BaseFee, overhead, scalar *big.Int
+ return func(blockNum uint64, blockTime uint64, dataGas RollupGasData, isDepositTx bool) *big.Int {
+ rollupDataGas := dataGas.DataGas(blockTime, config) // Only fake txs for RPC view-calls are 0.
+ if config.Optimism == nil || isDepositTx || rollupDataGas == 0 {
+ return nil
+ }
+ if blockNum != cacheBlockNum {
+ l1BaseFee = statedb.GetState(L1BlockAddr, L1BaseFeeSlot).Big()
+ overhead = statedb.GetState(L1BlockAddr, OverheadSlot).Big()
+ scalar = statedb.GetState(L1BlockAddr, ScalarSlot).Big()
+ cacheBlockNum = blockNum
+ }
+ return L1Cost(rollupDataGas, l1BaseFee, overhead, scalar)
+ }
+}
+
+func L1Cost(rollupDataGas uint64, l1BaseFee, overhead, scalar *big.Int) *big.Int {
+ l1GasUsed := new(big.Int).SetUint64(rollupDataGas)
+ l1GasUsed = l1GasUsed.Add(l1GasUsed, overhead)
+ l1Cost := l1GasUsed.Mul(l1GasUsed, l1BaseFee)
+ l1Cost = l1Cost.Mul(l1Cost, scalar)
+ return l1Cost.Div(l1Cost, big.NewInt(1_000_000))
+}
diff --git go-ethereum/core/state_processor.go op-geth/core/state_processor.go
index 9a4333f72330e26b8ab316a96f61e6e7cf9c5265..9b22e947a44c1486437330e2cbf86cf07a4cea05 100644
--- go-ethereum/core/state_processor.go
+++ op-geth/core/state_processor.go
@@ -71,8 +71,9 @@ // Mutate the block and state according to any hard-fork specs
if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 {
misc.ApplyDAOHardFork(statedb)
}
+ misc.EnsureCreate2Deployer(p.config, block.Time(), statedb)
var (
- context = NewEVMBlockContext(header, p.bc, nil)
+ context = NewEVMBlockContext(header, p.bc, nil, p.config, statedb)
vmenv = vm.NewEVM(context, vm.TxContext{}, statedb, p.config, cfg)
signer = types.MakeSigner(p.config, header.Number, header.Time)
)
@@ -109,6 +110,11 @@ // Create a new context to be used in the EVM environment.
txContext := NewEVMTxContext(msg)
evm.Reset(txContext, statedb)
+ nonce := tx.Nonce()
+ if msg.IsDepositTx && config.IsOptimismRegolith(evm.Context.Time) {
+ nonce = statedb.GetNonce(msg.From)
+ }
+
// Apply the transaction to the current state (included in the env).
result, err := ApplyMessage(evm, msg, gp)
if err != nil {
@@ -135,6 +141,17 @@ }
receipt.TxHash = tx.Hash()
receipt.GasUsed = result.UsedGas
+ if msg.IsDepositTx && config.IsOptimismRegolith(evm.Context.Time) {
+ // The actual nonce for deposit transactions is only recorded from Regolith onwards and
+ // otherwise must be nil.
+ receipt.DepositNonce = &nonce
+ // The DepositReceiptVersion for deposit transactions is only recorded from Canyon onwards
+ // and otherwise must be nil.
+ if config.IsOptimismCanyon(evm.Context.Time) {
+ receipt.DepositReceiptVersion = new(uint64)
+ *receipt.DepositReceiptVersion = types.CanyonDepositReceiptVersion
+ }
+ }
if tx.Type() == types.BlobTxType {
receipt.BlobGasUsed = uint64(len(tx.BlobHashes()) * params.BlobTxBlobGasPerBlob)
receipt.BlobGasPrice = evm.Context.BlobBaseFee
@@ -142,7 +159,7 @@ }
// 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())
+ receipt.ContractAddress = crypto.CreateAddress(evm.TxContext.Origin, nonce)
}
// Set the receipt logs and create the bloom filter.
@@ -164,7 +181,7 @@ if err != nil {
return nil, err
}
// Create a new context to be used in the EVM environment
- blockContext := NewEVMBlockContext(header, bc, author)
+ blockContext := NewEVMBlockContext(header, bc, author, config, statedb)
txContext := NewEVMTxContext(msg)
vmenv := vm.NewEVM(blockContext, txContext, statedb, config, cfg)
return applyTransaction(msg, config, gp, statedb, header.Number, header.Hash(), tx, usedGas, vmenv)
diff --git go-ethereum/core/state_prefetcher.go op-geth/core/state_prefetcher.go
index ff867309de302b90dc3e071e97cbe3705d34c970..bb6835202b9758e49611f8da677ddee3edc346f1 100644
--- go-ethereum/core/state_prefetcher.go
+++ op-geth/core/state_prefetcher.go
@@ -51,7 +51,7 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, cfg vm.Config, interrupt *atomic.Bool) {
var (
header = block.Header()
gaspool = new(GasPool).AddGas(block.GasLimit())
- blockContext = NewEVMBlockContext(header, p.bc, nil)
+ blockContext = NewEVMBlockContext(header, p.bc, nil, p.config, statedb)
evm = vm.NewEVM(blockContext, vm.TxContext{}, statedb, p.config, cfg)
signer = types.MakeSigner(p.config, header.Number, header.Time)
)
Transaction processing
+110
-9
Deposit transactions have special processing rules: gas is pre-paid on L1, and deposits with EVM-failure are included with rolled back changes (except mint). For regular transactions, at the end of the transition, the 1559 burn and L1 cost are routed to vaults.
diff --git go-ethereum/core/state_transition.go op-geth/core/state_transition.go
index 612fdd781379b4273635ecd0218c79bf7e62b8d3..1a555b4c2f0d5026dd0f1619933f2dc403981995 100644
--- go-ethereum/core/state_transition.go
+++ op-geth/core/state_transition.go
@@ -143,20 +143,30 @@ // When SkipAccountChecks is true, the message nonce is not checked against the
// account nonce in state. It also disables checking that the sender is an EOA.
// This field will be set to true for operations like RPC eth_call.
SkipAccountChecks bool
+
+ IsSystemTx bool // IsSystemTx indicates the message, if also a deposit, does not emit gas usage.
+ IsDepositTx bool // IsDepositTx indicates the message is force-included and can persist a mint.
+ Mint *big.Int // Mint is the amount to mint before EVM processing, or nil if there is no minting.
+ RollupDataGas types.RollupGasData // RollupDataGas indicates the rollup cost of the message, 0 if not a rollup or no cost.
}
// TransactionToMessage converts a transaction into a Message.
func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int) (*Message, error) {
msg := &Message{
- Nonce: tx.Nonce(),
- GasLimit: tx.Gas(),
- GasPrice: new(big.Int).Set(tx.GasPrice()),
- GasFeeCap: new(big.Int).Set(tx.GasFeeCap()),
- GasTipCap: new(big.Int).Set(tx.GasTipCap()),
- To: tx.To(),
- Value: tx.Value(),
- Data: tx.Data(),
- AccessList: tx.AccessList(),
+ Nonce: tx.Nonce(),
+ GasLimit: tx.Gas(),
+ GasPrice: new(big.Int).Set(tx.GasPrice()),
+ GasFeeCap: new(big.Int).Set(tx.GasFeeCap()),
+ GasTipCap: new(big.Int).Set(tx.GasTipCap()),
+ To: tx.To(),
+ Value: tx.Value(),
+ Data: tx.Data(),
+ AccessList: tx.AccessList(),
+ IsSystemTx: tx.IsSystemTx(),
+ IsDepositTx: tx.IsDepositTx(),
+ Mint: tx.Mint(),
+ RollupDataGas: tx.RollupDataGas(),
+
SkipAccountChecks: false,
BlobHashes: tx.BlobHashes(),
BlobGasFeeCap: tx.BlobGasFeeCap(),
@@ -233,11 +243,21 @@
func (st *StateTransition) buyGas() error {
mgval := new(big.Int).SetUint64(st.msg.GasLimit)
mgval = mgval.Mul(mgval, st.msg.GasPrice)
+ var l1Cost *big.Int
+ if st.evm.Context.L1CostFunc != nil && !st.msg.SkipAccountChecks {
+ l1Cost = st.evm.Context.L1CostFunc(st.evm.Context.BlockNumber.Uint64(), st.evm.Context.Time, st.msg.RollupDataGas, st.msg.IsDepositTx)
+ }
+ if l1Cost != nil {
+ mgval = mgval.Add(mgval, l1Cost)
+ }
balanceCheck := new(big.Int).Set(mgval)
if st.msg.GasFeeCap != nil {
balanceCheck.SetUint64(st.msg.GasLimit)
balanceCheck = balanceCheck.Mul(balanceCheck, st.msg.GasFeeCap)
balanceCheck.Add(balanceCheck, st.msg.Value)
+ if l1Cost != nil {
+ balanceCheck.Add(balanceCheck, l1Cost)
+ }
}
if st.evm.ChainConfig().IsCancun(st.evm.Context.BlockNumber, st.evm.Context.Time) {
if blobGas := st.blobGasUsed(); blobGas > 0 {
@@ -265,6 +285,21 @@ return nil
}
func (st *StateTransition) preCheck() error {
+ if st.msg.IsDepositTx {
+ // No fee fields to check, no nonce to check, and no need to check if EOA (L1 already verified it for us)
+ // Gas is free, but no refunds!
+ st.initialGas = st.msg.GasLimit
+ st.gasRemaining += st.msg.GasLimit // Add gas here in order to be able to execute calls.
+ // Don't touch the gas pool for system transactions
+ if st.msg.IsSystemTx {
+ if st.evm.ChainConfig().IsOptimismRegolith(st.evm.Context.Time) {
+ return fmt.Errorf("%w: address %v", ErrSystemTxNotSupported,
+ st.msg.From.Hex())
+ }
+ return nil
+ }
+ return st.gp.SubGas(st.msg.GasLimit) // gas used by deposits may not be used by other txs
+ }
// Only check transactions that are not fake
msg := st.msg
if !msg.SkipAccountChecks {
@@ -353,6 +388,37 @@ //
// However if any consensus issue encountered, return the error directly with
// nil evm execution result.
func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
+ if mint := st.msg.Mint; mint != nil {
+ st.state.AddBalance(st.msg.From, mint)
+ }
+ snap := st.state.Snapshot()
+
+ result, err := st.innerTransitionDb()
+ // Failed deposits must still be included. Unless we cannot produce the block at all due to the gas limit.
+ // On deposit failure, we rewind any state changes from after the minting, and increment the nonce.
+ if err != nil && err != ErrGasLimitReached && st.msg.IsDepositTx {
+ st.state.RevertToSnapshot(snap)
+ // Even though we revert the state changes, always increment the nonce for the next deposit transaction
+ st.state.SetNonce(st.msg.From, st.state.GetNonce(st.msg.From)+1)
+ // Record deposits as using all their gas (matches the gas pool)
+ // System Transactions are special & are not recorded as using any gas (anywhere)
+ // Regolith changes this behaviour so the actual gas used is reported.
+ // In this case the tx is invalid so is recorded as using all gas.
+ gasUsed := st.msg.GasLimit
+ if st.msg.IsSystemTx && !st.evm.ChainConfig().IsRegolith(st.evm.Context.Time) {
+ gasUsed = 0
+ }
+ result = &ExecutionResult{
+ UsedGas: gasUsed,
+ Err: fmt.Errorf("failed deposit: %w", err),
+ ReturnData: nil,
+ }
+ err = nil
+ }
+ return result, err
+}
+
+func (st *StateTransition) innerTransitionDb() (*ExecutionResult, error) {
// First check this message satisfies all consensus rules before
// applying the message. The rules include these clauses
//
@@ -419,6 +485,24 @@ st.state.SetNonce(msg.From, st.state.GetNonce(sender.Address())+1)
ret, st.gasRemaining, vmerr = st.evm.Call(sender, st.to(), msg.Data, st.gasRemaining, msg.Value)
}
+ // if deposit: skip refunds, skip tipping coinbase
+ // Regolith changes this behaviour to report the actual gasUsed instead of always reporting all gas used.
+ if st.msg.IsDepositTx && !rules.IsOptimismRegolith {
+ // Record deposits as using all their gas (matches the gas pool)
+ // System Transactions are special & are not recorded as using any gas (anywhere)
+ gasUsed := st.msg.GasLimit
+ if st.msg.IsSystemTx {
+ gasUsed = 0
+ }
+ return &ExecutionResult{
+ UsedGas: gasUsed,
+ Err: vmerr,
+ ReturnData: ret,
+ }, nil
+ }
+ // Note for deposit tx there is no ETH refunded for unused gas, but that's taken care of by the fact that gasPrice
+ // is always 0 for deposit tx. So calling refundGas will ensure the gasUsed accounting is correct without actually
+ // changing the sender's balance
if !rules.IsLondon {
// Before EIP-3529: refunds were capped to gasUsed / 2
st.refundGas(params.RefundQuotient)
@@ -426,6 +510,14 @@ } else {
// After EIP-3529: refunds are capped to gasUsed / 5
st.refundGas(params.RefundQuotientEIP3529)
}
+ if st.msg.IsDepositTx && rules.IsOptimismRegolith {
+ // Skip coinbase payments for deposit tx in Regolith
+ return &ExecutionResult{
+ UsedGas: st.gasUsed(),
+ Err: vmerr,
+ ReturnData: ret,
+ }, nil
+ }
effectiveTip := msg.GasPrice
if rules.IsLondon {
effectiveTip = cmath.BigMin(msg.GasTipCap, new(big.Int).Sub(msg.GasFeeCap, st.evm.Context.BaseFee))
@@ -439,6 +531,15 @@ } else {
fee := new(big.Int).SetUint64(st.gasUsed())
fee.Mul(fee, effectiveTip)
st.state.AddBalance(st.evm.Context.Coinbase, fee)
+ }
+
+ // Check that we are post bedrock to enable op-geth to be able to create pseudo pre-bedrock blocks (these are pre-bedrock, but don't follow l2 geth rules)
+ // Note optimismConfig will not be nil if rules.IsOptimismBedrock is true
+ if optimismConfig := st.evm.ChainConfig().Optimism; optimismConfig != nil && rules.IsOptimismBedrock {
+ st.state.AddBalance(params.OptimismBaseFeeRecipient, new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.evm.Context.BaseFee))
+ if cost := st.evm.Context.L1CostFunc(st.evm.Context.BlockNumber.Uint64(), st.evm.Context.Time, st.msg.RollupDataGas, st.msg.IsDepositTx); cost != nil {
+ st.state.AddBalance(params.OptimismL1FeeRecipient, cost)
+ }
}
return &ExecutionResult{
Core Error definitions
+3
-0
diff --git go-ethereum/core/error.go op-geth/core/error.go
index 4214ed207a91cedc38b5c4bd731d178a106d4945..43f25106807856df23218623a57220c0006df4e8 100644
--- go-ethereum/core/error.go
+++ op-geth/core/error.go
@@ -104,4 +104,7 @@
// ErrBlobFeeCapTooLow is returned if the transaction fee cap is less than the
// blob gas fee of the block.
ErrBlobFeeCapTooLow = errors.New("max fee per blob gas less than block blob gas fee")
+
+ // ErrSystemTxNotSupported is returned for any deposit tx with IsSystemTx=true after the Regolith fork
+ ErrSystemTxNotSupported = errors.New("system tx not supported")
)
Gaslimit
+9
-6
The gaslimit is free to be set by the Engine API caller, instead of enforcing adjustments of the
gaslimit in increments of 1⁄1024 of the previous gaslimit.
The gaslimit is changed (and limited) through the SystemConfig contract.
diff --git go-ethereum/consensus/misc/eip1559/eip1559.go op-geth/consensus/misc/eip1559/eip1559.go
index 84b82c4c492ec1351da2129b51b99fc50d3c6b28..a66298af692fbb7bb477847452aff5937af55c83 100644
--- go-ethereum/consensus/misc/eip1559/eip1559.go
+++ op-geth/consensus/misc/eip1559/eip1559.go
@@ -37,15 +37,17 @@ parentGasLimit := parent.GasLimit
if !config.IsLondon(parent.Number) {
parentGasLimit = parent.GasLimit * config.ElasticityMultiplier()
}
- if err := misc.VerifyGaslimit(parentGasLimit, header.GasLimit); err != nil {
- return err
+ if config.Optimism == nil { // gasLimit can adjust instantly in optimism
+ if err := misc.VerifyGaslimit(parentGasLimit, header.GasLimit); err != nil {
+ return err
+ }
}
// Verify the header is not malformed
if header.BaseFee == nil {
return errors.New("header is missing baseFee")
}
// Verify the baseFee is correct based on the parent header.
- expectedBaseFee := CalcBaseFee(config, parent)
+ expectedBaseFee := CalcBaseFee(config, parent, header.Time)
if header.BaseFee.Cmp(expectedBaseFee) != 0 {
return fmt.Errorf("invalid baseFee: have %s, want %s, parentBaseFee %s, parentGasUsed %d",
header.BaseFee, expectedBaseFee, parent.BaseFee, parent.GasUsed)
@@ -54,7 +56,8 @@ return nil
}
// CalcBaseFee calculates the basefee of the header.
-func CalcBaseFee(config *params.ChainConfig, parent *types.Header) *big.Int {
+// The time belongs to the new block to check if Canyon is activted or not
+func CalcBaseFee(config *params.ChainConfig, parent *types.Header, time uint64) *big.Int {
// If the current block is the first EIP-1559 block, return the InitialBaseFee.
if !config.IsLondon(parent.Number) {
return new(big.Int).SetUint64(params.InitialBaseFee)
@@ -77,7 +80,7 @@ // max(1, parentBaseFee * gasUsedDelta / parentGasTarget / baseFeeChangeDenominator)
num.SetUint64(parent.GasUsed - parentGasTarget)
num.Mul(num, parent.BaseFee)
num.Div(num, denom.SetUint64(parentGasTarget))
- num.Div(num, denom.SetUint64(config.BaseFeeChangeDenominator()))
+ num.Div(num, denom.SetUint64(config.BaseFeeChangeDenominator(time)))
baseFeeDelta := math.BigMax(num, common.Big1)
return num.Add(parent.BaseFee, baseFeeDelta)
@@ -87,7 +90,7 @@ // max(0, parentBaseFee * gasUsedDelta / parentGasTarget / baseFeeChangeDenominator)
num.SetUint64(parentGasTarget - parent.GasUsed)
num.Mul(num, parent.BaseFee)
num.Div(num, denom.SetUint64(parentGasTarget))
- num.Div(num, denom.SetUint64(config.BaseFeeChangeDenominator()))
+ num.Div(num, denom.SetUint64(config.BaseFeeChangeDenominator(time)))
baseFee := num.Sub(parent.BaseFee, num)
return math.BigMax(baseFee, common.Big0)
Consensus tweaks
+3
-0
The Engine API is activated at the Merge transition, with a Total Terminal Difficulty (TTD). The rollup starts post-merge, and thus sets the TTD to 0.
diff --git go-ethereum/consensus/beacon/consensus.go op-geth/consensus/beacon/consensus.go
index e856f4e6ceadb62947b39d7858e4b44282a6fd22..a7d0e58161a3465cf4a3ccad71c1f376067d3616 100644
--- go-ethereum/consensus/beacon/consensus.go
+++ op-geth/consensus/beacon/consensus.go
@@ -464,6 +464,9 @@ func IsTTDReached(chain consensus.ChainHeaderReader, parentHash common.Hash, parentNumber uint64) (bool, error) {
if chain.Config().TerminalTotalDifficulty == nil {
return false, nil
}
+ if common.Big0.Cmp(chain.Config().TerminalTotalDifficulty) == 0 { // in case TTD is reached at genesis.
+ return true, nil
+ }
td := chain.GetTd(parentHash, parentNumber)
if td == nil {
return false, consensus.ErrUnknownAncestor
Engine API modifications
+55
-1
The Engine API is extended to insert transactions into the block and optionally exclude the tx-pool, to reproduce the exact block of the sequencer from just the inputs, as derived from L1 by the rollup-node. See L2 execution engine specs.
diff --git go-ethereum/beacon/engine/types.go op-geth/beacon/engine/types.go
index 67f30d4455aa3f88d9867931918a957cae1d51b7..6f3aa006b8776fe3fb28689fdbee4247951ceed9 100644
--- go-ethereum/beacon/engine/types.go
+++ op-geth/beacon/engine/types.go
@@ -36,11 +36,22 @@ Random common.Hash `json:"prevRandao" gencodec:"required"`
SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient" gencodec:"required"`
Withdrawals []*types.Withdrawal `json:"withdrawals"`
BeaconRoot *common.Hash `json:"parentBeaconBlockRoot"`
+
+ // Transactions is a field for rollups: the transactions list is forced into the block
+ Transactions [][]byte `json:"transactions,omitempty" gencodec:"optional"`
+ // NoTxPool is a field for rollups: if true, the no transactions are taken out of the tx-pool,
+ // only transactions from the above Transactions list will be included.
+ NoTxPool bool `json:"noTxPool,omitempty" gencodec:"optional"`
+ // GasLimit is a field for rollups: if set, this sets the exact gas limit the block produced with.
+ GasLimit *uint64 `json:"gasLimit,omitempty" gencodec:"optional"`
}
// JSON type overrides for PayloadAttributes.
type payloadAttributesMarshaling struct {
Timestamp hexutil.Uint64
+
+ Transactions []hexutil.Bytes
+ GasLimit *hexutil.Uint64
}
//go:generate go run github.com/fjl/gencodec -type ExecutableData -field-override executableDataMarshaling -out gen_ed.go
diff --git go-ethereum/beacon/engine/gen_blockparams.go op-geth/beacon/engine/gen_blockparams.go
index b1f01b50ff8e3b1adf0454ff989356a6f612a337..c343e5890668558738a5f31b287a89a427888f66 100644
--- go-ethereum/beacon/engine/gen_blockparams.go
+++ op-geth/beacon/engine/gen_blockparams.go
@@ -21,6 +21,9 @@ Random common.Hash `json:"prevRandao" gencodec:"required"`
SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient" gencodec:"required"`
Withdrawals []*types.Withdrawal `json:"withdrawals"`
BeaconRoot *common.Hash `json:"parentBeaconBlockRoot"`
+ Transactions []hexutil.Bytes `json:"transactions,omitempty" gencodec:"optional"`
+ NoTxPool bool `json:"noTxPool,omitempty" gencodec:"optional"`
+ GasLimit *hexutil.Uint64 `json:"gasLimit,omitempty" gencodec:"optional"`
}
var enc PayloadAttributes
enc.Timestamp = hexutil.Uint64(p.Timestamp)
@@ -28,6 +31,14 @@ enc.Random = p.Random
enc.SuggestedFeeRecipient = p.SuggestedFeeRecipient
enc.Withdrawals = p.Withdrawals
enc.BeaconRoot = p.BeaconRoot
+ if p.Transactions != nil {
+ enc.Transactions = make([]hexutil.Bytes, len(p.Transactions))
+ for k, v := range p.Transactions {
+ enc.Transactions[k] = v
+ }
+ }
+ enc.NoTxPool = p.NoTxPool
+ enc.GasLimit = (*hexutil.Uint64)(p.GasLimit)
return json.Marshal(&enc)
}
@@ -39,6 +50,9 @@ Random *common.Hash `json:"prevRandao" gencodec:"required"`
SuggestedFeeRecipient *common.Address `json:"suggestedFeeRecipient" gencodec:"required"`
Withdrawals []*types.Withdrawal `json:"withdrawals"`
BeaconRoot *common.Hash `json:"parentBeaconBlockRoot"`
+ Transactions []hexutil.Bytes `json:"transactions,omitempty" gencodec:"optional"`
+ NoTxPool *bool `json:"noTxPool,omitempty" gencodec:"optional"`
+ GasLimit *hexutil.Uint64 `json:"gasLimit,omitempty" gencodec:"optional"`
}
var dec PayloadAttributes
if err := json.Unmarshal(input, &dec); err != nil {
@@ -61,6 +75,18 @@ p.Withdrawals = dec.Withdrawals
}
if dec.BeaconRoot != nil {
p.BeaconRoot = dec.BeaconRoot
+ }
+ if dec.Transactions != nil {
+ p.Transactions = make([][]byte, len(dec.Transactions))
+ for k, v := range dec.Transactions {
+ p.Transactions[k] = v
+ }
+ }
+ if dec.NoTxPool != nil {
+ p.NoTxPool = *dec.NoTxPool
+ }
+ if dec.GasLimit != nil {
+ p.GasLimit = (*uint64)(dec.GasLimit)
}
return nil
}
diff --git go-ethereum/eth/catalyst/api.go op-geth/eth/catalyst/api.go
index d1e19914140d0b152feb5c78154f380876e1f0e8..69599d8c6c290d4e3c8dbd9a99d2c12008b28cfd 100644
--- go-ethereum/eth/catalyst/api.go
+++ op-geth/eth/catalyst/api.go
@@ -320,7 +320,7 @@ } else if api.eth.BlockChain().CurrentBlock().Hash() == update.HeadBlockHash {
// If the specified head matches with our local head, do nothing and keep
// generating the payload. It's a special corner case that a few slots are
// missing and we are requested to generate the payload in slot.
- } else {
+ } else if api.eth.BlockChain().Config().Optimism == nil { // minor Engine API divergence: allow proposers to reorg their own chain
// If the head block is already in our canonical chain, the beacon client is
// probably resyncing. Ignore the update.
log.Info("Ignoring beacon update to old head", "number", block.NumberU64(), "hash", update.HeadBlockHash, "age", common.PrettyAge(time.Unix(int64(block.Time()), 0)), "have", api.eth.BlockChain().CurrentBlock().Number)
@@ -364,6 +364,17 @@ // If payload generation was requested, create a new block to be potentially
// sealed by the beacon client. The payload will be requested later, and we
// will replace it arbitrarily many times in between.
if payloadAttributes != nil {
+ if api.eth.BlockChain().Config().Optimism != nil && payloadAttributes.GasLimit == nil {
+ return engine.STATUS_INVALID, engine.InvalidPayloadAttributes.With(errors.New("gasLimit parameter is required"))
+ }
+ transactions := make(types.Transactions, 0, len(payloadAttributes.Transactions))
+ for i, otx := range payloadAttributes.Transactions {
+ var tx types.Transaction
+ if err := tx.UnmarshalBinary(otx); err != nil {
+ return engine.STATUS_INVALID, fmt.Errorf("transaction %d is not valid: %v", i, err)
+ }
+ transactions = append(transactions, &tx)
+ }
args := &miner.BuildPayloadArgs{
Parent: update.HeadBlockHash,
Timestamp: payloadAttributes.Timestamp,
@@ -371,6 +382,9 @@ FeeRecipient: payloadAttributes.SuggestedFeeRecipient,
Random: payloadAttributes.Random,
Withdrawals: payloadAttributes.Withdrawals,
BeaconRoot: payloadAttributes.BeaconRoot,
+ NoTxPool: payloadAttributes.NoTxPool,
+ Transactions: transactions,
+ GasLimit: payloadAttributes.GasLimit,
}
id := args.Id()
// If we already are busy generating this work, then we do not need
@@ -717,6 +731,9 @@ // user that something might be off with their consensus node.
//
// TODO(karalabe): Spin this goroutine down somehow
func (api *ConsensusAPI) heartbeat() {
+ if api.eth.BlockChain().Config().Optimism != nil { // don't start the api heartbeat, there is no transition
+ return
+ }
// Sleep a bit on startup since there's obviously no beacon client yet
// attached, so no need to print scary warnings to the user.
time.Sleep(beaconUpdateStartupTimeout)
Block-building modifications
+111
-9
The block-building code (in the “miner” package because of Proof-Of-Work legacy of ethereum) implements the changes to support the transaction-inclusion, tx-pool toggle and gaslimit parameters of the Engine API.
diff --git go-ethereum/miner/miner.go op-geth/miner/miner.go
index b7273948f5e75dac52548cc07faa19abd5705072..82d353a336eff601566da2f938e344a62f474027 100644
--- go-ethereum/miner/miner.go
+++ op-geth/miner/miner.go
@@ -18,6 +18,7 @@ // Package miner implements Ethereum block creation and mining.
package miner
import (
+ "context"
"fmt"
"math/big"
"sync"
@@ -31,6 +32,7 @@ "github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/core/txpool"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/eth/downloader"
+ "github.com/ethereum/go-ethereum/eth/tracers"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/params"
@@ -43,6 +45,10 @@ BlockChain() *core.BlockChain
TxPool() *txpool.TxPool
}
+type BackendWithHistoricalState interface {
+ StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, tracers.StateReleaseFunc, error)
+}
+
// Config is the configuration parameters of mining.
type Config struct {
Etherbase common.Address `toml:",omitempty"` // Public address for block mining rewards
@@ -53,6 +59,8 @@ GasPrice *big.Int // Minimum gas price for mining a transaction
Recommit time.Duration // The time interval for miner to re-create mining work.
NewPayloadTimeout time.Duration // The maximum time allowance for creating a new payload
+
+ RollupComputePendingBlock bool // Compute the pending block from tx-pool, instead of copying the latest-block
}
// DefaultConfig contains default settings for miner.
diff --git go-ethereum/miner/worker.go op-geth/miner/worker.go
index f6807028145419b642d9ac2cbec73aba71556fae..4a73c1b1b69c14f956b10440baf5a0407169ecde 100644
--- go-ethereum/miner/worker.go
+++ op-geth/miner/worker.go
@@ -17,6 +17,7 @@
package miner
import (
+ "context"
"errors"
"fmt"
"math/big"
@@ -26,6 +27,7 @@ "time"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/consensus"
+ "github.com/ethereum/go-ethereum/consensus/misc"
"github.com/ethereum/go-ethereum/consensus/misc/eip1559"
"github.com/ethereum/go-ethereum/consensus/misc/eip4844"
"github.com/ethereum/go-ethereum/core"
@@ -33,6 +35,7 @@ "github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/core/txpool"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/eth/tracers"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/params"
@@ -55,7 +58,7 @@ resubmitAdjustChanSize = 10
// minRecommitInterval is the minimal time interval to recreate the sealing block with
// any newly arrived transactions.
- minRecommitInterval = 1 * time.Second
+ minRecommitInterval = 100 * time.Millisecond
// maxRecommitInterval is the maximum time interval to recreate the sealing block with
// any newly arrived transactions.
@@ -338,6 +341,9 @@
// pending returns the pending state and corresponding block. The returned
// values can be nil in case the pending block is not initialized.
func (w *worker) pending() (*types.Block, *state.StateDB) {
+ if w.chainConfig.Optimism != nil && !w.config.RollupComputePendingBlock {
+ return nil, nil // when not computing the pending block, there is never a pending state
+ }
w.snapshotMu.RLock()
defer w.snapshotMu.RUnlock()
if w.snapshotState == nil {
@@ -349,6 +355,12 @@
// pendingBlock returns pending block. The returned block can be nil in case the
// pending block is not initialized.
func (w *worker) pendingBlock() *types.Block {
+ if w.chainConfig.Optimism != nil && !w.config.RollupComputePendingBlock {
+ // For compatibility when not computing a pending block, we serve the latest block as "pending"
+ headHeader := w.eth.BlockChain().CurrentHeader()
+ headBlock := w.eth.BlockChain().GetBlock(headHeader.Hash(), headHeader.Number.Uint64())
+ return headBlock
+ }
w.snapshotMu.RLock()
defer w.snapshotMu.RUnlock()
return w.snapshotBlock
@@ -357,6 +369,9 @@
// pendingBlockAndReceipts returns pending block and corresponding receipts.
// The returned values can be nil in case the pending block is not initialized.
func (w *worker) pendingBlockAndReceipts() (*types.Block, types.Receipts) {
+ if w.chainConfig.Optimism != nil && !w.config.RollupComputePendingBlock {
+ return nil, nil // when not computing the pending block, there are no pending receipts, and thus no pending logs
+ }
w.snapshotMu.RLock()
defer w.snapshotMu.RUnlock()
return w.snapshotBlock, w.snapshotReceipts
@@ -411,6 +426,19 @@
// newWorkLoop is a standalone goroutine to submit new sealing work upon received events.
func (w *worker) newWorkLoop(recommit time.Duration) {
defer w.wg.Done()
+ if w.chainConfig.Optimism != nil && !w.config.RollupComputePendingBlock {
+ for { // do not update the pending-block, instead drain work without doing it, to keep producers from blocking.
+ select {
+ case <-w.startCh:
+ case <-w.chainHeadCh:
+ case <-w.resubmitIntervalCh:
+ case <-w.resubmitAdjustCh:
+ case <-w.exitCh:
+ return
+ }
+ }
+ }
+
var (
interrupt *atomic.Int32
minRecommit = recommit // minimal resubmit interval specified by user.
@@ -528,6 +556,9 @@ case req := <-w.getWorkCh:
req.result <- w.generateWork(req.params)
case ev := <-w.txsCh:
+ if w.chainConfig.Optimism != nil && !w.config.RollupComputePendingBlock {
+ continue // don't update the pending-block snapshot if we are not computing the pending block
+ }
// Apply transactions to the pending state if we're not sealing
//
// Note all transactions received may not be continuous with transactions
@@ -708,6 +739,15 @@ func (w *worker) makeEnv(parent *types.Header, header *types.Header, coinbase common.Address) (*environment, error) {
// Retrieve the parent state to execute on top and start a prefetcher for
// the miner to speed block sealing up a bit.
state, err := w.chain.StateAt(parent.Root)
+ if err != nil && w.chainConfig.Optimism != nil { // Allow the miner to reorg its own chain arbitrarily deep
+ if historicalBackend, ok := w.eth.(BackendWithHistoricalState); ok {
+ var release tracers.StateReleaseFunc
+ parentBlock := w.eth.BlockChain().GetBlockByHash(parent.Hash())
+ state, release, err = historicalBackend.StateAtBlock(context.Background(), parentBlock, ^uint64(0), nil, false, false)
+ state = state.Copy()
+ release()
+ }
+ }
if err != nil {
return nil, err
}
@@ -896,6 +936,9 @@ random common.Hash // The randomness generated by beacon chain, empty before the merge
withdrawals types.Withdrawals // List of withdrawals to include in block.
beaconRoot *common.Hash // The beacon root (cancun field).
noTxs bool // Flag whether an empty block without any transaction is expected
+
+ txs types.Transactions // Deposit transactions to include at the start of the block
+ gasLimit *uint64 // Optional gas limit override
}
// prepareWork constructs the sealing task according to the given parameters,
@@ -932,7 +975,7 @@ Time: timestamp,
Coinbase: genParams.coinbase,
}
// Set the extra field.
- if len(w.extra) != 0 {
+ if len(w.extra) != 0 && w.chainConfig.Optimism == nil { // Optimism chains must not set any extra data.
header.Extra = w.extra
}
// Set the randomness field from the beacon chain if it's available.
@@ -941,12 +984,18 @@ header.MixDigest = genParams.random
}
// Set baseFee and GasLimit if we are on an EIP-1559 chain
if w.chainConfig.IsLondon(header.Number) {
- header.BaseFee = eip1559.CalcBaseFee(w.chainConfig, parent)
+ header.BaseFee = eip1559.CalcBaseFee(w.chainConfig, parent, header.Time)
if !w.chainConfig.IsLondon(parent.Number) {
parentGasLimit := parent.GasLimit * w.chainConfig.ElasticityMultiplier()
header.GasLimit = core.CalcGasLimit(parentGasLimit, w.config.GasCeil)
}
}
+ if genParams.gasLimit != nil { // override gas limit if specified
+ header.GasLimit = *genParams.gasLimit
+ } else if w.chain.Config().Optimism != nil && w.config.GasCeil != 0 {
+ // configure the gas limit of pending blocks with the miner gas limit config when using optimism
+ header.GasLimit = w.config.GasCeil
+ }
// Apply EIP-4844, EIP-4788.
if w.chainConfig.IsCancun(header.Number, header.Time) {
var excessBlobGas uint64
@@ -974,7 +1023,7 @@ log.Error("Failed to create sealing context", "err", err)
return nil, err
}
if header.ParentBeaconRoot != nil {
- context := core.NewEVMBlockContext(header, w.chain, nil)
+ context := core.NewEVMBlockContext(header, w.chain, nil, w.chainConfig, env.state)
vmenv := vm.NewEVM(context, vm.TxContext{}, env.state, w.chainConfig, vm.Config{})
core.ProcessBeaconBlockRoot(*header.ParentBeaconRoot, vmenv, env.state)
}
@@ -1013,14 +1062,30 @@ return nil
}
// generateWork generates a sealing block based on the given parameters.
-func (w *worker) generateWork(params *generateParams) *newPayloadResult {
- work, err := w.prepareWork(params)
+func (w *worker) generateWork(genParams *generateParams) *newPayloadResult {
+ work, err := w.prepareWork(genParams)
if err != nil {
return &newPayloadResult{err: err}
}
defer work.discard()
+ if work.gasPool == nil {
+ work.gasPool = new(core.GasPool).AddGas(work.header.GasLimit)
+ }
- if !params.noTxs {
+ misc.EnsureCreate2Deployer(w.chainConfig, work.header.Time, work.state)
+
+ for _, tx := range genParams.txs {
+ from, _ := types.Sender(work.signer, tx)
+ work.state.SetTxContext(tx.Hash(), work.tcount)
+ _, err := w.commitTransaction(work, tx)
+ if err != nil {
+ return &newPayloadResult{err: fmt.Errorf("failed to force-include tx: %s type: %d sender: %s nonce: %d, err: %w", tx.Hash(), tx.Type(), from, tx.Nonce(), err)}
+ }
+ work.tcount++
+ }
+
+ // forced transactions done, fill rest of block with transactions
+ if !genParams.noTxs {
interrupt := new(atomic.Int32)
timer := time.AfterFunc(w.newpayloadTimeout, func() {
interrupt.Store(commitInterruptTimeout)
@@ -1032,7 +1097,7 @@ if errors.Is(err, errBlockInterruptedByTimeout) {
log.Warn("Block building is interrupted", "allowance", common.PrettyDuration(w.newpayloadTimeout))
}
}
- block, err := w.engine.FinalizeAndAssemble(w.chain, work.header, work.state, work.txs, nil, work.receipts, params.withdrawals)
+ block, err := w.engine.FinalizeAndAssemble(w.chain, work.header, work.state, work.txs, nil, work.receipts, genParams.withdrawals)
if err != nil {
return &newPayloadResult{err: err}
}
diff --git go-ethereum/miner/payload_building.go op-geth/miner/payload_building.go
index 69ffab75b5d171f9ce91dcfb03daf6f927db5c9a..1510ee5a826d2a62ebcd5ae89a38849299a421f4 100644
--- go-ethereum/miner/payload_building.go
+++ op-geth/miner/payload_building.go
@@ -41,6 +41,10 @@ FeeRecipient common.Address // The provided recipient address for collecting transaction fee
Random common.Hash // The provided randomness value
Withdrawals types.Withdrawals // The provided withdrawals
BeaconRoot *common.Hash // The provided beaconRoot (Cancun)
+
+ NoTxPool bool // Optimism addition: option to disable tx pool contents from being included
+ Transactions []*types.Transaction // Optimism addition: txs forced into the block via engine API
+ GasLimit *uint64 // Optimism addition: override gas limit of the block to build
}
// Id computes an 8-byte identifier by hashing the components of the payload arguments.
@@ -55,6 +59,19 @@ rlp.Encode(hasher, args.Withdrawals)
if args.BeaconRoot != nil {
hasher.Write(args.BeaconRoot[:])
}
+
+ if args.NoTxPool || len(args.Transactions) > 0 { // extend if extra payload attributes are used
+ binary.Write(hasher, binary.BigEndian, args.NoTxPool)
+ binary.Write(hasher, binary.BigEndian, uint64(len(args.Transactions)))
+ for _, tx := range args.Transactions {
+ h := tx.Hash()
+ hasher.Write(h[:])
+ }
+ }
+ if args.GasLimit != nil {
+ binary.Write(hasher, binary.BigEndian, *args.GasLimit)
+ }
+
var out engine.PayloadID
copy(out[:], hasher.Sum(nil)[:8])
return out
@@ -179,6 +196,7 @@ func (w *worker) buildPayload(args *BuildPayloadArgs) (*Payload, error) {
// Build the initial version with no transaction included. It should be fast
// enough to run. The empty payload can at least make sure there is something
// to deliver for not missing slot.
+ // In OP-Stack, the "empty" block is constructed from provided txs only, i.e. no tx-pool usage.
emptyParams := &generateParams{
timestamp: args.Timestamp,
forceTime: true,
@@ -188,6 +206,8 @@ random: args.Random,
withdrawals: args.Withdrawals,
beaconRoot: args.BeaconRoot,
noTxs: true,
+ txs: args.Transactions,
+ gasLimit: args.GasLimit,
}
empty := w.getSealingBlock(emptyParams)
if empty.err != nil {
@@ -196,6 +216,12 @@ }
// Construct a payload object for return.
payload := newPayload(empty.block, args.Id())
+ if args.NoTxPool { // don't start the background payload updating job if there is no tx pool to pull from
+ // make sure to make it appear as full, otherwise it will wait indefinitely for payload building to complete.
+ payload.full = empty.block
+ payload.fullFees = empty.fees
+ return payload, nil
+ }
// Spin up a routine for updating the payload in background. This strategy
// can maximum the revenue for including transactions with highest fee.
@@ -219,6 +245,8 @@ random: args.Random,
withdrawals: args.Withdrawals,
beaconRoot: args.BeaconRoot,
noTxs: false,
+ txs: args.Transactions,
+ gasLimit: args.GasLimit,
}
for {
diff --git go-ethereum/miner/worker_test.go op-geth/miner/worker_test.go
index 9c4694c0e20deade0c1c929f61dab094205c8d1c..d0a5ced8f9b6082613c10bfed460b6044464ae9e 100644
--- go-ethereum/miner/worker_test.go
+++ op-geth/miner/worker_test.go
@@ -297,7 +297,8 @@ min := float64(3 * time.Second.Nanoseconds())
estimate = estimate*(1-intervalAdjustRatio) + intervalAdjustRatio*(min-intervalAdjustBias)
wantMinInterval, wantRecommitInterval = 3*time.Second, time.Duration(estimate)*time.Nanosecond
case 3:
- wantMinInterval, wantRecommitInterval = time.Second, time.Second
+ // lower than upstream test, since enforced min recommit interval is lower
+ wantMinInterval, wantRecommitInterval = 500*time.Millisecond, 500*time.Millisecond
}
// Check interval
Tx-pool tx cost updates
+141
-26
Transaction queueing and inclusion needs to account for the L1 cost component.
diff --git go-ethereum/core/txpool/validation.go op-geth/core/txpool/validation.go
index 0df363d81d87edbc07b613098bca62eaf5eab3ae..a708d09ae37169761e733937f2527707b767c7af 100644
--- go-ethereum/core/txpool/validation.go
+++ op-geth/core/txpool/validation.go
@@ -30,6 +30,22 @@ "github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/params"
)
+// L1 Info Gas Overhead is the amount of gas the the L1 info deposit consumes.
+// It is removed from the tx pool max gas to better indicate that L2 transactions
+// are not able to consume all of the gas in a L2 block as the L1 info deposit is always present.
+const l1InfoGasOverhead = uint64(70_000)
+
+func EffectiveGasLimit(chainConfig *params.ChainConfig, gasLimit uint64) uint64 {
+ if chainConfig.Optimism != nil {
+ if l1InfoGasOverhead < gasLimit {
+ gasLimit -= l1InfoGasOverhead
+ } else {
+ gasLimit = 0
+ }
+ }
+ return gasLimit
+}
+
// ValidationOptions define certain differences between transaction validation
// across the different pools without having to duplicate those checks.
type ValidationOptions struct {
@@ -47,6 +63,12 @@ //
// This check is public to allow different transaction pools to check the basic
// rules without duplicating code and running the risk of missed updates.
func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types.Signer, opts *ValidationOptions) error {
+ // No unauthenticated deposits allowed in the transaction pool.
+ // This is for spam protection, not consensus,
+ // as the external engine-API user authenticates deposits.
+ if tx.Type() == types.DepositTxType {
+ return core.ErrTxTypeNotSupported
+ }
// Ensure transactions not implemented by the calling pool are rejected
if opts.Accept&(1<<tx.Type()) == 0 {
return fmt.Errorf("%w: tx type %v not supported by this pool", core.ErrTxTypeNotSupported, tx.Type())
@@ -76,7 +98,7 @@ if tx.Value().Sign() < 0 {
return ErrNegativeValue
}
// Ensure the transaction doesn't exceed the current block limit gas
- if head.GasLimit < tx.Gas() {
+ if EffectiveGasLimit(opts.Config, head.GasLimit) < tx.Gas() {
return ErrGasLimit
}
// Sanity check for extremely large numbers (supported by RLP or RPC)
@@ -189,6 +211,9 @@
// ExistingCost is a mandatory callback to retrieve an already pooled
// transaction's cost with the given nonce to check for overdrafts.
ExistingCost func(addr common.Address, nonce uint64) *big.Int
+
+ // L1CostFn is an optional extension, to validate L1 rollup costs of a tx
+ L1CostFn L1CostFunc
}
// ValidateTransactionWithState is a helper method to check whether a transaction
@@ -219,6 +244,11 @@ var (
balance = opts.State.GetBalance(from)
cost = tx.Cost()
)
+ if opts.L1CostFn != nil {
+ if l1Cost := opts.L1CostFn(tx.RollupDataGas()); l1Cost != nil { // add rollup cost
+ cost = cost.Add(cost, l1Cost)
+ }
+ }
if balance.Cmp(cost) < 0 {
return fmt.Errorf("%w: balance %v, tx cost %v, overshot %v", core.ErrInsufficientFunds, balance, cost, new(big.Int).Sub(cost, balance))
}
diff --git go-ethereum/core/txpool/txpool.go op-geth/core/txpool/txpool.go
index 0d4e05da4c1876989b407dbb062481d80c75efbd..76b4e7dab89b7c2d35d3ad0e66d0cf168f471e4b 100644
--- go-ethereum/core/txpool/txpool.go
+++ op-geth/core/txpool/txpool.go
@@ -30,6 +30,8 @@ "github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/metrics"
)
+type L1CostFunc func(dataGas types.RollupGasData) *big.Int
+
// TxStatus is the current status of a transaction as seen by the pool.
type TxStatus uint
@@ -207,7 +209,6 @@ subpool.Reset(oldHead, newHead)
}
resetDone <- newHead
}(oldHead, newHead)
-
default:
// Reset already running, wait until it finishes
}
diff --git go-ethereum/core/txpool/legacypool/legacypool_test.go op-geth/core/txpool/legacypool/legacypool_test.go
index a8f3dd7d862476416ea6e41e026143f8eae3f46f..43dfeee92c2a6ec279b270faa353589df6a6da9c 100644
--- go-ethereum/core/txpool/legacypool/legacypool_test.go
+++ op-geth/core/txpool/legacypool/legacypool_test.go
@@ -2301,10 +2301,13 @@ }
// Tests that local transactions are journaled to disk, but remote transactions
// get discarded between restarts.
-func TestJournaling(t *testing.T) { testJournaling(t, false) }
-func TestJournalingNoLocals(t *testing.T) { testJournaling(t, true) }
+func TestJournaling(t *testing.T) { testJournaling(t, false, false) }
+func TestJournalingNoLocals(t *testing.T) { testJournaling(t, true, false) }
+
+func TestJournalingRemotes(t *testing.T) { testJournaling(t, false, true) }
+func TestJournalingRemotesNoLocals(t *testing.T) { testJournaling(t, true, true) }
-func testJournaling(t *testing.T, nolocals bool) {
+func testJournaling(t *testing.T, nolocals bool, journalRemotes bool) {
t.Parallel()
// Create a temporary file for the journal
@@ -2325,6 +2328,7 @@ blockchain := newTestBlockChain(params.TestChainConfig, 1000000, statedb, new(event.Feed))
config := testTxPoolConfig
config.NoLocals = nolocals
+ config.JournalRemote = journalRemotes
config.Journal = journal
config.Rejournal = time.Second
@@ -2373,10 +2377,14 @@ pending, queued = pool.Stats()
if queued != 0 {
t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 0)
}
- if nolocals {
+ if nolocals && !journalRemotes {
if pending != 0 {
t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 0)
}
+ } else if journalRemotes {
+ if pending != 3 {
+ t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 3)
+ }
} else {
if pending != 2 {
t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 2)
@@ -2397,10 +2405,16 @@ pool = New(config, blockchain)
pool.Init(new(big.Int).SetUint64(config.PriceLimit), blockchain.CurrentBlock(), makeAddressReserver())
pending, queued = pool.Stats()
- if pending != 0 {
- t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 0)
+ if journalRemotes {
+ if pending != 1 { // Remove the 2 replaced local transactions, but preserve the remote
+ t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 1)
+ }
+ } else {
+ if pending != 0 {
+ t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 0)
+ }
}
- if nolocals {
+ if nolocals && !journalRemotes {
if queued != 0 {
t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 0)
}
diff --git go-ethereum/core/txpool/legacypool/list_test.go op-geth/core/txpool/legacypool/list_test.go
index b5cd34b23b622425518f8fcd1a9896eb5a4ec021..b1f6ec305d575c8e7e0d6bc1d84fcedcfaf7d28e 100644
--- go-ethereum/core/txpool/legacypool/list_test.go
+++ op-geth/core/txpool/legacypool/list_test.go
@@ -38,7 +38,7 @@ }
// Insert the transactions in a random order
list := newList(true)
for _, v := range rand.Perm(len(txs)) {
- list.Add(txs[v], DefaultConfig.PriceBump)
+ list.Add(txs[v], DefaultConfig.PriceBump, nil)
}
// Verify internal state
if len(list.txs.items) != len(txs) {
@@ -65,7 +65,7 @@ b.ResetTimer()
for i := 0; i < b.N; i++ {
list := newList(true)
for _, v := range rand.Perm(len(txs)) {
- list.Add(txs[v], DefaultConfig.PriceBump)
+ list.Add(txs[v], DefaultConfig.PriceBump, nil)
list.Filter(priceLimit, DefaultConfig.PriceBump)
}
}
diff --git go-ethereum/core/txpool/legacypool/legacypool.go op-geth/core/txpool/legacypool/legacypool.go
index 0e33923274058176fb6404862772ccbc506e750f..6d415032cf5b1cbd88345ae64242e3f9152a86bb 100644
--- go-ethereum/core/txpool/legacypool/legacypool.go
+++ op-geth/core/txpool/legacypool/legacypool.go
@@ -125,6 +125,10 @@ NoLocals bool // Whether local transaction handling should be disabled
Journal string // Journal of local transactions to survive node restarts
Rejournal time.Duration // Time interval to regenerate the local transaction journal
+ // JournalRemote controls whether journaling includes remote transactions or not.
+ // When true, all transactions loaded from the journal are treated as remote.
+ JournalRemote bool
+
PriceLimit uint64 // Minimum gas price to enforce for acceptance into the pool
PriceBump uint64 // Minimum price bump percentage to replace an already existing transaction (nonce)
@@ -230,6 +234,8 @@ wg sync.WaitGroup // tracks loop, scheduleReorgLoop
initDoneCh chan struct{} // is closed once the pool is initialized (for tests)
changesSinceReorg int // A counter for how many drops we've performed in-between reorg.
+
+ l1CostFn txpool.L1CostFunc // To apply L1 costs as rollup, optional field, may be nil.
}
type txpoolResetRequest struct {
@@ -266,7 +272,7 @@ pool.locals.add(addr)
}
pool.priced = newPricedList(pool.all)
- if !config.NoLocals && config.Journal != "" {
+ if (!config.NoLocals || config.JournalRemote) && config.Journal != "" {
pool.journal = newTxJournal(config.Journal)
}
return pool
@@ -315,10 +321,14 @@ go pool.scheduleReorgLoop()
// If local transactions and journaling is enabled, load from disk
if pool.journal != nil {
- if err := pool.journal.load(pool.addLocals); err != nil {
+ add := pool.addLocals
+ if pool.config.JournalRemote {
+ add = pool.addRemotesSync // Use sync version to match pool.AddLocals
+ }
+ if err := pool.journal.load(add); err != nil {
log.Warn("Failed to load transaction journal", "err", err)
}
- if err := pool.journal.rotate(pool.local()); err != nil {
+ if err := pool.journal.rotate(pool.toJournal()); err != nil {
log.Warn("Failed to rotate transaction journal", "err", err)
}
}
@@ -388,7 +398,7 @@ // Handle local transaction journal rotation
case <-journal.C:
if pool.journal != nil {
pool.mu.Lock()
- if err := pool.journal.rotate(pool.local()); err != nil {
+ if err := pool.journal.rotate(pool.toJournal()); err != nil {
log.Warn("Failed to rotate local tx journal", "err", err)
}
pool.mu.Unlock()
@@ -566,6 +576,23 @@
return pool.locals.flatten()
}
+// toJournal retrieves all transactions that should be included in the journal,
+// grouped by origin account and sorted by nonce.
+// The returned transaction set is a copy and can be freely modified by calling code.
+func (pool *LegacyPool) toJournal() map[common.Address]types.Transactions {
+ if !pool.config.JournalRemote {
+ return pool.local()
+ }
+ txs := make(map[common.Address]types.Transactions)
+ for addr, pending := range pool.pending {
+ txs[addr] = append(txs[addr], pending.Flatten()...)
+ }
+ for addr, queued := range pool.queue {
+ txs[addr] = append(txs[addr], queued.Flatten()...)
+ }
+ return txs
+}
+
// local retrieves all currently known local transactions, grouped by origin
// account and sorted by nonce. The returned transaction set is a copy and can be
// freely modified by calling code.
@@ -631,11 +658,18 @@ },
ExistingCost: func(addr common.Address, nonce uint64) *big.Int {
if list := pool.pending[addr]; list != nil {
if tx := list.txs.Get(nonce); tx != nil {
- return tx.Cost()
+ cost := tx.Cost()
+ if pool.l1CostFn != nil {
+ if l1Cost := pool.l1CostFn(tx.RollupDataGas()); l1Cost != nil { // add rollup cost
+ cost = cost.Add(cost, l1Cost)
+ }
+ }
+ return cost
}
}
return nil
},
+ L1CostFn: pool.l1CostFn,
}
if err := txpool.ValidateTransactionWithState(tx, pool.signer, opts); err != nil {
return err
@@ -758,7 +792,7 @@
// Try to replace an existing transaction in the pending pool
if list := pool.pending[from]; list != nil && list.Contains(tx.Nonce()) {
// Nonce already pending, check if required price bump is met
- inserted, old := list.Add(tx, pool.config.PriceBump)
+ inserted, old := list.Add(tx, pool.config.PriceBump, pool.l1CostFn)
if !inserted {
pendingDiscardMeter.Mark(1)
return false, txpool.ErrReplaceUnderpriced
@@ -832,7 +866,7 @@ from, _ := types.Sender(pool.signer, tx) // already validated
if pool.queue[from] == nil {
pool.queue[from] = newList(false)
}
- inserted, old := pool.queue[from].Add(tx, pool.config.PriceBump)
+ inserted, old := pool.queue[from].Add(tx, pool.config.PriceBump, pool.l1CostFn)
if !inserted {
// An older transaction was better, discard this
queuedDiscardMeter.Mark(1)
@@ -867,7 +901,7 @@ // journalTx adds the specified transaction to the local disk journal if it is
// deemed to have been sent from a local account.
func (pool *LegacyPool) journalTx(from common.Address, tx *types.Transaction) {
// Only journal if it's enabled and the transaction is local
- if pool.journal == nil || !pool.locals.contains(from) {
+ if pool.journal == nil || (!pool.config.JournalRemote && !pool.locals.contains(from)) {
return
}
if err := pool.journal.insert(tx); err != nil {
@@ -886,7 +920,7 @@ pool.pending[addr] = newList(true)
}
list := pool.pending[addr]
- inserted, old := list.Add(tx, pool.config.PriceBump)
+ inserted, old := list.Add(tx, pool.config.PriceBump, pool.l1CostFn)
if !inserted {
// An older transaction was better, discard this
pool.all.Remove(hash)
@@ -1279,7 +1313,7 @@ if reset != nil {
pool.demoteUnexecutables()
if reset.newHead != nil {
if pool.chainconfig.IsLondon(new(big.Int).Add(reset.newHead.Number, big.NewInt(1))) {
- pendingBaseFee := eip1559.CalcBaseFee(pool.chainconfig, reset.newHead)
+ pendingBaseFee := eip1559.CalcBaseFee(pool.chainconfig, reset.newHead, reset.newHead.Time+1)
pool.priced.SetBaseFee(pendingBaseFee)
} else {
pool.priced.Reheap()
@@ -1411,6 +1445,11 @@ pool.currentHead.Store(newHead)
pool.currentState = statedb
pool.pendingNonces = newNoncer(statedb)
+ costFn := types.NewL1CostFunc(pool.chainconfig, statedb)
+ pool.l1CostFn = func(dataGas types.RollupGasData) *big.Int {
+ return costFn(newHead.Number.Uint64(), newHead.Time, dataGas, false)
+ }
+
// Inject any transactions discarded due to reorgs
log.Debug("Reinjecting stale transactions", "count", len(reinject))
core.SenderCacher.Recover(pool.signer, reinject)
@@ -1425,7 +1464,7 @@ // Track the promoted transactions to broadcast them at once
var promoted []*types.Transaction
// Iterate over all accounts and promote any executable transactions
- gasLimit := pool.currentHead.Load().GasLimit
+ gasLimit := txpool.EffectiveGasLimit(pool.chainconfig, pool.currentHead.Load().GasLimit)
for _, addr := range accounts {
list := pool.queue[addr]
if list == nil {
@@ -1438,8 +1477,16 @@ hash := tx.Hash()
pool.all.Remove(hash)
}
log.Trace("Removed old queued transactions", "count", len(forwards))
+ balance := pool.currentState.GetBalance(addr)
+ if !list.Empty() && pool.l1CostFn != nil {
+ // Reduce the cost-cap by L1 rollup cost of the first tx if necessary. Other txs will get filtered out afterwards.
+ el := list.txs.FirstElement()
+ if l1Cost := pool.l1CostFn(el.RollupDataGas()); l1Cost != nil {
+ balance = new(big.Int).Sub(balance, l1Cost) // negative big int is fine
+ }
+ }
// Drop all transactions that are too costly (low balance or out of gas)
- drops, _ := list.Filter(pool.currentState.GetBalance(addr), gasLimit)
+ drops, _ := list.Filter(balance, gasLimit)
for _, tx := range drops {
hash := tx.Hash()
pool.all.Remove(hash)
@@ -1628,7 +1675,7 @@ // is always explicitly triggered by SetBaseFee and it would be unnecessary and wasteful
// to trigger a re-heap is this function
func (pool *LegacyPool) demoteUnexecutables() {
// Iterate over all accounts and demote any non-executable transactions
- gasLimit := pool.currentHead.Load().GasLimit
+ gasLimit := txpool.EffectiveGasLimit(pool.chainconfig, pool.currentHead.Load().GasLimit)
for addr, list := range pool.pending {
nonce := pool.currentState.GetNonce(addr)
@@ -1639,8 +1686,16 @@ hash := tx.Hash()
pool.all.Remove(hash)
log.Trace("Removed old pending transaction", "hash", hash)
}
+ balance := pool.currentState.GetBalance(addr)
+ if !list.Empty() && pool.l1CostFn != nil {
+ // Reduce the cost-cap by L1 rollup cost of the first tx if necessary. Other txs will get filtered out afterwards.
+ el := list.txs.FirstElement()
+ if l1Cost := pool.l1CostFn(el.RollupDataGas()); l1Cost != nil {
+ balance = new(big.Int).Sub(balance, l1Cost) // negative big int is fine
+ }
+ }
// Drop all transactions that are too costly (low balance or out of gas), and queue any invalids back for later
- drops, invalids := list.Filter(pool.currentState.GetBalance(addr), gasLimit)
+ drops, invalids := list.Filter(balance, gasLimit)
for _, tx := range drops {
hash := tx.Hash()
log.Trace("Removed unpayable pending transaction", "hash", hash)
diff --git go-ethereum/core/txpool/legacypool/list.go op-geth/core/txpool/legacypool/list.go
index 05ae0b58cd59766145c3dc4c80045878368f8e28..c61f7a0f8c1f1883f64ed4ffd41d50934cc3ae09 100644
--- go-ethereum/core/txpool/legacypool/list.go
+++ op-geth/core/txpool/legacypool/list.go
@@ -26,6 +26,7 @@ "sync/atomic"
"time"
"github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/txpool"
"github.com/ethereum/go-ethereum/core/types"
)
@@ -263,6 +264,15 @@ cache := m.flatten()
return cache[len(cache)-1]
}
+// FirstElement returns the first element from the heap (guaranteed to be lowest), thus, the
+// transaction with the lowest nonce. Returns nil if there are no elements.
+func (m *sortedMap) FirstElement() *types.Transaction {
+ if m.Len() == 0 {
+ return nil
+ }
+ return m.Get((*m.index)[0])
+}
+
// list is a "list" of transactions belonging to an account, sorted by account
// nonce. The same type can be used both for storing contiguous transactions for
// the executable/pending queue; and for storing gapped transactions for the non-
@@ -298,7 +308,7 @@ // transaction was accepted, and if yes, any previous transaction it replaced.
//
// If the new transaction is accepted into the list, the lists' cost and gas
// thresholds are also potentially updated.
-func (l *list) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Transaction) {
+func (l *list) Add(tx *types.Transaction, priceBump uint64, l1CostFn txpool.L1CostFunc) (bool, *types.Transaction) {
// If there's an older better transaction, abort
old := l.txs.Get(tx.Nonce())
if old != nil {
@@ -326,6 +336,11 @@ l.subTotalCost([]*types.Transaction{old})
}
// Add new tx cost to totalcost
l.totalcost.Add(l.totalcost, tx.Cost())
+ if l1CostFn != nil {
+ if l1Cost := l1CostFn(tx.RollupDataGas()); l1Cost != nil { // add rollup cost
+ l.totalcost.Add(l.totalcost, l1Cost)
+ }
+ }
// Otherwise overwrite the old transaction with the current one
l.txs.Put(tx)
if cost := tx.Cost(); l.costcap.Cmp(cost) < 0 {
Chain Configuration
+579
-3
Chain config
+187
-3
The rollup functionality is enabled with the optimism field in the chain config.
The EIP-1559 parameters are configurable to adjust for faster more frequent and smaller blocks.
The parameters can be overriden for testing.
diff --git go-ethereum/params/config.go op-geth/params/config.go
index 88ff772a1d5cd614526c48972241a9a4c5b3f3cd..fdfe45490254e651230088db5d5f5249e2793bb3 100644
--- go-ethereum/params/config.go
+++ op-geth/params/config.go
@@ -31,6 +31,32 @@ SepoliaGenesisHash = common.HexToHash("0x25a5cc106eea7138acab33231d7160d69cb777ee0c2c553fcddf5138993e6dd9")
GoerliGenesisHash = common.HexToHash("0xbf7e331f7f7c1dd2e05159666b3bf8bc7a8a3a9eb1d518969eab529dd9b88c1a")
)
+const (
+ OPMainnetChainID = 10
+ OPGoerliChainID = 420
+ BaseMainnetChainID = 8453
+ BaseGoerliChainID = 84531
+ baseSepoliaChainID = 84532
+ baseGoerliDevnetChainID = 11763071
+ pgnSepoliaChainID = 58008
+ devnetChainID = 997
+ chaosnetChainID = 888
+)
+
+// OP Stack chain config
+var (
+ // March 17, 2023 @ 7:00:00 pm UTC
+ OptimismGoerliRegolithTime = uint64(1679079600)
+ // May 4, 2023 @ 5:00:00 pm UTC
+ BaseGoerliRegolithTime = uint64(1683219600)
+ // Apr 21, 2023 @ 6:30:00 pm UTC
+ baseGoerliDevnetRegolithTime = uint64(1682101800)
+ // March 5, 2023 @ 2:48:00 am UTC
+ devnetRegolithTime = uint64(1677984480)
+ // August 16, 2023 @ 3:34:22 am UTC
+ chaosnetRegolithTime = uint64(1692156862)
+)
+
func newUint64(val uint64) *uint64 { return &val }
var (
@@ -273,6 +299,16 @@ Ethash: new(EthashConfig),
Clique: nil,
}
TestRules = TestChainConfig.Rules(new(big.Int), false, 0)
+
+ // This is an Optimism chain config with bedrock starting a block 5, introduced for historical endpoint testing, largely based on the clique config
+ OptimismTestConfig = func() *ChainConfig {
+ conf := *AllCliqueProtocolChanges // copy the config
+ conf.Clique = nil
+ conf.TerminalTotalDifficultyPassed = true
+ conf.BedrockBlock = big.NewInt(5)
+ conf.Optimism = &OptimismConfig{EIP1559Elasticity: 50, EIP1559Denominator: 10}
+ return &conf
+ }()
)
// NetworkNames are user friendly names to use in the chain spec banner.
@@ -319,6 +355,13 @@ CancunTime *uint64 `json:"cancunTime,omitempty"` // Cancun switch time (nil = no fork, 0 = already on cancun)
PragueTime *uint64 `json:"pragueTime,omitempty"` // Prague switch time (nil = no fork, 0 = already on prague)
VerkleTime *uint64 `json:"verkleTime,omitempty"` // Verkle switch time (nil = no fork, 0 = already on verkle)
+ BedrockBlock *big.Int `json:"bedrockBlock,omitempty"` // Bedrock switch block (nil = no fork, 0 = already on optimism bedrock)
+ RegolithTime *uint64 `json:"regolithTime,omitempty"` // Regolith switch time (nil = no fork, 0 = already on optimism regolith)
+ CanyonTime *uint64 `json:"canyonTime,omitempty"` // Canyon switch time (nil = no fork, 0 = already on optimism canyon)
+ // Delta: the Delta upgrade does not affect the execution-layer, and is thus not configurable in the chain config.
+
+ InteropTime *uint64 `json:"interopTime,omitempty"` // Interop switch time (nil = no fork, 0 = already on optimism interop)
+
// TerminalTotalDifficulty is the amount of total difficulty reached by
// the network that triggers the consensus upgrade.
TerminalTotalDifficulty *big.Int `json:"terminalTotalDifficulty,omitempty"`
@@ -332,6 +375,9 @@ // Various consensus engines
Ethash *EthashConfig `json:"ethash,omitempty"`
Clique *CliqueConfig `json:"clique,omitempty"`
IsDevMode bool `json:"isDev,omitempty"`
+
+ // Optimism config, nil if not active
+ Optimism *OptimismConfig `json:"optimism,omitempty"`
}
// EthashConfig is the consensus engine configs for proof-of-work based sealing.
@@ -353,6 +399,18 @@ func (c *CliqueConfig) String() string {
return "clique"
}
+// OptimismConfig is the optimism config.
+type OptimismConfig struct {
+ EIP1559Elasticity uint64 `json:"eip1559Elasticity"`
+ EIP1559Denominator uint64 `json:"eip1559Denominator"`
+ EIP1559DenominatorCanyon uint64 `json:"eip1559DenominatorCanyon"`
+}
+
+// String implements the stringer interface, returning the optimism fee config details.
+func (o *OptimismConfig) String() string {
+ return "optimism"
+}
+
// Description returns a human-readable description of ChainConfig.
func (c *ChainConfig) Description() string {
var banner string
@@ -364,6 +422,8 @@ network = "unknown"
}
banner += fmt.Sprintf("Chain ID: %v (%s)\n", c.ChainID, network)
switch {
+ case c.Optimism != nil:
+ banner += "Consensus: Optimism\n"
case c.Ethash != nil:
if c.TerminalTotalDifficulty == nil {
banner += "Consensus: Ethash (proof-of-work)\n"
@@ -442,6 +502,15 @@ }
if c.VerkleTime != nil {
banner += fmt.Sprintf(" - Verkle: @%-10v\n", *c.VerkleTime)
}
+ if c.RegolithTime != nil {
+ banner += fmt.Sprintf(" - Regolith: @%-10v\n", *c.RegolithTime)
+ }
+ if c.CanyonTime != nil {
+ banner += fmt.Sprintf(" - Canyon: @%-10v\n", *c.CanyonTime)
+ }
+ if c.InteropTime != nil {
+ banner += fmt.Sprintf(" - Interop: @%-10v\n", *c.InteropTime)
+ }
return banner
}
@@ -545,6 +614,45 @@ func (c *ChainConfig) IsVerkle(num *big.Int, time uint64) bool {
return c.IsLondon(num) && isTimestampForked(c.VerkleTime, time)
}
+// IsBedrock returns whether num is either equal to the Bedrock fork block or greater.
+func (c *ChainConfig) IsBedrock(num *big.Int) bool {
+ return isBlockForked(c.BedrockBlock, num)
+}
+
+func (c *ChainConfig) IsRegolith(time uint64) bool {
+ return isTimestampForked(c.RegolithTime, time)
+}
+
+func (c *ChainConfig) IsCanyon(time uint64) bool {
+ return isTimestampForked(c.CanyonTime, time)
+}
+
+func (c *ChainConfig) IsInterop(time uint64) bool {
+ return isTimestampForked(c.InteropTime, time)
+}
+
+// IsOptimism returns whether the node is an optimism node or not.
+func (c *ChainConfig) IsOptimism() bool {
+ return c.Optimism != nil
+}
+
+// IsOptimismBedrock returns true iff this is an optimism node & bedrock is active
+func (c *ChainConfig) IsOptimismBedrock(num *big.Int) bool {
+ return c.IsOptimism() && c.IsBedrock(num)
+}
+
+func (c *ChainConfig) IsOptimismRegolith(time uint64) bool {
+ return c.IsOptimism() && c.IsRegolith(time)
+}
+func (c *ChainConfig) IsOptimismCanyon(time uint64) bool {
+ return c.IsOptimism() && c.IsCanyon(time)
+}
+
+// IsOptimismPreBedrock returns true iff this is an optimism node & bedrock is not yet active
+func (c *ChainConfig) IsOptimismPreBedrock(num *big.Int) bool {
+ return c.IsOptimism() && !c.IsBedrock(num)
+}
+
// CheckCompatible checks whether scheduled fork transitions have been imported
// with a mismatching chain configuration.
func (c *ChainConfig) CheckCompatible(newcfg *ChainConfig, height uint64, time uint64) *ConfigCompatError {
@@ -710,12 +818,22 @@ return nil
}
// BaseFeeChangeDenominator bounds the amount the base fee can change between blocks.
-func (c *ChainConfig) BaseFeeChangeDenominator() uint64 {
+// The time parameters is the timestamp of the block to determine if Canyon is active or not
+func (c *ChainConfig) BaseFeeChangeDenominator(time uint64) uint64 {
+ if c.Optimism != nil {
+ if c.IsCanyon(time) {
+ return c.Optimism.EIP1559DenominatorCanyon
+ }
+ return c.Optimism.EIP1559Denominator
+ }
return DefaultBaseFeeChangeDenominator
}
// ElasticityMultiplier bounds the maximum gas limit an EIP-1559 block may have.
func (c *ChainConfig) ElasticityMultiplier() uint64 {
+ if c.Optimism != nil {
+ return c.Optimism.EIP1559Elasticity
+ }
return DefaultElasticityMultiplier
}
@@ -852,6 +970,8 @@ IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul bool
IsBerlin, IsLondon bool
IsMerge, IsShanghai, IsCancun, IsPrague bool
IsVerkle bool
+ IsOptimismBedrock, IsOptimismRegolith bool
+ IsOptimismCanyon bool
}
// Rules ensures c's ChainID is not nil.
@@ -877,5 +997,9 @@ IsShanghai: c.IsShanghai(num, timestamp),
IsCancun: c.IsCancun(num, timestamp),
IsPrague: c.IsPrague(num, timestamp),
IsVerkle: c.IsVerkle(num, timestamp),
+ // Optimism
+ IsOptimismBedrock: c.IsOptimismBedrock(num),
+ IsOptimismRegolith: c.IsOptimismRegolith(timestamp),
+ IsOptimismCanyon: c.IsOptimismCanyon(timestamp),
}
}
diff --git go-ethereum/params/protocol_params.go op-geth/params/protocol_params.go
index 8a5c01184941f9260fbbf561a4495667990cb8ce..7a204a3fe27b0b6a99046aebd20c65db9ec348be 100644
--- go-ethereum/params/protocol_params.go
+++ op-geth/params/protocol_params.go
@@ -22,6 +22,13 @@
"github.com/ethereum/go-ethereum/common"
)
+var (
+ // The base fee portion of the transaction fee accumulates at this predeploy
+ OptimismBaseFeeRecipient = common.HexToAddress("0x4200000000000000000000000000000000000019")
+ // The L1 portion of the transaction fee accumulates at this predeploy
+ OptimismL1FeeRecipient = common.HexToAddress("0x420000000000000000000000000000000000001A")
+)
+
const (
GasLimitBoundDivisor uint64 = 1024 // The bound divisor of the gas limit, used in update calculations.
MinGasLimit uint64 = 5000 // Minimum the gas limit may ever be.
diff --git go-ethereum/core/genesis.go op-geth/core/genesis.go
index 1045815fab90e8a264a4bb433819dc1c3e3bbdda..e5126de1cb3db015b140b169a0a571bf9ea43509 100644
--- go-ethereum/core/genesis.go
+++ op-geth/core/genesis.go
@@ -25,6 +25,8 @@ "fmt"
"math/big"
"strings"
+ "github.com/ethereum-optimism/superchain-registry/superchain"
+
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/common/math"
@@ -65,6 +67,11 @@ ParentHash common.Hash `json:"parentHash"`
BaseFee *big.Int `json:"baseFeePerGas"` // EIP-1559
ExcessBlobGas *uint64 `json:"excessBlobGas"` // EIP-4844
BlobGasUsed *uint64 `json:"blobGasUsed"` // EIP-4844
+
+ // StateHash represents the genesis state, to allow instantiation of a chain with missing initial state.
+ // Chains with history pruning, or extraordinarily large genesis allocation (e.g. after a regenesis event)
+ // may utilize this to get started, and then state-sync the latest state, while still verifying the header chain.
+ StateHash *common.Hash `json:"stateHash,omitempty"`
}
func ReadGenesis(db ethdb.Database) (*Genesis, error) {
@@ -101,6 +108,10 @@ genesis.Coinbase = genesisHeader.Coinbase
genesis.BaseFee = genesisHeader.BaseFee
genesis.ExcessBlobGas = genesisHeader.ExcessBlobGas
genesis.BlobGasUsed = genesisHeader.BlobGasUsed
+ if genesis.Alloc == nil {
+ h := genesisHeader.Hash()
+ genesis.StateHash = &h
+ }
return &genesis, nil
}
@@ -245,6 +256,10 @@ // ChainOverrides contains the changes to chain config.
type ChainOverrides struct {
OverrideCancun *uint64
OverrideVerkle *uint64
+ // optimism
+ OverrideOptimismCanyon *uint64
+ ApplySuperchainUpgrades bool
+ OverrideOptimismInterop *uint64
}
// SetupGenesisBlock writes or updates the genesis block in db.
@@ -270,11 +285,42 @@ return params.AllEthashProtocolChanges, common.Hash{}, errGenesisNoConfig
}
applyOverrides := func(config *params.ChainConfig) {
if config != nil {
+ // If applying the superchain-registry to a known OP-Stack chain,
+ // then override the local chain-config with that from the registry.
+ if overrides != nil && overrides.ApplySuperchainUpgrades && config.IsOptimism() && config.ChainID != nil && config.ChainID.IsUint64() {
+ if _, ok := superchain.OPChains[config.ChainID.Uint64()]; ok {
+ conf, err := params.LoadOPStackChainConfig(config.ChainID.Uint64())
+ if err != nil {
+ log.Warn("failed to load chain config from superchain-registry, skipping override", "err", err, "chain_id", config.ChainID)
+ } else {
+ *config = *conf
+ }
+ }
+ }
+
+ if config.IsOptimism() && config.ChainID != nil && config.ChainID.Cmp(big.NewInt(params.OPGoerliChainID)) == 0 {
+ // Apply Optimism Goerli regolith time
+ config.RegolithTime = ¶ms.OptimismGoerliRegolithTime
+ }
+ if config.IsOptimism() && config.ChainID != nil && config.ChainID.Cmp(big.NewInt(params.BaseGoerliChainID)) == 0 {
+ // Apply Base Goerli regolith time
+ config.RegolithTime = ¶ms.BaseGoerliRegolithTime
+ }
if overrides != nil && overrides.OverrideCancun != nil {
config.CancunTime = overrides.OverrideCancun
}
if overrides != nil && overrides.OverrideVerkle != nil {
config.VerkleTime = overrides.OverrideVerkle
+ }
+ if overrides != nil && overrides.OverrideOptimismCanyon != nil {
+ config.CanyonTime = overrides.OverrideOptimismCanyon
+ config.ShanghaiTime = overrides.OverrideOptimismCanyon
+ if config.Optimism != nil && config.Optimism.EIP1559DenominatorCanyon == 0 {
+ config.Optimism.EIP1559DenominatorCanyon = 250
+ }
+ }
+ if overrides != nil && overrides.OverrideOptimismInterop != nil {
+ config.InteropTime = overrides.OverrideOptimismInterop
}
}
}
@@ -412,8 +458,15 @@ }
// ToBlock returns the genesis block according to genesis specification.
func (g *Genesis) ToBlock() *types.Block {
- root, err := g.Alloc.hash()
- if err != nil {
+ var root common.Hash
+ var err error
+ if g.StateHash != nil {
+ if len(g.Alloc) > 0 {
+ panic(fmt.Errorf("cannot both have genesis hash %s "+
+ "and non-empty state-allocation", *g.StateHash))
+ }
+ root = *g.StateHash
+ } else if root, err = g.Alloc.hash(); err != nil {
panic(err)
}
head := &types.Header{
Chain config cleanup
+3
-0
The optimism Goerli testnet used clique-config data to make geth internals accept blocks. Post-bedrock the beacon-consensus (i.e. follow Engine API) is now used, and the clique config is removed.
diff --git go-ethereum/core/rawdb/accessors_metadata.go op-geth/core/rawdb/accessors_metadata.go
index 859566f722f5960b0ce417514d6f20ff35a5cbe9..7dae87a98f2f5383b3b14f0d04012eb64c98a91b 100644
--- go-ethereum/core/rawdb/accessors_metadata.go
+++ op-geth/core/rawdb/accessors_metadata.go
@@ -64,6 +64,9 @@ if err := json.Unmarshal(data, &config); err != nil {
log.Error("Invalid chain config JSON", "hash", hash, "err", err)
return nil
}
+ if config.Optimism != nil {
+ config.Clique = nil // get rid of legacy clique data in chain config (optimism goerli issue)
+ }
return &config
}
Genesis loading
+6
-0
diff --git go-ethereum/core/gen_genesis.go op-geth/core/gen_genesis.go
index 38614252a38047715e012a2f5d91973f46fdd999..bd2a069b541a67b3445e18d74af95e69874ef46b 100644
--- go-ethereum/core/gen_genesis.go
+++ op-geth/core/gen_genesis.go
@@ -33,6 +33,7 @@ ParentHash common.Hash `json:"parentHash"`
BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas"`
ExcessBlobGas *math.HexOrDecimal64 `json:"excessBlobGas"`
BlobGasUsed *math.HexOrDecimal64 `json:"blobGasUsed"`
+ StateHash *common.Hash `json:"stateHash,omitempty"`
}
var enc Genesis
enc.Config = g.Config
@@ -55,6 +56,7 @@ enc.ParentHash = g.ParentHash
enc.BaseFee = (*math.HexOrDecimal256)(g.BaseFee)
enc.ExcessBlobGas = (*math.HexOrDecimal64)(g.ExcessBlobGas)
enc.BlobGasUsed = (*math.HexOrDecimal64)(g.BlobGasUsed)
+ enc.StateHash = g.StateHash
return json.Marshal(&enc)
}
@@ -76,6 +78,7 @@ ParentHash *common.Hash `json:"parentHash"`
BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas"`
ExcessBlobGas *math.HexOrDecimal64 `json:"excessBlobGas"`
BlobGasUsed *math.HexOrDecimal64 `json:"blobGasUsed"`
+ StateHash *common.Hash `json:"stateHash,omitempty"`
}
var dec Genesis
if err := json.Unmarshal(input, &dec); err != nil {
@@ -131,6 +134,9 @@ g.ExcessBlobGas = (*uint64)(dec.ExcessBlobGas)
}
if dec.BlobGasUsed != nil {
g.BlobGasUsed = (*uint64)(dec.BlobGasUsed)
+ }
+ if dec.StateHash != nil {
+ g.StateHash = dec.StateHash
}
return nil
}
Superchain config
+383
-0
Testing of the superchain configuration
diff --git go-ethereum/core/superchain.go op-geth/core/superchain.go
new file mode 100644
index 0000000000000000000000000000000000000000..96f68cedcf437f251d18e35764e4d49f4ddcab6b
--- /dev/null
+++ op-geth/core/superchain.go
@@ -0,0 +1,99 @@
+package core
+
+import (
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum-optimism/superchain-registry/superchain"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/params"
+)
+
+func LoadOPStackGenesis(chainID uint64) (*Genesis, error) {
+ chConfig, ok := superchain.OPChains[chainID]
+ if !ok {
+ return nil, fmt.Errorf("unknown chain ID: %d", chainID)
+ }
+
+ cfg, err := params.LoadOPStackChainConfig(chainID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to load params.ChainConfig for chain %d: %w", chainID, err)
+ }
+
+ gen, err := superchain.LoadGenesis(chainID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to load genesis definition for chain %d: %w", chainID, err)
+ }
+
+ genesis := &Genesis{
+ Config: cfg,
+ Nonce: gen.Nonce,
+ Timestamp: gen.Timestamp,
+ ExtraData: gen.ExtraData,
+ GasLimit: gen.GasLimit,
+ Difficulty: (*big.Int)(gen.Difficulty),
+ Mixhash: common.Hash(gen.Mixhash),
+ Coinbase: common.Address(gen.Coinbase),
+ Alloc: make(GenesisAlloc),
+ Number: gen.Number,
+ GasUsed: gen.GasUsed,
+ ParentHash: common.Hash(gen.ParentHash),
+ BaseFee: (*big.Int)(gen.BaseFee),
+ }
+
+ for addr, acc := range gen.Alloc {
+ var code []byte
+ if acc.CodeHash != ([32]byte{}) {
+ dat, err := superchain.LoadContractBytecode(acc.CodeHash)
+ if err != nil {
+ return nil, fmt.Errorf("failed to load bytecode %s of address %s in chain %d: %w", acc.CodeHash, addr, chainID, err)
+ }
+ code = dat
+ }
+ var storage map[common.Hash]common.Hash
+ if len(acc.Storage) > 0 {
+ storage = make(map[common.Hash]common.Hash)
+ for k, v := range acc.Storage {
+ storage[common.Hash(k)] = common.Hash(v)
+ }
+ }
+ bal := common.Big0
+ if acc.Balance != nil {
+ bal = (*big.Int)(acc.Balance)
+ }
+ genesis.Alloc[common.Address(addr)] = GenesisAccount{
+ Code: code,
+ Storage: storage,
+ Balance: bal,
+ Nonce: acc.Nonce,
+ }
+ }
+ if gen.StateHash != nil {
+ if len(gen.Alloc) > 0 {
+ return nil, fmt.Errorf("chain definition unexpectedly contains both allocation (%d) and state-hash %s", len(gen.Alloc), *gen.StateHash)
+ }
+ genesis.StateHash = (*common.Hash)(gen.StateHash)
+ }
+
+ genesisBlock := genesis.ToBlock()
+ genesisBlockHash := genesisBlock.Hash()
+ expectedHash := common.Hash([32]byte(chConfig.Genesis.L2.Hash))
+
+ // Verify we correctly produced the genesis config by recomputing the genesis-block-hash,
+ // and check the genesis matches the chain genesis definition.
+ if chConfig.Genesis.L2.Number != genesisBlock.NumberU64() {
+ switch chainID {
+ case params.OPMainnetChainID:
+ expectedHash = common.HexToHash("0x7ca38a1916c42007829c55e69d3e9a73265554b586a499015373241b8a3fa48b")
+ case params.OPGoerliChainID:
+ expectedHash = common.HexToHash("0xc1fc15cd51159b1f1e5cbc4b82e85c1447ddfa33c52cf1d98d14fba0d6354be1")
+ default:
+ return nil, fmt.Errorf("unknown stateless genesis definition for chain %d", chainID)
+ }
+ }
+ if expectedHash != genesisBlockHash {
+ return nil, fmt.Errorf("produced genesis with hash %s but expected %s", genesisBlockHash, expectedHash)
+ }
+ return genesis, nil
+}
diff --git go-ethereum/params/superchain.go op-geth/params/superchain.go
new file mode 100644
index 0000000000000000000000000000000000000000..174b0a16b176d7a9b3d502222c4e513159149420
--- /dev/null
+++ op-geth/params/superchain.go
@@ -0,0 +1,284 @@
+package params
+
+import (
+ "encoding/binary"
+ "fmt"
+ "math/big"
+ "sort"
+ "strings"
+
+ "github.com/ethereum-optimism/superchain-registry/superchain"
+ "github.com/ethereum/go-ethereum/common"
+)
+
+var OPStackSupport = ProtocolVersionV0{Build: [8]byte{}, Major: 5, Minor: 0, Patch: 0, PreRelease: 1}.Encode()
+
+func init() {
+ for id, ch := range superchain.OPChains {
+ NetworkNames[fmt.Sprintf("%d", id)] = ch.Name
+ }
+}
+
+func OPStackChainIDByName(name string) (uint64, error) {
+ for id, ch := range superchain.OPChains {
+ if ch.Chain+"-"+ch.Superchain == name {
+ return id, nil
+ }
+ }
+ return 0, fmt.Errorf("unknown chain %q", name)
+}
+
+func OPStackChainNames() (out []string) {
+ for _, ch := range superchain.OPChains {
+ out = append(out, ch.Chain+"-"+ch.Superchain)
+ }
+ sort.Strings(out)
+ return
+}
+
+func LoadOPStackChainConfig(chainID uint64) (*ChainConfig, error) {
+ chConfig, ok := superchain.OPChains[chainID]
+ if !ok {
+ return nil, fmt.Errorf("unknown chain ID: %d", chainID)
+ }
+ superchainConfig, ok := superchain.Superchains[chConfig.Superchain]
+ if !ok {
+ return nil, fmt.Errorf("unknown superchain %q", chConfig.Superchain)
+ }
+
+ genesisActivation := uint64(0)
+ out := &ChainConfig{
+ ChainID: new(big.Int).SetUint64(chainID),
+ HomesteadBlock: common.Big0,
+ DAOForkBlock: nil,
+ DAOForkSupport: false,
+ EIP150Block: common.Big0,
+ EIP155Block: common.Big0,
+ EIP158Block: common.Big0,
+ ByzantiumBlock: common.Big0,
+ ConstantinopleBlock: common.Big0,
+ PetersburgBlock: common.Big0,
+ IstanbulBlock: common.Big0,
+ MuirGlacierBlock: common.Big0,
+ BerlinBlock: common.Big0,
+ LondonBlock: common.Big0,
+ ArrowGlacierBlock: common.Big0,
+ GrayGlacierBlock: common.Big0,
+ MergeNetsplitBlock: common.Big0,
+ ShanghaiTime: superchainConfig.Config.CanyonTime, // Shanghai activates with Canyon
+ CancunTime: nil,
+ PragueTime: nil,
+ BedrockBlock: common.Big0,
+ RegolithTime: &genesisActivation,
+ CanyonTime: superchainConfig.Config.CanyonTime,
+ TerminalTotalDifficulty: common.Big0,
+ TerminalTotalDifficultyPassed: true,
+ Ethash: nil,
+ Clique: nil,
+ Optimism: &OptimismConfig{
+ EIP1559Elasticity: 6,
+ EIP1559Denominator: 50,
+ EIP1559DenominatorCanyon: 250,
+ },
+ }
+
+ // note: no actual parameters are being loaded, yet.
+ // Future superchain upgrades are loaded from the superchain chConfig and applied to the geth ChainConfig here.
+ _ = superchainConfig.Config
+
+ // special overrides for OP-Stack chains with pre-Regolith upgrade history
+ switch chainID {
+ case OPGoerliChainID:
+ out.LondonBlock = big.NewInt(4061224)
+ out.ArrowGlacierBlock = big.NewInt(4061224)
+ out.GrayGlacierBlock = big.NewInt(4061224)
+ out.MergeNetsplitBlock = big.NewInt(4061224)
+ out.BedrockBlock = big.NewInt(4061224)
+ out.RegolithTime = &OptimismGoerliRegolithTime
+ out.Optimism.EIP1559Elasticity = 10
+ case OPMainnetChainID:
+ out.BerlinBlock = big.NewInt(3950000)
+ out.LondonBlock = big.NewInt(105235063)
+ out.ArrowGlacierBlock = big.NewInt(105235063)
+ out.GrayGlacierBlock = big.NewInt(105235063)
+ out.MergeNetsplitBlock = big.NewInt(105235063)
+ out.BedrockBlock = big.NewInt(105235063)
+ case BaseGoerliChainID:
+ out.RegolithTime = &BaseGoerliRegolithTime
+ out.Optimism.EIP1559Elasticity = 10
+ case baseSepoliaChainID:
+ out.Optimism.EIP1559Elasticity = 10
+ case baseGoerliDevnetChainID:
+ out.RegolithTime = &baseGoerliDevnetRegolithTime
+ case pgnSepoliaChainID:
+ out.Optimism.EIP1559Elasticity = 2
+ out.Optimism.EIP1559Denominator = 8
+ case devnetChainID:
+ out.RegolithTime = &devnetRegolithTime
+ out.Optimism.EIP1559Elasticity = 10
+ case chaosnetChainID:
+ out.RegolithTime = &chaosnetRegolithTime
+ out.Optimism.EIP1559Elasticity = 10
+ }
+
+ return out, nil
+}
+
+// ProtocolVersion encodes the OP-Stack protocol version. See OP-Stack superchain-upgrade specification.
+type ProtocolVersion [32]byte
+
+func (p ProtocolVersion) MarshalText() ([]byte, error) {
+ return common.Hash(p).MarshalText()
+}
+
+func (p *ProtocolVersion) UnmarshalText(input []byte) error {
+ return (*common.Hash)(p).UnmarshalText(input)
+}
+
+func (p ProtocolVersion) Parse() (versionType uint8, build [8]byte, major, minor, patch, preRelease uint32) {
+ versionType = p[0]
+ if versionType != 0 {
+ return
+ }
+ // bytes 1:8 reserved for future use
+ copy(build[:], p[8:16]) // differentiates forks and custom-builds of standard protocol
+ major = binary.BigEndian.Uint32(p[16:20]) // incompatible API changes
+ minor = binary.BigEndian.Uint32(p[20:24]) // identifies additional functionality in backwards compatible manner
+ patch = binary.BigEndian.Uint32(p[24:28]) // identifies backward-compatible bug-fixes
+ preRelease = binary.BigEndian.Uint32(p[28:32]) // identifies unstable versions that may not satisfy the above
+ return
+}
+
+func (p ProtocolVersion) String() string {
+ versionType, build, major, minor, patch, preRelease := p.Parse()
+ if versionType != 0 {
+ return "v0.0.0-unknown." + common.Hash(p).String()
+ }
+ ver := fmt.Sprintf("v%d.%d.%d", major, minor, patch)
+ if preRelease != 0 {
+ ver += fmt.Sprintf("-%d", preRelease)
+ }
+ if build != ([8]byte{}) {
+ if humanBuildTag(build) {
+ ver += fmt.Sprintf("+%s", strings.TrimRight(string(build[:]), "\x00"))
+ } else {
+ ver += fmt.Sprintf("+0x%x", build)
+ }
+ }
+ return ver
+}
+
+// humanBuildTag identifies which build tag we can stringify for human-readable versions
+func humanBuildTag(v [8]byte) bool {
+ for i, c := range v { // following semver.org advertised regex, alphanumeric with '-' and '.', except leading '.'.
+ if c == 0 { // trailing zeroed are allowed
+ for _, d := range v[i:] {
+ if d != 0 {
+ return false
+ }
+ }
+ return true
+ }
+ if !((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-' || (c == '.' && i > 0)) {
+ return false
+ }
+ }
+ return true
+}
+
+// ProtocolVersionComparison is used to identify how far ahead/outdated a protocol version is relative to another.
+// This value is used in metrics and switch comparisons, to easily identify each type of version difference.
+// Negative values mean the version is outdated.
+// Positive values mean the version is up-to-date.
+// Matching versions have a 0.
+type ProtocolVersionComparison int
+
+const (
+ AheadMajor ProtocolVersionComparison = 4
+ OutdatedMajor ProtocolVersionComparison = -4
+ AheadMinor ProtocolVersionComparison = 3
+ OutdatedMinor ProtocolVersionComparison = -3
+ AheadPatch ProtocolVersionComparison = 2
+ OutdatedPatch ProtocolVersionComparison = -2
+ AheadPrerelease ProtocolVersionComparison = 1
+ OutdatedPrerelease ProtocolVersionComparison = -1
+ Matching ProtocolVersionComparison = 0
+ DiffVersionType ProtocolVersionComparison = 100
+ DiffBuild ProtocolVersionComparison = 101
+ EmptyVersion ProtocolVersionComparison = 102
+ InvalidVersion ProtocolVersionComparison = 103
+)
+
+func (p ProtocolVersion) Compare(other ProtocolVersion) (cmp ProtocolVersionComparison) {
+ if p == (ProtocolVersion{}) || (other == (ProtocolVersion{})) {
+ return EmptyVersion
+ }
+ aVersionType, aBuild, aMajor, aMinor, aPatch, aPreRelease := p.Parse()
+ bVersionType, bBuild, bMajor, bMinor, bPatch, bPreRelease := other.Parse()
+ if aVersionType != bVersionType {
+ return DiffVersionType
+ }
+ if aBuild != bBuild {
+ return DiffBuild
+ }
+ // max values are reserved, consider versions with these values invalid
+ if aMajor == ^uint32(0) || aMinor == ^uint32(0) || aPatch == ^uint32(0) || aPreRelease == ^uint32(0) ||
+ bMajor == ^uint32(0) || bMinor == ^uint32(0) || bPatch == ^uint32(0) || bPreRelease == ^uint32(0) {
+ return InvalidVersion
+ }
+ fn := func(a, b uint32, ahead, outdated ProtocolVersionComparison) ProtocolVersionComparison {
+ if a == b {
+ return Matching
+ }
+ if a > b {
+ return ahead
+ }
+ return outdated
+ }
+ if aPreRelease != 0 { // if A is a pre-release, then decrement the version before comparison
+ if aPatch != 0 {
+ aPatch -= 1
+ } else if aMinor != 0 {
+ aMinor -= 1
+ aPatch = ^uint32(0) // max value
+ } else if aMajor != 0 {
+ aMajor -= 1
+ aMinor = ^uint32(0) // max value
+ }
+ }
+ if bPreRelease != 0 { // if B is a pre-release, then decrement the version before comparison
+ if bPatch != 0 {
+ bPatch -= 1
+ } else if bMinor != 0 {
+ bMinor -= 1
+ bPatch = ^uint32(0) // max value
+ } else if bMajor != 0 {
+ bMajor -= 1
+ bMinor = ^uint32(0) // max value
+ }
+ }
+ if c := fn(aMajor, bMajor, AheadMajor, OutdatedMajor); c != Matching {
+ return c
+ }
+ if c := fn(aMinor, bMinor, AheadMinor, OutdatedMinor); c != Matching {
+ return c
+ }
+ if c := fn(aPatch, bPatch, AheadPatch, OutdatedPatch); c != Matching {
+ return c
+ }
+ return fn(aPreRelease, bPreRelease, AheadPrerelease, OutdatedPrerelease)
+}
+
+type ProtocolVersionV0 struct {
+ Build [8]byte
+ Major, Minor, Patch, PreRelease uint32
+}
+
+func (v ProtocolVersionV0) Encode() (out ProtocolVersion) {
+ copy(out[8:16], v.Build[:])
+ binary.BigEndian.PutUint32(out[16:20], v.Major)
+ binary.BigEndian.PutUint32(out[20:24], v.Minor)
+ binary.BigEndian.PutUint32(out[24:28], v.Patch)
+ binary.BigEndian.PutUint32(out[28:32], v.PreRelease)
+ return
+}
Node modifications
+464
-97
Changes to the node configuration and services.
CLI
+213
-9
Flags
+159
-4
Flag changes: - Transactions can be forwarded to an RPC for sequencing. - Historical calls can be forwarded to a legacy node. - The tx pool propagation can be enabled/disabled. - The Optimism bedrock fork activation can be changed for testing.
diff --git go-ethereum/cmd/utils/flags.go op-geth/cmd/utils/flags.go
index e9a7c7c110f9ace92ce3191174a9ab93827630a4..0c4c077c920897cdca419a15baceb7d75bc92384 100644
--- go-ethereum/cmd/utils/flags.go
+++ op-geth/cmd/utils/flags.go
@@ -156,6 +156,15 @@ Name: "holesky",
Usage: "Holesky network: pre-configured proof-of-stake test network",
Category: flags.EthCategory,
}
+
+ OPNetworkFlag = &cli.StringFlag{
+ Name: "op-network",
+ Aliases: []string{"beta.op-network"},
+ Usage: "Select a pre-configured OP-Stack network (warning: op-mainnet and op-goerli require special sync," +
+ " datadir is recommended), options: " + strings.Join(params.OPStackChainNames(), ", "),
+ Category: flags.EthCategory,
+ }
+
// Dev mode
DeveloperFlag = &cli.BoolFlag{
Name: "dev",
@@ -253,6 +262,16 @@ Name: "override.verkle",
Usage: "Manually specify the Verkle fork timestamp, overriding the bundled setting",
Category: flags.EthCategory,
}
+ OverrideOptimismCanyon = &flags.BigFlag{
+ Name: "override.canyon",
+ Usage: "Manually specify the Optimsim Canyon fork timestamp, overriding the bundled setting",
+ Category: flags.EthCategory,
+ }
+ OverrideOptimismInterop = &cli.Uint64Flag{
+ Name: "override.interop",
+ Usage: "Manually specify the Optimsim Interop feature-set fork timestamp, overriding the bundled setting",
+ Category: flags.EthCategory,
+ }
SyncModeFlag = &flags.TextMarshalerFlag{
Name: "syncmode",
Usage: `Blockchain sync mode ("snap", "full" or "light")`,
@@ -332,6 +351,11 @@ TxPoolJournalFlag = &cli.StringFlag{
Name: "txpool.journal",
Usage: "Disk journal for local transaction to survive node restarts",
Value: ethconfig.Defaults.TxPool.Journal,
+ Category: flags.TxPoolCategory,
+ }
+ TxPoolJournalRemotesFlag = &cli.BoolFlag{
+ Name: "txpool.journalremotes",
+ Usage: "Includes remote transactions in the journal",
Category: flags.TxPoolCategory,
}
TxPoolRejournalFlag = &cli.DurationFlag{
@@ -849,6 +873,59 @@ Usage: "Gas price below which gpo will ignore transactions",
Value: ethconfig.Defaults.GPO.IgnorePrice.Int64(),
Category: flags.GasPriceCategory,
}
+ GpoMinSuggestedPriorityFeeFlag = &cli.Int64Flag{
+ Name: "gpo.minsuggestedpriorityfee",
+ Usage: "Minimum transaction priority fee to suggest. Used on OP chains when blocks are not full.",
+ Value: ethconfig.Defaults.GPO.MinSuggestedPriorityFee.Int64(),
+ Category: flags.GasPriceCategory,
+ }
+
+ // Rollup Flags
+ RollupSequencerHTTPFlag = &cli.StringFlag{
+ Name: "rollup.sequencerhttp",
+ Usage: "HTTP endpoint for the sequencer mempool",
+ Category: flags.RollupCategory,
+ }
+
+ RollupHistoricalRPCFlag = &cli.StringFlag{
+ Name: "rollup.historicalrpc",
+ Usage: "RPC endpoint for historical data.",
+ Category: flags.RollupCategory,
+ }
+
+ RollupHistoricalRPCTimeoutFlag = &cli.StringFlag{
+ Name: "rollup.historicalrpctimeout",
+ Usage: "Timeout for historical RPC requests.",
+ Value: "5s",
+ Category: flags.RollupCategory,
+ }
+
+ RollupDisableTxPoolGossipFlag = &cli.BoolFlag{
+ Name: "rollup.disabletxpoolgossip",
+ Usage: "Disable transaction pool gossip.",
+ Category: flags.RollupCategory,
+ }
+ RollupEnableTxPoolAdmissionFlag = &cli.BoolFlag{
+ Name: "rollup.enabletxpooladmission",
+ Usage: "Add RPC-submitted transactions to the txpool (on by default if --rollup.sequencerhttp is not set).",
+ Category: flags.RollupCategory,
+ }
+ RollupComputePendingBlock = &cli.BoolFlag{
+ Name: "rollup.computependingblock",
+ Usage: "By default the pending block equals the latest block to save resources and not leak txs from the tx-pool, this flag enables computing of the pending block from the tx-pool instead.",
+ Category: flags.RollupCategory,
+ }
+ RollupHaltOnIncompatibleProtocolVersionFlag = &cli.StringFlag{
+ Name: "rollup.halt",
+ Usage: "Opt-in option to halt on incompatible protocol version requirements of the given level (major/minor/patch/none), as signaled through the Engine API by the rollup node",
+ Category: flags.RollupCategory,
+ }
+ RollupSuperchainUpgradesFlag = &cli.BoolFlag{
+ Name: "rollup.superchain-upgrades",
+ Aliases: []string{"beta.rollup.superchain-upgrades"},
+ Usage: "Apply superchain-registry config changes to the local chain-configuration",
+ Category: flags.RollupCategory,
+ }
// Metrics flags
MetricsEnabledFlag = &cli.BoolFlag{
@@ -954,7 +1031,7 @@ SepoliaFlag,
HoleskyFlag,
}
// NetworkFlags is the flag group of all built-in supported networks.
- NetworkFlags = append([]cli.Flag{MainnetFlag}, TestnetFlags...)
+ NetworkFlags = append([]cli.Flag{MainnetFlag, OPNetworkFlag}, TestnetFlags...)
// DatabaseFlags is the flag group of all database flags.
DatabaseFlags = []cli.Flag{
@@ -980,6 +1057,9 @@ return filepath.Join(path, "sepolia")
}
if ctx.Bool(HoleskyFlag.Name) {
return filepath.Join(path, "holesky")
+ }
+ if ctx.IsSet(OPNetworkFlag.Name) {
+ return filepath.Join(path, ctx.String(OPNetworkFlag.Name))
}
return path
}
@@ -1493,6 +1573,8 @@ case ctx.Bool(SepoliaFlag.Name) && cfg.DataDir == node.DefaultDataDir():
cfg.DataDir = filepath.Join(node.DefaultDataDir(), "sepolia")
case ctx.Bool(HoleskyFlag.Name) && cfg.DataDir == node.DefaultDataDir():
cfg.DataDir = filepath.Join(node.DefaultDataDir(), "holesky")
+ case ctx.IsSet(OPNetworkFlag.Name) && cfg.DataDir == node.DefaultDataDir():
+ cfg.DataDir = filepath.Join(node.DefaultDataDir(), ctx.String(OPNetworkFlag.Name))
}
}
@@ -1514,6 +1596,9 @@ }
if ctx.IsSet(GpoIgnoreGasPriceFlag.Name) {
cfg.IgnorePrice = big.NewInt(ctx.Int64(GpoIgnoreGasPriceFlag.Name))
}
+ if ctx.IsSet(GpoMinSuggestedPriorityFeeFlag.Name) {
+ cfg.MinSuggestedPriorityFee = big.NewInt(ctx.Int64(GpoMinSuggestedPriorityFeeFlag.Name))
+ }
}
func setTxPool(ctx *cli.Context, cfg *legacypool.Config) {
@@ -1532,6 +1617,9 @@ cfg.NoLocals = ctx.Bool(TxPoolNoLocalsFlag.Name)
}
if ctx.IsSet(TxPoolJournalFlag.Name) {
cfg.Journal = ctx.String(TxPoolJournalFlag.Name)
+ }
+ if ctx.IsSet(TxPoolJournalRemotesFlag.Name) {
+ cfg.JournalRemote = ctx.Bool(TxPoolJournalRemotesFlag.Name)
}
if ctx.IsSet(TxPoolRejournalFlag.Name) {
cfg.Rejournal = ctx.Duration(TxPoolRejournalFlag.Name)
@@ -1575,6 +1663,9 @@ }
if ctx.IsSet(MinerNewPayloadTimeout.Name) {
cfg.NewPayloadTimeout = ctx.Duration(MinerNewPayloadTimeout.Name)
}
+ if ctx.IsSet(RollupComputePendingBlock.Name) {
+ cfg.RollupComputePendingBlock = ctx.Bool(RollupComputePendingBlock.Name)
+ }
}
func setRequiredBlocks(ctx *cli.Context, cfg *ethconfig.Config) {
@@ -1649,7 +1740,7 @@
// SetEthConfig applies eth-related command line flags to the config.
func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
// Avoid conflicting network flags
- CheckExclusive(ctx, MainnetFlag, DeveloperFlag, GoerliFlag, SepoliaFlag, HoleskyFlag)
+ CheckExclusive(ctx, MainnetFlag, DeveloperFlag, GoerliFlag, SepoliaFlag, HoleskyFlag, OPNetworkFlag)
CheckExclusive(ctx, LightServeFlag, SyncModeFlag, "light")
CheckExclusive(ctx, DeveloperFlag, ExternalSignerFlag) // Can't use both ephemeral unlocked and external signer
@@ -1790,6 +1881,20 @@ } else {
cfg.EthDiscoveryURLs = SplitAndTrim(urls)
}
}
+ // Only configure sequencer http flag if we're running in verifier mode i.e. --mine is disabled.
+ if ctx.IsSet(RollupSequencerHTTPFlag.Name) && !ctx.IsSet(MiningEnabledFlag.Name) {
+ cfg.RollupSequencerHTTP = ctx.String(RollupSequencerHTTPFlag.Name)
+ }
+ if ctx.IsSet(RollupHistoricalRPCFlag.Name) {
+ cfg.RollupHistoricalRPC = ctx.String(RollupHistoricalRPCFlag.Name)
+ }
+ if ctx.IsSet(RollupHistoricalRPCTimeoutFlag.Name) {
+ cfg.RollupHistoricalRPCTimeout = ctx.Duration(RollupHistoricalRPCTimeoutFlag.Name)
+ }
+ cfg.RollupDisableTxPoolGossip = ctx.Bool(RollupDisableTxPoolGossipFlag.Name)
+ cfg.RollupDisableTxPoolAdmission = cfg.RollupSequencerHTTP != "" && !ctx.Bool(RollupEnableTxPoolAdmissionFlag.Name)
+ cfg.RollupHaltOnIncompatibleProtocolVersion = ctx.String(RollupHaltOnIncompatibleProtocolVersionFlag.Name)
+ cfg.ApplySuperchainUpgrades = ctx.Bool(RollupSuperchainUpgradesFlag.Name)
// Override any default configs for hard coded networks.
switch {
case ctx.Bool(MainnetFlag.Name):
@@ -1876,6 +1981,12 @@ }
if !ctx.IsSet(MinerGasPriceFlag.Name) {
cfg.Miner.GasPrice = big.NewInt(1)
}
+ case ctx.IsSet(OPNetworkFlag.Name):
+ genesis := MakeGenesis(ctx)
+ if !ctx.IsSet(NetworkIdFlag.Name) {
+ cfg.NetworkId = genesis.Config.ChainID.Uint64()
+ }
+ cfg.Genesis = genesis
default:
if cfg.NetworkId == 1 {
SetDNSDiscoveryDefaults(cfg, params.MainnetGenesisHash)
@@ -2086,8 +2197,7 @@ }
func IsNetworkPreset(ctx *cli.Context) bool {
for _, flag := range NetworkFlags {
- bFlag, _ := flag.(*cli.BoolFlag)
- if ctx.IsSet(bFlag.Name) {
+ if ctx.IsSet(flag.Names()[0]) {
return true
}
}
@@ -2129,6 +2239,17 @@ case ctx.Bool(SepoliaFlag.Name):
genesis = core.DefaultSepoliaGenesisBlock()
case ctx.Bool(GoerliFlag.Name):
genesis = core.DefaultGoerliGenesisBlock()
+ case ctx.IsSet(OPNetworkFlag.Name):
+ name := ctx.String(OPNetworkFlag.Name)
+ ch, err := params.OPStackChainIDByName(name)
+ if err != nil {
+ Fatalf("failed to load OP-Stack chain %q: %v", name, err)
+ }
+ genesis, err := core.LoadOPStackGenesis(ch)
+ if err != nil {
+ Fatalf("failed to load genesis for OP-Stack chain %q (%d): %v", name, ch, err)
+ }
+ return genesis
case ctx.Bool(DeveloperFlag.Name):
Fatalf("Developer chains are ephemeral")
}
diff --git go-ethereum/cmd/geth/main.go op-geth/cmd/geth/main.go
index 2d4fe3dc060cd779272ff5607ce4386cee5967ed..d19641986bae873627352714bdaae400b28e3874 100644
--- go-ethereum/cmd/geth/main.go
+++ op-geth/cmd/geth/main.go
@@ -67,10 +67,13 @@ utils.USBFlag,
utils.SmartCardDaemonPathFlag,
utils.OverrideCancun,
utils.OverrideVerkle,
+ utils.OverrideOptimismCanyon,
+ utils.OverrideOptimismInterop,
utils.EnablePersonal,
utils.TxPoolLocalsFlag,
utils.TxPoolNoLocalsFlag,
utils.TxPoolJournalFlag,
+ utils.TxPoolJournalRemotesFlag,
utils.TxPoolRejournalFlag,
utils.TxPoolPriceLimitFlag,
utils.TxPoolPriceBumpFlag,
@@ -143,6 +146,14 @@ utils.GpoBlocksFlag,
utils.GpoPercentileFlag,
utils.GpoMaxGasPriceFlag,
utils.GpoIgnoreGasPriceFlag,
+ utils.GpoMinSuggestedPriorityFeeFlag,
+ utils.RollupSequencerHTTPFlag,
+ utils.RollupHistoricalRPCFlag,
+ utils.RollupHistoricalRPCTimeoutFlag,
+ utils.RollupDisableTxPoolGossipFlag,
+ utils.RollupComputePendingBlock,
+ utils.RollupHaltOnIncompatibleProtocolVersionFlag,
+ utils.RollupSuperchainUpgradesFlag,
configFileFlag,
}, utils.NetworkFlags, utils.DatabaseFlags)
@@ -303,6 +314,9 @@ 5. Networking is disabled; there is no listen-address, the maximum number of peers is set
to 0, and discovery is disabled.
`)
+ case ctx.IsSet(utils.OPNetworkFlag.Name):
+ log.Info("Starting geth on an OP network...", "network", ctx.String(utils.OPNetworkFlag.Name))
+
case !ctx.IsSet(utils.NetworkIdFlag.Name):
log.Info("Starting Geth on Ethereum mainnet...")
}
@@ -314,7 +328,14 @@ !ctx.IsSet(utils.SepoliaFlag.Name) &&
!ctx.IsSet(utils.GoerliFlag.Name) &&
!ctx.IsSet(utils.DeveloperFlag.Name) {
// Nope, we're really on mainnet. Bump that cache up!
+ // Note: If we don't set the OPNetworkFlag and have already initialized the database, we may hit this case.
log.Info("Bumping default cache on mainnet", "provided", ctx.Int(utils.CacheFlag.Name), "updated", 4096)
+ ctx.Set(utils.CacheFlag.Name, strconv.Itoa(4096))
+ }
+ } else if ctx.String(utils.SyncModeFlag.Name) != "light" && !ctx.IsSet(utils.CacheFlag.Name) && ctx.IsSet(utils.OPNetworkFlag.Name) {
+ // We haven't set the cache, but may used the OP network flag we may be on an OP stack mainnet.
+ if strings.Contains(ctx.String(utils.OPNetworkFlag.Name), "mainnet") {
+ log.Info("Bumping default cache on mainnet", "provided", ctx.Int(utils.CacheFlag.Name), "updated", 4096, "network", ctx.String(utils.OPNetworkFlag.Name))
ctx.Set(utils.CacheFlag.Name, strconv.Itoa(4096))
}
}
diff --git go-ethereum/internal/flags/categories.go op-geth/internal/flags/categories.go
index 487684d98b3e4388fae941d96e9e7ffce6c1b214..de5ef2714a8fae569ca7ce9905b8ff0ecdd073b9 100644
--- go-ethereum/internal/flags/categories.go
+++ op-geth/internal/flags/categories.go
@@ -32,6 +32,7 @@ NetworkingCategory = "NETWORKING"
MinerCategory = "MINER"
GasPriceCategory = "GAS PRICE ORACLE"
VMCategory = "VIRTUAL MACHINE"
+ RollupCategory = "ROLLUP NODE"
LoggingCategory = "LOGGING AND DEBUGGING"
MetricsCategory = "METRICS AND STATS"
MiscCategory = "MISC"
diff --git go-ethereum/cmd/geth/config.go op-geth/cmd/geth/config.go
index 027dac7bd60a26b61cad572185653820a74769bf..194f779842f48871969206321372b826edd6cb7f 100644
--- go-ethereum/cmd/geth/config.go
+++ op-geth/cmd/geth/config.go
@@ -174,10 +174,22 @@ if ctx.IsSet(utils.OverrideCancun.Name) {
v := ctx.Uint64(utils.OverrideCancun.Name)
cfg.Eth.OverrideCancun = &v
}
+
+ if ctx.IsSet(utils.OverrideOptimismCanyon.Name) {
+ v := ctx.Uint64(utils.OverrideOptimismCanyon.Name)
+ cfg.Eth.OverrideOptimismCanyon = &v
+ }
+
+ if ctx.IsSet(utils.OverrideOptimismInterop.Name) {
+ v := ctx.Uint64(utils.OverrideOptimismInterop.Name)
+ cfg.Eth.OverrideOptimismInterop = &v
+ }
+
if ctx.IsSet(utils.OverrideVerkle.Name) {
v := ctx.Uint64(utils.OverrideVerkle.Name)
cfg.Eth.OverrideVerkle = &v
}
+
backend, eth := utils.RegisterEthService(stack, &cfg.Eth)
// Create gauge with geth system and build information
Versioning
+54
-5
List the op-geth and upstream go-ethereum versions.
diff --git go-ethereum/cmd/geth/misccmd.go op-geth/cmd/geth/misccmd.go
index f3530c30fb69fe08024d9f62a1a377d416c684d9..e7fb108ebfb6a065eb1232ced8fcdf1c49eee4c5 100644
--- go-ethereum/cmd/geth/misccmd.go
+++ op-geth/cmd/geth/misccmd.go
@@ -80,6 +80,7 @@ }
if git.Date != "" {
fmt.Println("Git Commit Date:", git.Date)
}
+ fmt.Println("Upstream Version:", params.GethVersionWithMeta)
fmt.Println("Architecture:", runtime.GOARCH)
fmt.Println("Go Version:", runtime.Version())
fmt.Println("Operating System:", runtime.GOOS)
diff --git go-ethereum/params/version.go op-geth/params/version.go
index 5fb9631f1b3bee78137816e93b39e28908fb3519..291d8ca7c508e2a9a5da50d9d5314fb2c96a4aa4 100644
--- go-ethereum/params/version.go
+++ op-geth/params/version.go
@@ -18,8 +18,11 @@ package params
import (
"fmt"
+ "regexp"
+ "strconv"
)
+// Version is the version of upstream geth
const (
VersionMajor = 1 // Major version component of the current release
VersionMinor = 13 // Minor version component of the current release
@@ -27,14 +30,56 @@ VersionPatch = 5 // Patch version component of the current release
VersionMeta = "stable" // Version metadata to append to the version string
)
+// OPVersion is the version of op-geth
+var (
+ OPVersionMajor = 0 // Major version component of the current release
+ OPVersionMinor = 1 // Minor version component of the current release
+ OPVersionPatch = 0 // Patch version component of the current release
+ OPVersionMeta = "unstable" // Version metadata to append to the version string
+)
+
+// This is set at build-time by the linker when the build is done by build/ci.go.
+var gitTag string
+
+// Override the version variables if the gitTag was set at build time.
+var _ = func() (_ string) {
+ semver := regexp.MustCompile(`^v([0-9]+)\.([0-9]+)\.([0-9]+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+)?$`)
+ version := semver.FindStringSubmatch(gitTag)
+ if version == nil {
+ return
+ }
+ if version[4] == "" {
+ version[4] = "stable"
+ }
+ OPVersionMajor, _ = strconv.Atoi(version[1])
+ OPVersionMinor, _ = strconv.Atoi(version[2])
+ OPVersionPatch, _ = strconv.Atoi(version[3])
+ OPVersionMeta = version[4]
+ return
+}()
+
// Version holds the textual version string.
var Version = func() string {
- return fmt.Sprintf("%d.%d.%d", VersionMajor, VersionMinor, VersionPatch)
+ return fmt.Sprintf("%d.%d.%d", OPVersionMajor, OPVersionMinor, OPVersionPatch)
}()
// VersionWithMeta holds the textual version string including the metadata.
var VersionWithMeta = func() string {
v := Version
+ if OPVersionMeta != "" {
+ v += "-" + OPVersionMeta
+ }
+ return v
+}()
+
+// GethVersion holds the textual geth version string.
+var GethVersion = func() string {
+ return fmt.Sprintf("%d.%d.%d", VersionMajor, VersionMinor, VersionPatch)
+}()
+
+// GethVersionWithMeta holds the textual geth version string including the metadata.
+var GethVersionWithMeta = func() string {
+ v := GethVersion
if VersionMeta != "" {
v += "-" + VersionMeta
}
@@ -46,8 +91,8 @@ // "1.8.11-dea1ce05" for stable releases, or "1.8.13-unstable-21c059b6" for unstable
// releases.
func ArchiveVersion(gitCommit string) string {
vsn := Version
- if VersionMeta != "stable" {
- vsn += "-" + VersionMeta
+ if OPVersionMeta != "stable" {
+ vsn += "-" + OPVersionMeta
}
if len(gitCommit) >= 8 {
vsn += "-" + gitCommit[:8]
@@ -60,7 +105,7 @@ vsn := VersionWithMeta
if len(gitCommit) >= 8 {
vsn += "-" + gitCommit[:8]
}
- if (VersionMeta != "stable") && (gitDate != "") {
+ if (OPVersionMeta != "stable") && (gitDate != "") {
vsn += "-" + gitDate
}
return vsn
diff --git go-ethereum/build/ci.go op-geth/build/ci.go
index afe1c332b8cb199d4aa640282b1817a06e308b25..ab39dbcfb31995cf4bbb42f06e28b89a490ebc5a 100644
--- go-ethereum/build/ci.go
+++ op-geth/build/ci.go
@@ -247,6 +247,9 @@ if env.Commit != "" {
ld = append(ld, "-X", "github.com/ethereum/go-ethereum/internal/version.gitCommit="+env.Commit)
ld = append(ld, "-X", "github.com/ethereum/go-ethereum/internal/version.gitDate="+env.Date)
}
+ if env.Tag != "" {
+ ld = append(ld, "-X", "github.com/ethereum/go-ethereum/params.gitTag="+env.Tag)
+ }
// Strip DWARF on darwin. This used to be required for certain things,
// and there is no downside to this, so we just keep doing it.
if runtime.GOOS == "darwin" {
@@ -541,7 +544,7 @@ switch {
case env.Branch == "master":
tags = []string{"latest"}
case strings.HasPrefix(env.Tag, "v1."):
- tags = []string{"stable", fmt.Sprintf("release-1.%d", params.VersionMinor), "v" + params.Version}
+ tags = []string{"stable", fmt.Sprintf("release-1.%d", params.OPVersionMinor), "v" + params.Version}
}
// If architecture specific image builds are requested, build and push them
if *image {
Node config
+21
-6
diff --git go-ethereum/eth/ethconfig/config.go op-geth/eth/ethconfig/config.go
index 5e8f58efdb35b519228d388ffcdc17ccca967ec7..ff164ed84149e3d2903071d6b06a395440922edb 100644
--- go-ethereum/eth/ethconfig/config.go
+++ op-geth/eth/ethconfig/config.go
@@ -38,12 +38,13 @@ )
// FullNodeGPO contains default gasprice oracle settings for full node.
var FullNodeGPO = gasprice.Config{
- Blocks: 20,
- Percentile: 60,
- MaxHeaderHistory: 1024,
- MaxBlockHistory: 1024,
- MaxPrice: gasprice.DefaultMaxPrice,
- IgnorePrice: gasprice.DefaultIgnorePrice,
+ Blocks: 20,
+ Percentile: 60,
+ MaxHeaderHistory: 1024,
+ MaxBlockHistory: 1024,
+ MaxPrice: gasprice.DefaultMaxPrice,
+ IgnorePrice: gasprice.DefaultIgnorePrice,
+ MinSuggestedPriorityFee: gasprice.DefaultMinSuggestedPriorityFee,
}
// LightClientGPO contains default gasprice oracle settings for light client.
@@ -169,6 +170,20 @@ OverrideCancun *uint64 `toml:",omitempty"`
// OverrideVerkle (TODO: remove after the fork)
OverrideVerkle *uint64 `toml:",omitempty"`
+
+ OverrideOptimismCanyon *uint64 `toml:",omitempty"`
+
+ OverrideOptimismInterop *uint64 `toml:",omitempty"`
+
+ // ApplySuperchainUpgrades requests the node to load chain-configuration from the superchain-registry.
+ ApplySuperchainUpgrades bool `toml:",omitempty"`
+
+ RollupSequencerHTTP string
+ RollupHistoricalRPC string
+ RollupHistoricalRPCTimeout time.Duration
+ RollupDisableTxPoolGossip bool
+ RollupDisableTxPoolAdmission bool
+ RollupHaltOnIncompatibleProtocolVersion string
}
// CreateConsensusEngine creates a consensus engine for the given chain config.
Tx gossip disable option
+24
-3
diff --git go-ethereum/eth/handler.go op-geth/eth/handler.go
index f0021e56446ce30718de3a1b51b4d60865d5bf9d..55584f88c40e873ad30860361af43a5953235593 100644
--- go-ethereum/eth/handler.go
+++ op-geth/eth/handler.go
@@ -93,6 +93,7 @@ Sync downloader.SyncMode // Whether to snap or full sync
BloomCache uint64 // Megabytes to alloc for snap sync bloom
EventMux *event.TypeMux // Legacy event mux, deprecate for `feed`
RequiredBlocks map[uint64]common.Hash // Hard coded map of required block hashes for sync challenges
+ NoTxGossip bool // Disable P2P transaction gossip
}
type handler struct {
@@ -106,6 +107,8 @@ database ethdb.Database
txpool txPool
chain *core.BlockChain
maxPeers int
+
+ noTxGossip bool
downloader *downloader.Downloader
blockFetcher *fetcher.BlockFetcher
@@ -142,6 +145,7 @@ forkFilter: forkid.NewFilter(config.Chain),
eventMux: config.EventMux,
database: config.Database,
txpool: config.TxPool,
+ noTxGossip: config.NoTxGossip,
chain: config.Chain,
peers: newPeerSet(),
merger: config.Merger,
@@ -169,9 +173,10 @@ log.Warn("Switch sync mode from full sync to snap sync", "reason", "head state missing")
}
} else {
head := h.chain.CurrentBlock()
- if head.Number.Uint64() > 0 && h.chain.HasState(head.Root) {
+ if head.Number.Uint64() > 0 && h.chain.HasState(head.Root) && (!config.Chain.Config().IsOptimism() || head.Number.Cmp(config.Chain.Config().BedrockBlock) != 0) {
// Print warning log if database is not empty to run snap sync.
- log.Warn("Switch sync mode from snap sync to full sync", "reason", "snap sync complete")
+ // For OP chains, snap sync from bedrock block is allowed.
+ log.Warn("Switch sync mode from snap sync to full sync")
} else {
// If snap sync was requested and our database is empty, grant it
h.snapSync.Store(true)
diff --git go-ethereum/eth/handler_eth.go op-geth/eth/handler_eth.go
index 2a839f615f63be71674a4a55034c14c50b52ea6e..6dbe03e2140998359201a75f6b7a6a9ca2cb9c75 100644
--- go-ethereum/eth/handler_eth.go
+++ op-geth/eth/handler_eth.go
@@ -34,7 +34,20 @@ // packets that are sent as replies or broadcasts.
type ethHandler handler
func (h *ethHandler) Chain() *core.BlockChain { return h.chain }
-func (h *ethHandler) TxPool() eth.TxPool { return h.txpool }
+
+// NilPool satisfies the TxPool interface but does not return any tx in the
+// pool. It is used to disable transaction gossip.
+type NilPool struct{}
+
+// NilPool Get always returns nil
+func (n NilPool) Get(hash common.Hash) *types.Transaction { return nil }
+
+func (h *ethHandler) TxPool() eth.TxPool {
+ if h.noTxGossip {
+ return &NilPool{}
+ }
+ return h.txpool
+}
// RunPeer is invoked when a peer joins on the `eth` protocol.
func (h *ethHandler) RunPeer(peer *eth.Peer, hand eth.Handler) error {
@@ -52,6 +65,9 @@
// AcceptTxs retrieves whether transaction processing is enabled on the node
// or if inbound transactions should simply be dropped.
func (h *ethHandler) AcceptTxs() bool {
+ if h.noTxGossip {
+ return false
+ }
return h.synced.Load()
}
Warn on missing hardfork data
+4
-0
diff --git go-ethereum/core/blockchain.go op-geth/core/blockchain.go
index f458da82573ef87bb0793dd9e012401522eafb38..e27b9420dc72067eece1d8ec7dfe06e0fc4d72b5 100644
--- go-ethereum/core/blockchain.go
+++ op-geth/core/blockchain.go
@@ -285,6 +285,10 @@ }
log.Info(strings.Repeat("-", 153))
log.Info("")
+ if chainConfig.IsOptimism() && chainConfig.RegolithTime == nil {
+ log.Warn("Optimism RegolithTime has not been set")
+ }
+
bc := &BlockChain{
chainConfig: chainConfig,
cacheConfig: cacheConfig,
Optional Engine API extensions
+66
-0
diff --git go-ethereum/eth/catalyst/superchain.go op-geth/eth/catalyst/superchain.go
new file mode 100644
index 0000000000000000000000000000000000000000..503519889f4f050ad0aa739525022044fa842bc6
--- /dev/null
+++ op-geth/eth/catalyst/superchain.go
@@ -0,0 +1,66 @@
+package catalyst
+
+import (
+ "fmt"
+
+ "github.com/ethereum/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/metrics"
+ "github.com/ethereum/go-ethereum/params"
+)
+
+var (
+ requiredProtocolDeltaGauge = metrics.NewRegisteredGauge("superchain/required/delta", nil)
+ recommendedProtocolDeltaGauge = metrics.NewRegisteredGauge("superchain/recommended/delta", nil)
+)
+
+type SuperchainSignal struct {
+ Recommended params.ProtocolVersion `json:"recommended"`
+ Required params.ProtocolVersion `json:"required"`
+}
+
+func (api *ConsensusAPI) SignalSuperchainV1(signal *SuperchainSignal) (params.ProtocolVersion, error) {
+ if signal == nil {
+ log.Info("Received empty superchain version signal", "local", params.OPStackSupport)
+ return params.OPStackSupport, nil
+ }
+ // update metrics and log any warnings/info
+ requiredProtocolDeltaGauge.Update(int64(params.OPStackSupport.Compare(signal.Required)))
+ recommendedProtocolDeltaGauge.Update(int64(params.OPStackSupport.Compare(signal.Recommended)))
+ logger := log.New("local", params.OPStackSupport, "required", signal.Required, "recommended", signal.Recommended)
+ LogProtocolVersionSupport(logger, params.OPStackSupport, signal.Recommended, "recommended")
+ LogProtocolVersionSupport(logger, params.OPStackSupport, signal.Required, "required")
+
+ if err := api.eth.HandleRequiredProtocolVersion(signal.Required); err != nil {
+ log.Error("Failed to handle required protocol version", "err", err, "required", signal.Required)
+ return params.OPStackSupport, err
+ }
+
+ return params.OPStackSupport, nil
+}
+
+func LogProtocolVersionSupport(logger log.Logger, local, other params.ProtocolVersion, name string) {
+ switch local.Compare(other) {
+ case params.AheadMajor:
+ logger.Info(fmt.Sprintf("Ahead with major %s protocol version change", name))
+ case params.AheadMinor, params.AheadPatch, params.AheadPrerelease:
+ logger.Debug(fmt.Sprintf("Ahead with compatible %s protocol version change", name))
+ case params.Matching:
+ logger.Debug(fmt.Sprintf("Latest %s protocol version is supported", name))
+ case params.OutdatedMajor:
+ logger.Error(fmt.Sprintf("Outdated with major %s protocol change", name))
+ case params.OutdatedMinor:
+ logger.Warn(fmt.Sprintf("Outdated with minor backward-compatible %s protocol change", name))
+ case params.OutdatedPatch:
+ logger.Info(fmt.Sprintf("Outdated with support backward-compatible %s protocol change", name))
+ case params.OutdatedPrerelease:
+ logger.Debug(fmt.Sprintf("New %s protocol pre-release is available", name))
+ case params.DiffBuild:
+ logger.Debug(fmt.Sprintf("Ignoring %s protocolversion signal, local build is different", name))
+ case params.DiffVersionType:
+ logger.Warn(fmt.Sprintf("Failed to recognize %s protocol version signal version-type", name))
+ case params.EmptyVersion:
+ logger.Debug(fmt.Sprintf("No %s protocol version available to check", name))
+ case params.InvalidVersion:
+ logger.Warn(fmt.Sprintf("Invalid protocol version comparison with %s", name))
+ }
+}
Support legacy DBs when snap-syncing
+9
-1
Snap-sync does not serve unprefixed code by default.
diff --git go-ethereum/core/blockchain_reader.go op-geth/core/blockchain_reader.go
index 466a86c144155008b88c5652b5313f44a900263d..30fbcb883b9aecfade40aa4db1c1c25032822c41 100644
--- go-ethereum/core/blockchain_reader.go
+++ op-geth/core/blockchain_reader.go
@@ -319,6 +319,14 @@ // in Verkle scheme. Fix it once snap-sync is supported for Verkle.
return bc.stateCache.(codeReader).ContractCodeWithPrefix(common.Address{}, hash)
}
+// ContractCode retrieves a blob of data associated with a contract hash
+// either from ephemeral in-memory cache, or from persistent storage.
+// This is a legacy-method, replaced by ContractCodeWithPrefix,
+// but required for old databases to serve snap-sync.
+func (bc *BlockChain) ContractCode(hash common.Hash) ([]byte, error) {
+ return bc.stateCache.ContractCode(common.Address{}, hash)
+}
+
// State returns a new mutable state based on the current HEAD block.
func (bc *BlockChain) State() (*state.StateDB, error) {
return bc.StateAt(bc.CurrentBlock().Root)
diff --git go-ethereum/eth/protocols/snap/handler.go op-geth/eth/protocols/snap/handler.go
index bd7ce9e71543c944c1a8e1ff2dd2dfcaa95d236f..0d1aac0cefb71a0894099fbdc40ad7cd4f0b204f 100644
--- go-ethereum/eth/protocols/snap/handler.go
+++ op-geth/eth/protocols/snap/handler.go
@@ -469,7 +469,7 @@ if hash == types.EmptyCodeHash {
// Peers should not request the empty code, but if they do, at
// least sent them back a correct response without db lookups
codes = append(codes, []byte{})
- } else if blob, err := chain.ContractCodeWithPrefix(hash); err == nil {
+ } else if blob, err := chain.ContractCode(hash); err == nil {
codes = append(codes, blob)
bytes += uint64(len(blob))
}
Discv5 node discovery
+1
-0
Fix discv5 option to allow discv5 to be an active source for node-discovery.
diff --git go-ethereum/p2p/server.go op-geth/p2p/server.go
index 8f42765a8c263fbfacacddd1bac8f331db67ad11..7975b787bd7dad63981ec1022b7d32477ace2e7c 100644
--- go-ethereum/p2p/server.go
+++ op-geth/p2p/server.go
@@ -579,6 +579,7 @@ srv.DiscV5, err = discover.ListenV5(sconn, srv.localnode, cfg)
if err != nil {
return err
}
+ srv.discmix.AddSource(srv.DiscV5.RandomNodes())
}
// Add protocol-specific discovery sources.
Generated TOML config update
+126
-78
diff --git go-ethereum/eth/ethconfig/gen_config.go op-geth/eth/ethconfig/gen_config.go
index 2abddc9e0d3878344f5ac547a0ac369db0d4a985..27ade8781daf6977509b46979976db974a4b46de 100644
--- go-ethereum/eth/ethconfig/gen_config.go
+++ op-geth/eth/ethconfig/gen_config.go
@@ -17,45 +17,53 @@
// MarshalTOML marshals as TOML.
func (c Config) MarshalTOML() (interface{}, error) {
type Config struct {
- Genesis *core.Genesis `toml:",omitempty"`
- NetworkId uint64
- SyncMode downloader.SyncMode
- EthDiscoveryURLs []string
- SnapDiscoveryURLs []string
- NoPruning bool
- NoPrefetch bool
- TxLookupLimit uint64 `toml:",omitempty"`
- TransactionHistory uint64 `toml:",omitempty"`
- StateHistory uint64 `toml:",omitempty"`
- StateScheme string `toml:",omitempty"`
- RequiredBlocks map[uint64]common.Hash `toml:"-"`
- LightServ int `toml:",omitempty"`
- LightIngress int `toml:",omitempty"`
- LightEgress int `toml:",omitempty"`
- LightPeers int `toml:",omitempty"`
- LightNoPrune bool `toml:",omitempty"`
- LightNoSyncServe bool `toml:",omitempty"`
- SkipBcVersionCheck bool `toml:"-"`
- DatabaseHandles int `toml:"-"`
- DatabaseCache int
- DatabaseFreezer string
- TrieCleanCache int
- TrieDirtyCache int
- TrieTimeout time.Duration
- SnapshotCache int
- Preimages bool
- FilterLogCacheSize int
- Miner miner.Config
- TxPool legacypool.Config
- BlobPool blobpool.Config
- GPO gasprice.Config
- EnablePreimageRecording bool
- DocRoot string `toml:"-"`
- RPCGasCap uint64
- RPCEVMTimeout time.Duration
- RPCTxFeeCap float64
- OverrideCancun *uint64 `toml:",omitempty"`
- OverrideVerkle *uint64 `toml:",omitempty"`
+ Genesis *core.Genesis `toml:",omitempty"`
+ NetworkId uint64
+ SyncMode downloader.SyncMode
+ EthDiscoveryURLs []string
+ SnapDiscoveryURLs []string
+ NoPruning bool
+ NoPrefetch bool
+ TxLookupLimit uint64 `toml:",omitempty"`
+ TransactionHistory uint64 `toml:",omitempty"`
+ StateHistory uint64 `toml:",omitempty"`
+ StateScheme string `toml:",omitempty"`
+ RequiredBlocks map[uint64]common.Hash `toml:"-"`
+ LightServ int `toml:",omitempty"`
+ LightIngress int `toml:",omitempty"`
+ LightEgress int `toml:",omitempty"`
+ LightPeers int `toml:",omitempty"`
+ LightNoPrune bool `toml:",omitempty"`
+ LightNoSyncServe bool `toml:",omitempty"`
+ SkipBcVersionCheck bool `toml:"-"`
+ DatabaseHandles int `toml:"-"`
+ DatabaseCache int
+ DatabaseFreezer string
+ TrieCleanCache int
+ TrieDirtyCache int
+ TrieTimeout time.Duration
+ SnapshotCache int
+ Preimages bool
+ FilterLogCacheSize int
+ Miner miner.Config
+ TxPool legacypool.Config
+ BlobPool blobpool.Config
+ GPO gasprice.Config
+ EnablePreimageRecording bool
+ DocRoot string `toml:"-"`
+ RPCGasCap uint64
+ RPCEVMTimeout time.Duration
+ RPCTxFeeCap float64
+ OverrideCancun *uint64 `toml:",omitempty"`
+ OverrideVerkle *uint64 `toml:",omitempty"`
+ OverrideOptimismCanyon *uint64 `toml:",omitempty"`
+ ApplySuperchainUpgrades bool `toml:",omitempty"`
+ RollupSequencerHTTP string
+ RollupHistoricalRPC string
+ RollupHistoricalRPCTimeout time.Duration
+ RollupDisableTxPoolGossip bool
+ RollupDisableTxPoolAdmission bool
+ RollupHaltOnIncompatibleProtocolVersion string
}
var enc Config
enc.Genesis = c.Genesis
@@ -97,51 +105,67 @@ enc.RPCEVMTimeout = c.RPCEVMTimeout
enc.RPCTxFeeCap = c.RPCTxFeeCap
enc.OverrideCancun = c.OverrideCancun
enc.OverrideVerkle = c.OverrideVerkle
+ enc.OverrideOptimismCanyon = c.OverrideOptimismCanyon
+ enc.ApplySuperchainUpgrades = c.ApplySuperchainUpgrades
+ enc.RollupSequencerHTTP = c.RollupSequencerHTTP
+ enc.RollupHistoricalRPC = c.RollupHistoricalRPC
+ enc.RollupHistoricalRPCTimeout = c.RollupHistoricalRPCTimeout
+ enc.RollupDisableTxPoolGossip = c.RollupDisableTxPoolGossip
+ enc.RollupDisableTxPoolAdmission = c.RollupDisableTxPoolAdmission
+ enc.RollupHaltOnIncompatibleProtocolVersion = c.RollupHaltOnIncompatibleProtocolVersion
return &enc, nil
}
// UnmarshalTOML unmarshals from TOML.
func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
type Config struct {
- Genesis *core.Genesis `toml:",omitempty"`
- NetworkId *uint64
- SyncMode *downloader.SyncMode
- EthDiscoveryURLs []string
- SnapDiscoveryURLs []string
- NoPruning *bool
- NoPrefetch *bool
- TxLookupLimit *uint64 `toml:",omitempty"`
- TransactionHistory *uint64 `toml:",omitempty"`
- StateHistory *uint64 `toml:",omitempty"`
- StateScheme *string `toml:",omitempty"`
- RequiredBlocks map[uint64]common.Hash `toml:"-"`
- LightServ *int `toml:",omitempty"`
- LightIngress *int `toml:",omitempty"`
- LightEgress *int `toml:",omitempty"`
- LightPeers *int `toml:",omitempty"`
- LightNoPrune *bool `toml:",omitempty"`
- LightNoSyncServe *bool `toml:",omitempty"`
- SkipBcVersionCheck *bool `toml:"-"`
- DatabaseHandles *int `toml:"-"`
- DatabaseCache *int
- DatabaseFreezer *string
- TrieCleanCache *int
- TrieDirtyCache *int
- TrieTimeout *time.Duration
- SnapshotCache *int
- Preimages *bool
- FilterLogCacheSize *int
- Miner *miner.Config
- TxPool *legacypool.Config
- BlobPool *blobpool.Config
- GPO *gasprice.Config
- EnablePreimageRecording *bool
- DocRoot *string `toml:"-"`
- RPCGasCap *uint64
- RPCEVMTimeout *time.Duration
- RPCTxFeeCap *float64
- OverrideCancun *uint64 `toml:",omitempty"`
- OverrideVerkle *uint64 `toml:",omitempty"`
+ Genesis *core.Genesis `toml:",omitempty"`
+ NetworkId *uint64
+ SyncMode *downloader.SyncMode
+ EthDiscoveryURLs []string
+ SnapDiscoveryURLs []string
+ NoPruning *bool
+ NoPrefetch *bool
+ TxLookupLimit *uint64 `toml:",omitempty"`
+ TransactionHistory *uint64 `toml:",omitempty"`
+ StateHistory *uint64 `toml:",omitempty"`
+ StateScheme *string `toml:",omitempty"`
+ RequiredBlocks map[uint64]common.Hash `toml:"-"`
+ LightServ *int `toml:",omitempty"`
+ LightIngress *int `toml:",omitempty"`
+ LightEgress *int `toml:",omitempty"`
+ LightPeers *int `toml:",omitempty"`
+ LightNoPrune *bool `toml:",omitempty"`
+ LightNoSyncServe *bool `toml:",omitempty"`
+ SkipBcVersionCheck *bool `toml:"-"`
+ DatabaseHandles *int `toml:"-"`
+ DatabaseCache *int
+ DatabaseFreezer *string
+ TrieCleanCache *int
+ TrieDirtyCache *int
+ TrieTimeout *time.Duration
+ SnapshotCache *int
+ Preimages *bool
+ FilterLogCacheSize *int
+ Miner *miner.Config
+ TxPool *legacypool.Config
+ BlobPool *blobpool.Config
+ GPO *gasprice.Config
+ EnablePreimageRecording *bool
+ DocRoot *string `toml:"-"`
+ RPCGasCap *uint64
+ RPCEVMTimeout *time.Duration
+ RPCTxFeeCap *float64
+ OverrideCancun *uint64 `toml:",omitempty"`
+ OverrideVerkle *uint64 `toml:",omitempty"`
+ OverrideOptimismCanyon *uint64 `toml:",omitempty"`
+ ApplySuperchainUpgrades *bool `toml:",omitempty"`
+ RollupSequencerHTTP *string
+ RollupHistoricalRPC *string
+ RollupHistoricalRPCTimeout *time.Duration
+ RollupDisableTxPoolGossip *bool
+ RollupDisableTxPoolAdmission *bool
+ RollupHaltOnIncompatibleProtocolVersion *string
}
var dec Config
if err := unmarshal(&dec); err != nil {
@@ -263,6 +287,30 @@ c.OverrideCancun = dec.OverrideCancun
}
if dec.OverrideVerkle != nil {
c.OverrideVerkle = dec.OverrideVerkle
+ }
+ if dec.OverrideOptimismCanyon != nil {
+ c.OverrideOptimismCanyon = dec.OverrideOptimismCanyon
+ }
+ if dec.ApplySuperchainUpgrades != nil {
+ c.ApplySuperchainUpgrades = *dec.ApplySuperchainUpgrades
+ }
+ if dec.RollupSequencerHTTP != nil {
+ c.RollupSequencerHTTP = *dec.RollupSequencerHTTP
+ }
+ if dec.RollupHistoricalRPC != nil {
+ c.RollupHistoricalRPC = *dec.RollupHistoricalRPC
+ }
+ if dec.RollupHistoricalRPCTimeout != nil {
+ c.RollupHistoricalRPCTimeout = *dec.RollupHistoricalRPCTimeout
+ }
+ if dec.RollupDisableTxPoolGossip != nil {
+ c.RollupDisableTxPoolGossip = *dec.RollupDisableTxPoolGossip
+ }
+ if dec.RollupDisableTxPoolAdmission != nil {
+ c.RollupDisableTxPoolAdmission = *dec.RollupDisableTxPoolAdmission
+ }
+ if dec.RollupHaltOnIncompatibleProtocolVersion != nil {
+ c.RollupHaltOnIncompatibleProtocolVersion = *dec.RollupHaltOnIncompatibleProtocolVersion
}
return nil
}
User API enhancements
+1278
-103
Encode the Deposit Tx properties, the L1 costs, and daisy-chain RPC-calls for pre-Bedrock historical data
Receipts metadata
+300
-37
Pre-Bedrock L1-cost receipt data is loaded from the database if available, and post-Bedrock the L1-cost metadata is hydrated on-the-fly based on the L1 fee information in the corresponding block.
diff --git go-ethereum/core/types/receipt.go op-geth/core/types/receipt.go
index 4f96fde59c44278beee06e9846e158c2501644e6..6c0d863ef69a335e42973e18f3d3c664fabcf881 100644
--- go-ethereum/core/types/receipt.go
+++ op-geth/core/types/receipt.go
@@ -46,6 +46,9 @@ ReceiptStatusFailed = uint64(0)
// ReceiptStatusSuccessful is the status code of a transaction if execution succeeded.
ReceiptStatusSuccessful = uint64(1)
+
+ // The version number for post-canyon deposit receipts.
+ CanyonDepositReceiptVersion = uint64(1)
)
// Receipt represents the results of a transaction.
@@ -58,7 +61,8 @@ CumulativeGasUsed uint64 `json:"cumulativeGasUsed" gencodec:"required"`
Bloom Bloom `json:"logsBloom" gencodec:"required"`
Logs []*Log `json:"logs" gencodec:"required"`
- // Implementation fields: These fields are added by geth when processing a transaction.
+ // Implementation fields: These fields are added by geth when processing a transaction or retrieving a receipt.
+ // gencodec annotated fields: these are stored in the chain database.
TxHash common.Hash `json:"transactionHash" gencodec:"required"`
ContractAddress common.Address `json:"contractAddress"`
GasUsed uint64 `json:"gasUsed" gencodec:"required"`
@@ -66,11 +70,25 @@ EffectiveGasPrice *big.Int `json:"effectiveGasPrice"` // required, but tag omitted for backwards compatibility
BlobGasUsed uint64 `json:"blobGasUsed,omitempty"`
BlobGasPrice *big.Int `json:"blobGasPrice,omitempty"`
+ // DepositNonce was introduced in Regolith to store the actual nonce used by deposit transactions
+ // The state transition process ensures this is only set for Regolith deposit transactions.
+ DepositNonce *uint64 `json:"depositNonce,omitempty"`
+ // DepositReceiptVersion was introduced in Canyon to indicate an update to how receipt hashes
+ // should be computed when set. The state transition process ensures this is only set for
+ // post-Canyon deposit transactions.
+ DepositReceiptVersion *uint64 `json:"depositReceiptVersion,omitempty"`
+
// Inclusion information: These fields provide information about the inclusion of the
// transaction corresponding to this receipt.
BlockHash common.Hash `json:"blockHash,omitempty"`
BlockNumber *big.Int `json:"blockNumber,omitempty"`
TransactionIndex uint `json:"transactionIndex"`
+
+ // OVM legacy: extend receipts with their L1 price (if a rollup tx)
+ L1GasPrice *big.Int `json:"l1GasPrice,omitempty"`
+ L1GasUsed *big.Int `json:"l1GasUsed,omitempty"`
+ L1Fee *big.Int `json:"l1Fee,omitempty"`
+ FeeScalar *big.Float `json:"l1FeeScalar,omitempty"`
}
type receiptMarshaling struct {
@@ -84,6 +102,14 @@ BlobGasUsed hexutil.Uint64
BlobGasPrice *hexutil.Big
BlockNumber *hexutil.Big
TransactionIndex hexutil.Uint
+
+ // Optimism
+ L1GasPrice *hexutil.Big
+ L1GasUsed *hexutil.Big
+ L1Fee *hexutil.Big
+ FeeScalar *big.Float
+ DepositNonce *hexutil.Uint64
+ DepositReceiptVersion *hexutil.Uint64
}
// receiptRLP is the consensus encoding of a receipt.
@@ -94,11 +120,98 @@ Bloom Bloom
Logs []*Log
}
+type depositReceiptRLP struct {
+ PostStateOrStatus []byte
+ CumulativeGasUsed uint64
+ Bloom Bloom
+ Logs []*Log
+ // DepositNonce was introduced in Regolith to store the actual nonce used by deposit transactions.
+ // Must be nil for any transactions prior to Regolith or that aren't deposit transactions.
+ DepositNonce *uint64 `rlp:"optional"`
+ // Receipt hash post-Regolith but pre-Canyon inadvertently did not include the above
+ // DepositNonce. Post Canyon, receipts will have a non-empty DepositReceiptVersion indicating
+ // which post-Canyon receipt hash function to invoke.
+ DepositReceiptVersion *uint64 `rlp:"optional"`
+}
+
// storedReceiptRLP is the storage encoding of a receipt.
type storedReceiptRLP struct {
PostStateOrStatus []byte
CumulativeGasUsed uint64
Logs []*Log
+ // DepositNonce was introduced in Regolith to store the actual nonce used by deposit transactions.
+ // Must be nil for any transactions prior to Regolith or that aren't deposit transactions.
+ DepositNonce *uint64 `rlp:"optional"`
+ // Receipt hash post-Regolith but pre-Canyon inadvertently did not include the above
+ // DepositNonce. Post Canyon, receipts will have a non-empty DepositReceiptVersion indicating
+ // which post-Canyon receipt hash function to invoke.
+ DepositReceiptVersion *uint64 `rlp:"optional"`
+}
+
+// LegacyOptimismStoredReceiptRLP is the pre bedrock storage encoding of a
+// receipt. It will only exist in the database if it was migrated using the
+// migration tool. Nodes that sync using snap-sync will not have any of these
+// entries.
+type LegacyOptimismStoredReceiptRLP struct {
+ PostStateOrStatus []byte
+ CumulativeGasUsed uint64
+ Logs []*LogForStorage
+ L1GasUsed *big.Int
+ L1GasPrice *big.Int
+ L1Fee *big.Int
+ FeeScalar string
+}
+
+// LogForStorage is a wrapper around a Log that handles
+// backward compatibility with prior storage formats.
+type LogForStorage Log
+
+// EncodeRLP implements rlp.Encoder.
+func (l *LogForStorage) EncodeRLP(w io.Writer) error {
+ rl := Log{Address: l.Address, Topics: l.Topics, Data: l.Data}
+ return rlp.Encode(w, &rl)
+}
+
+type legacyRlpStorageLog struct {
+ Address common.Address
+ Topics []common.Hash
+ Data []byte
+ BlockNumber uint64
+ TxHash common.Hash
+ TxIndex uint
+ BlockHash common.Hash
+ Index uint
+}
+
+// DecodeRLP implements rlp.Decoder.
+//
+// Note some redundant fields(e.g. block number, tx hash etc) will be assembled later.
+func (l *LogForStorage) DecodeRLP(s *rlp.Stream) error {
+ blob, err := s.Raw()
+ if err != nil {
+ return err
+ }
+ var dec Log
+ err = rlp.DecodeBytes(blob, &dec)
+ if err == nil {
+ *l = LogForStorage{
+ Address: dec.Address,
+ Topics: dec.Topics,
+ Data: dec.Data,
+ }
+ } else {
+ // Try to decode log with previous definition.
+ var dec legacyRlpStorageLog
+ err = rlp.DecodeBytes(blob, &dec)
+ if err == nil {
+ *l = LogForStorage{
+ Address: dec.Address,
+ Topics: dec.Topics,
+ Data: dec.Data,
+ }
+ }
+ }
+ return err
}
// NewReceipt creates a barebone transaction receipt, copying the init fields.
@@ -136,7 +249,13 @@
// encodeTyped writes the canonical encoding of a typed receipt to w.
func (r *Receipt) encodeTyped(data *receiptRLP, w *bytes.Buffer) error {
w.WriteByte(r.Type)
- return rlp.Encode(w, data)
+ switch r.Type {
+ case DepositTxType:
+ withNonce := &depositReceiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs, r.DepositNonce, r.DepositReceiptVersion}
+ return rlp.Encode(w, withNonce)
+ default:
+ return rlp.Encode(w, data)
+ }
}
// MarshalBinary returns the consensus encoding of the receipt.
@@ -212,6 +331,16 @@ return err
}
r.Type = b[0]
return r.setFromRLP(data)
+ case DepositTxType:
+ var data depositReceiptRLP
+ err := rlp.DecodeBytes(b[1:], &data)
+ if err != nil {
+ return err
+ }
+ r.Type = b[0]
+ r.DepositNonce = data.DepositNonce
+ r.DepositReceiptVersion = data.DepositReceiptVersion
+ return r.setFromRLP(receiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, data.Bloom, data.Logs})
default:
return ErrTxTypeNotSupported
}
@@ -275,6 +404,12 @@ return err
}
}
w.ListEnd(logList)
+ if r.DepositNonce != nil {
+ w.WriteUint64(*r.DepositNonce)
+ if r.DepositReceiptVersion != nil {
+ w.WriteUint64(*r.DepositReceiptVersion)
+ }
+ }
w.ListEnd(outerList)
return w.Flush()
}
@@ -282,8 +417,51 @@
// DecodeRLP implements rlp.Decoder, and loads both consensus and implementation
// fields of a receipt from an RLP stream.
func (r *ReceiptForStorage) DecodeRLP(s *rlp.Stream) error {
+ // Retrieve the entire receipt blob as we need to try multiple decoders
+ blob, err := s.Raw()
+ if err != nil {
+ return err
+ }
+ // First try to decode the latest receipt database format, try the pre-bedrock Optimism legacy format otherwise.
+ if err := decodeStoredReceiptRLP(r, blob); err == nil {
+ return nil
+ }
+ return decodeLegacyOptimismReceiptRLP(r, blob)
+}
+
+func decodeLegacyOptimismReceiptRLP(r *ReceiptForStorage, blob []byte) error {
+ var stored LegacyOptimismStoredReceiptRLP
+ if err := rlp.DecodeBytes(blob, &stored); err != nil {
+ return err
+ }
+ if err := (*Receipt)(r).setStatus(stored.PostStateOrStatus); err != nil {
+ return err
+ }
+ r.CumulativeGasUsed = stored.CumulativeGasUsed
+ r.Logs = make([]*Log, len(stored.Logs))
+ for i, log := range stored.Logs {
+ r.Logs[i] = (*Log)(log)
+ }
+ r.Bloom = CreateBloom(Receipts{(*Receipt)(r)})
+ // UsingOVM
+ scalar := new(big.Float)
+ if stored.FeeScalar != "" {
+ var ok bool
+ scalar, ok = scalar.SetString(stored.FeeScalar)
+ if !ok {
+ return errors.New("cannot parse fee scalar")
+ }
+ }
+ r.L1GasUsed = stored.L1GasUsed
+ r.L1GasPrice = stored.L1GasPrice
+ r.L1Fee = stored.L1Fee
+ r.FeeScalar = scalar
+ return nil
+}
+
+func decodeStoredReceiptRLP(r *ReceiptForStorage, blob []byte) error {
var stored storedReceiptRLP
- if err := s.Decode(&stored); err != nil {
+ if err := rlp.DecodeBytes(blob, &stored); err != nil {
return err
}
if err := (*Receipt)(r).setStatus(stored.PostStateOrStatus); err != nil {
@@ -292,7 +470,10 @@ }
r.CumulativeGasUsed = stored.CumulativeGasUsed
r.Logs = stored.Logs
r.Bloom = CreateBloom(Receipts{(*Receipt)(r)})
-
+ if stored.DepositNonce != nil {
+ r.DepositNonce = stored.DepositNonce
+ r.DepositReceiptVersion = stored.DepositReceiptVersion
+ }
return nil
}
@@ -302,7 +483,10 @@
// Len returns the number of receipts in this list.
func (rs Receipts) Len() int { return len(rs) }
-// EncodeIndex encodes the i'th receipt to w.
+// EncodeIndex encodes the i'th receipt to w. For DepositTxType receipts with non-nil DepositNonce
+// but nil DepositReceiptVersion, the output will differ than calling r.MarshalBinary(); this
+// behavior difference should not be changed to preserve backwards compatibility of receipt-root
+// hash computation.
func (rs Receipts) EncodeIndex(i int, w *bytes.Buffer) {
r := rs[i]
data := &receiptRLP{r.statusEncoding(), r.CumulativeGasUsed, r.Bloom, r.Logs}
@@ -314,6 +498,14 @@ w.WriteByte(r.Type)
switch r.Type {
case AccessListTxType, DynamicFeeTxType, BlobTxType:
rlp.Encode(w, data)
+ case DepositTxType:
+ if r.DepositReceiptVersion != nil {
+ // post-canyon receipt hash computation update
+ depositData := &depositReceiptRLP{data.PostStateOrStatus, data.CumulativeGasUsed, r.Bloom, r.Logs, r.DepositNonce, r.DepositReceiptVersion}
+ rlp.Encode(w, depositData)
+ } else {
+ rlp.Encode(w, data)
+ }
default:
// For unsupported types, write nothing. Since this is for
// DeriveSha, the error will be caught matching the derived hash
@@ -351,7 +543,11 @@ // The contract address can be derived from the transaction itself
if txs[i].To() == nil {
// Deriving the signer is expensive, only do if it's actually needed
from, _ := Sender(signer, txs[i])
- rs[i].ContractAddress = crypto.CreateAddress(from, txs[i].Nonce())
+ nonce := txs[i].Nonce()
+ if rs[i].DepositNonce != nil {
+ nonce = *rs[i].DepositNonce
+ }
+ rs[i].ContractAddress = crypto.CreateAddress(from, nonce)
} else {
rs[i].ContractAddress = common.Address{}
}
@@ -373,5 +569,28 @@ rs[i].Logs[j].Index = logIndex
logIndex++
}
}
+ if config.Optimism != nil && len(txs) >= 2 { // need at least an info tx and a non-info tx
+ if data := txs[0].Data(); len(data) >= 4+32*8 { // function selector + 8 arguments to setL1BlockValues
+ l1Basefee := new(big.Int).SetBytes(data[4+32*2 : 4+32*3]) // arg index 2
+ overhead := new(big.Int).SetBytes(data[4+32*6 : 4+32*7]) // arg index 6
+ scalar := new(big.Int).SetBytes(data[4+32*7 : 4+32*8]) // arg index 7
+ fscalar := new(big.Float).SetInt(scalar) // legacy: format fee scalar as big Float
+ fdivisor := new(big.Float).SetUint64(1_000_000) // 10**6, i.e. 6 decimals
+ feeScalar := new(big.Float).Quo(fscalar, fdivisor)
+ for i := 0; i < len(rs); i++ {
+ if !txs[i].IsDepositTx() {
+ gas := txs[i].RollupDataGas().DataGas(time, config)
+ rs[i].L1GasPrice = l1Basefee
+ // GasUsed reported in receipt should include the overhead
+ rs[i].L1GasUsed = new(big.Int).Add(new(big.Int).SetUint64(gas), overhead)
+ rs[i].L1Fee = L1Cost(gas, l1Basefee, overhead, scalar)
+ rs[i].FeeScalar = feeScalar
+ }
+ }
+ } else {
+ return fmt.Errorf("L1 info tx only has %d bytes, cannot read gas price parameters", len(data))
+ }
+ }
+
return nil
}
diff --git go-ethereum/core/types/gen_receipt_json.go op-geth/core/types/gen_receipt_json.go
index 4c641a972795f70ce27e98baf1b3c2e032fe89c2..14a074b2ba2d14f46976dffb76200724e3cf916e 100644
--- go-ethereum/core/types/gen_receipt_json.go
+++ op-geth/core/types/gen_receipt_json.go
@@ -16,21 +16,27 @@
// 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"`
- Bloom Bloom `json:"logsBloom" gencodec:"required"`
- Logs []*Log `json:"logs" gencodec:"required"`
- TxHash common.Hash `json:"transactionHash" gencodec:"required"`
- ContractAddress common.Address `json:"contractAddress"`
- GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"`
- EffectiveGasPrice *hexutil.Big `json:"effectiveGasPrice"`
- BlobGasUsed hexutil.Uint64 `json:"blobGasUsed,omitempty"`
- BlobGasPrice *hexutil.Big `json:"blobGasPrice,omitempty"`
- BlockHash common.Hash `json:"blockHash,omitempty"`
- BlockNumber *hexutil.Big `json:"blockNumber,omitempty"`
- TransactionIndex hexutil.Uint `json:"transactionIndex"`
+ Type hexutil.Uint64 `json:"type,omitempty"`
+ PostState hexutil.Bytes `json:"root"`
+ Status hexutil.Uint64 `json:"status"`
+ CumulativeGasUsed hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"`
+ Bloom Bloom `json:"logsBloom" gencodec:"required"`
+ Logs []*Log `json:"logs" gencodec:"required"`
+ TxHash common.Hash `json:"transactionHash" gencodec:"required"`
+ ContractAddress common.Address `json:"contractAddress"`
+ GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"`
+ EffectiveGasPrice *hexutil.Big `json:"effectiveGasPrice"`
+ BlobGasUsed hexutil.Uint64 `json:"blobGasUsed,omitempty"`
+ BlobGasPrice *hexutil.Big `json:"blobGasPrice,omitempty"`
+ DepositNonce *hexutil.Uint64 `json:"depositNonce,omitempty"`
+ DepositReceiptVersion *hexutil.Uint64 `json:"depositReceiptVersion,omitempty"`
+ BlockHash common.Hash `json:"blockHash,omitempty"`
+ BlockNumber *hexutil.Big `json:"blockNumber,omitempty"`
+ TransactionIndex hexutil.Uint `json:"transactionIndex"`
+ L1GasPrice *hexutil.Big `json:"l1GasPrice,omitempty"`
+ L1GasUsed *hexutil.Big `json:"l1GasUsed,omitempty"`
+ L1Fee *hexutil.Big `json:"l1Fee,omitempty"`
+ FeeScalar *big.Float `json:"l1FeeScalar,omitempty"`
}
var enc Receipt
enc.Type = hexutil.Uint64(r.Type)
@@ -45,30 +51,42 @@ enc.GasUsed = hexutil.Uint64(r.GasUsed)
enc.EffectiveGasPrice = (*hexutil.Big)(r.EffectiveGasPrice)
enc.BlobGasUsed = hexutil.Uint64(r.BlobGasUsed)
enc.BlobGasPrice = (*hexutil.Big)(r.BlobGasPrice)
+ enc.DepositNonce = (*hexutil.Uint64)(r.DepositNonce)
+ enc.DepositReceiptVersion = (*hexutil.Uint64)(r.DepositReceiptVersion)
enc.BlockHash = r.BlockHash
enc.BlockNumber = (*hexutil.Big)(r.BlockNumber)
enc.TransactionIndex = hexutil.Uint(r.TransactionIndex)
+ enc.L1GasPrice = (*hexutil.Big)(r.L1GasPrice)
+ enc.L1GasUsed = (*hexutil.Big)(r.L1GasUsed)
+ enc.L1Fee = (*hexutil.Big)(r.L1Fee)
+ enc.FeeScalar = r.FeeScalar
return json.Marshal(&enc)
}
// 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"`
- Bloom *Bloom `json:"logsBloom" gencodec:"required"`
- Logs []*Log `json:"logs" gencodec:"required"`
- TxHash *common.Hash `json:"transactionHash" gencodec:"required"`
- ContractAddress *common.Address `json:"contractAddress"`
- GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"`
- EffectiveGasPrice *hexutil.Big `json:"effectiveGasPrice"`
- BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed,omitempty"`
- BlobGasPrice *hexutil.Big `json:"blobGasPrice,omitempty"`
- BlockHash *common.Hash `json:"blockHash,omitempty"`
- BlockNumber *hexutil.Big `json:"blockNumber,omitempty"`
- TransactionIndex *hexutil.Uint `json:"transactionIndex"`
+ Type *hexutil.Uint64 `json:"type,omitempty"`
+ PostState *hexutil.Bytes `json:"root"`
+ Status *hexutil.Uint64 `json:"status"`
+ CumulativeGasUsed *hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"`
+ Bloom *Bloom `json:"logsBloom" gencodec:"required"`
+ Logs []*Log `json:"logs" gencodec:"required"`
+ TxHash *common.Hash `json:"transactionHash" gencodec:"required"`
+ ContractAddress *common.Address `json:"contractAddress"`
+ GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"`
+ EffectiveGasPrice *hexutil.Big `json:"effectiveGasPrice"`
+ BlobGasUsed *hexutil.Uint64 `json:"blobGasUsed,omitempty"`
+ BlobGasPrice *hexutil.Big `json:"blobGasPrice,omitempty"`
+ DepositNonce *hexutil.Uint64 `json:"depositNonce,omitempty"`
+ DepositReceiptVersion *hexutil.Uint64 `json:"depositReceiptVersion,omitempty"`
+ BlockHash *common.Hash `json:"blockHash,omitempty"`
+ BlockNumber *hexutil.Big `json:"blockNumber,omitempty"`
+ TransactionIndex *hexutil.Uint `json:"transactionIndex"`
+ L1GasPrice *hexutil.Big `json:"l1GasPrice,omitempty"`
+ L1GasUsed *hexutil.Big `json:"l1GasUsed,omitempty"`
+ L1Fee *hexutil.Big `json:"l1Fee,omitempty"`
+ FeeScalar *big.Float `json:"l1FeeScalar,omitempty"`
}
var dec Receipt
if err := json.Unmarshal(input, &dec); err != nil {
@@ -115,6 +133,12 @@ }
if dec.BlobGasPrice != nil {
r.BlobGasPrice = (*big.Int)(dec.BlobGasPrice)
}
+ if dec.DepositNonce != nil {
+ r.DepositNonce = (*uint64)(dec.DepositNonce)
+ }
+ if dec.DepositReceiptVersion != nil {
+ r.DepositReceiptVersion = (*uint64)(dec.DepositReceiptVersion)
+ }
if dec.BlockHash != nil {
r.BlockHash = *dec.BlockHash
}
@@ -123,6 +147,18 @@ r.BlockNumber = (*big.Int)(dec.BlockNumber)
}
if dec.TransactionIndex != nil {
r.TransactionIndex = uint(*dec.TransactionIndex)
+ }
+ if dec.L1GasPrice != nil {
+ r.L1GasPrice = (*big.Int)(dec.L1GasPrice)
+ }
+ if dec.L1GasUsed != nil {
+ r.L1GasUsed = (*big.Int)(dec.L1GasUsed)
+ }
+ if dec.L1Fee != nil {
+ r.L1Fee = (*big.Int)(dec.L1Fee)
+ }
+ if dec.FeeScalar != nil {
+ r.FeeScalar = dec.FeeScalar
}
return nil
}
diff --git go-ethereum/core/rawdb/accessors_chain.go op-geth/core/rawdb/accessors_chain.go
index d9a89fe90c99c9b3235880e384305c06907acaad..40d60236c13bcc4b15a50a0649a2fd00d104a8c5 100644
--- go-ethereum/core/rawdb/accessors_chain.go
+++ op-geth/core/rawdb/accessors_chain.go
@@ -643,7 +643,6 @@ log.Error("Missing body but have receipt", "hash", hash, "number", number)
return nil
}
header := ReadHeader(db, hash, number)
-
var baseFee *big.Int
if header == nil {
baseFee = big.NewInt(0)
@@ -693,6 +692,15 @@ type storedReceiptRLP struct {
PostStateOrStatus []byte
CumulativeGasUsed uint64
Logs []*types.Log
+
+ // Remaining fields are declared to allow the receipt RLP to be parsed without errors.
+ // However, they must not be used as they may not be populated correctly due to multiple receipt formats
+ // being combined into a single list of optional fields which can be mistaken for each other.
+ // DepositNonce (*uint64) from Regolith deposit tx receipts will be parsed into L1GasUsed
+ L1GasUsed *big.Int `rlp:"optional"` // OVM legacy
+ L1GasPrice *big.Int `rlp:"optional"` // OVM legacy
+ L1Fee *big.Int `rlp:"optional"` // OVM legacy
+ FeeScalar string `rlp:"optional"` // OVM legacy
}
// ReceiptLogs is a barebone version of ReceiptForStorage which only keeps
API Backend
+125
-9
Forward transactions to the sequencer if configured.
diff --git go-ethereum/eth/api_backend.go op-geth/eth/api_backend.go
index 601e5551585724b2d7d28c5295bd3b271037d821..b109dd9a97c569be932b2454980a89b94e290ce1 100644
--- go-ethereum/eth/api_backend.go
+++ op-geth/eth/api_backend.go
@@ -19,12 +19,14 @@
import (
"context"
"errors"
+ "fmt"
"math/big"
"time"
"github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/consensus"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/bloombits"
@@ -37,6 +39,7 @@ "github.com/ethereum/go-ethereum/eth/gasprice"
"github.com/ethereum/go-ethereum/eth/tracers"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/miner"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rpc"
@@ -46,6 +49,7 @@ // EthAPIBackend implements ethapi.Backend and tracers.Backend for full nodes
type EthAPIBackend struct {
extRPCEnabled bool
allowUnprotectedTxs bool
+ disableTxPool bool
eth *Ethereum
gpo *gasprice.Oracle
}
@@ -190,10 +194,11 @@ func (b *EthAPIBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
// Pending state is only known by the miner
if number == rpc.PendingBlockNumber {
block, state := b.eth.miner.Pending()
- if block == nil || state == nil {
- return nil, nil, errors.New("pending state is not available")
+ if block != nil && state != nil {
+ return state, block.Header(), nil
+ } else {
+ number = rpc.LatestBlockNumber // fall back to latest state
}
- return state, block.Header(), nil
}
// Otherwise resolve the block number and return its state
header, err := b.HeaderByNumber(ctx, number)
@@ -201,7 +206,7 @@ if err != nil {
return nil, nil, err
}
if header == nil {
- return nil, nil, errors.New("header not found")
+ return nil, nil, fmt.Errorf("header %w", ethereum.NotFound)
}
stateDb, err := b.eth.BlockChain().StateAt(header.Root)
if err != nil {
@@ -220,7 +225,7 @@ if err != nil {
return nil, nil, err
}
if header == nil {
- return nil, nil, errors.New("header for hash not found")
+ return nil, nil, fmt.Errorf("header for hash %w", ethereum.NotFound)
}
if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(header.Number.Uint64()) != hash {
return nil, nil, errors.New("hash is not currently canonical")
@@ -258,7 +263,7 @@ var context vm.BlockContext
if blockCtx != nil {
context = *blockCtx
} else {
- context = core.NewEVMBlockContext(header, b.eth.BlockChain(), nil)
+ context = core.NewEVMBlockContext(header, b.eth.BlockChain(), nil, b.eth.blockchain.Config(), state)
}
return vm.NewEVM(context, txContext, state, b.eth.blockchain.Config(), *vmConfig), state.Error
}
@@ -288,6 +293,26 @@ return b.eth.BlockChain().SubscribeLogsEvent(ch)
}
func (b *EthAPIBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {
+ if b.eth.seqRPCService != nil {
+ data, err := signedTx.MarshalBinary()
+ if err != nil {
+ return err
+ }
+ if err := b.eth.seqRPCService.CallContext(ctx, nil, "eth_sendRawTransaction", hexutil.Encode(data)); err != nil {
+ return err
+ }
+ if b.disableTxPool {
+ return nil
+ }
+ // Retain tx in local tx pool after forwarding, for local RPC usage.
+ if err := b.eth.txPool.Add([]*types.Transaction{signedTx}, true, false)[0]; err != nil {
+ log.Warn("successfully sent tx to sequencer, but failed to persist in local tx pool", "err", err, "tx", signedTx.Hash())
+ }
+ return nil
+ }
+ if b.disableTxPool {
+ return nil
+ }
return b.eth.txPool.Add([]*types.Transaction{signedTx}, true, false)[0]
}
@@ -415,3 +440,11 @@
func (b *EthAPIBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) {
return b.eth.stateAtTransaction(ctx, block, txIndex, reexec)
}
+
+func (b *EthAPIBackend) HistoricalRPCService() *rpc.Client {
+ return b.eth.historicalRPCService
+}
+
+func (b *EthAPIBackend) Genesis() *types.Block {
+ return b.eth.blockchain.Genesis()
+}
diff --git go-ethereum/eth/backend.go op-geth/eth/backend.go
index 09559f0ac116042981fc560e8f9529aa5a69a90f..d8e34503d43aa07e80aece8aefd6907798cc8beb 100644
--- go-ethereum/eth/backend.go
+++ op-geth/eth/backend.go
@@ -18,11 +18,13 @@ // Package eth implements the Ethereum protocol.
package eth
import (
+ "context"
"errors"
"fmt"
"math/big"
"runtime"
"sync"
+ "time"
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/common"
@@ -76,6 +78,9 @@ ethDialCandidates enode.Iterator
snapDialCandidates enode.Iterator
merger *consensus.Merger
+ seqRPCService *rpc.Client
+ historicalRPCService *rpc.Client
+
// DB interfaces
chainDb ethdb.Database // Block chain database
@@ -101,6 +106,8 @@
lock sync.RWMutex // Protects the variadic fields (e.g. gas price and etherbase)
shutdownTracker *shutdowncheck.ShutdownTracker // Tracks if and when the node has shutdown ungracefully
+
+ nodeCloser func() error
}
// New creates a new Ethereum object (including the
@@ -171,13 +178,13 @@ bloomRequests: make(chan chan *bloombits.Retrieval),
bloomIndexer: core.NewBloomIndexer(chainDb, params.BloomBitsBlocks, params.BloomConfirms),
p2pServer: stack.Server(),
shutdownTracker: shutdowncheck.NewShutdownTracker(chainDb),
+ nodeCloser: stack.Close,
}
bcVersion := rawdb.ReadDatabaseVersion(chainDb)
var dbVer = "<nil>"
if bcVersion != nil {
dbVer = fmt.Sprintf("%d", *bcVersion)
}
- log.Info("Initialising Ethereum protocol", "network", networkID, "dbversion", dbVer)
if !config.SkipBcVersionCheck {
if bcVersion != nil && *bcVersion > core.BlockChainVersion {
@@ -213,10 +220,27 @@ }
if config.OverrideVerkle != nil {
overrides.OverrideVerkle = config.OverrideVerkle
}
+ if config.OverrideOptimismCanyon != nil {
+ overrides.OverrideOptimismCanyon = config.OverrideOptimismCanyon
+ }
+ if config.OverrideOptimismInterop != nil {
+ overrides.OverrideOptimismInterop = config.OverrideOptimismInterop
+ }
+ overrides.ApplySuperchainUpgrades = config.ApplySuperchainUpgrades
eth.blockchain, err = core.NewBlockChain(chainDb, cacheConfig, config.Genesis, &overrides, eth.engine, vmConfig, eth.shouldPreserve, &config.TransactionHistory)
if err != nil {
return nil, err
}
+ if chainConfig := eth.blockchain.Config(); chainConfig.Optimism != nil { // config.Genesis.Config.ChainID cannot be used because it's based on CLI flags only, thus default to mainnet L1
+ config.NetworkId = chainConfig.ChainID.Uint64() // optimism defaults eth network ID to chain ID
+ eth.networkID = config.NetworkId
+ }
+ log.Info("Initialising Ethereum protocol", "network", config.NetworkId, "dbversion", dbVer)
+
+ if eth.blockchain.Config().Optimism != nil { // Optimism Bedrock depends on Merge functionality
+ eth.merger.FinalizePoS()
+ }
+
eth.bloomIndexer.Start(eth.blockchain)
if config.BlobPool.Datadir != "" {
@@ -245,6 +269,7 @@ Sync: config.SyncMode,
BloomCache: uint64(cacheLimit),
EventMux: eth.eventMux,
RequiredBlocks: config.RequiredBlocks,
+ NoTxGossip: config.RollupDisableTxPoolGossip,
}); err != nil {
return nil, err
}
@@ -252,7 +277,7 @@
eth.miner = miner.New(eth, &config.Miner, eth.blockchain.Config(), eth.EventMux(), eth.engine, eth.isLocalBlock)
eth.miner.SetExtra(makeExtraData(config.Miner.ExtraData))
- eth.APIBackend = &EthAPIBackend{stack.Config().ExtRPCEnabled(), stack.Config().AllowUnprotectedTxs, eth, nil}
+ eth.APIBackend = &EthAPIBackend{stack.Config().ExtRPCEnabled(), stack.Config().AllowUnprotectedTxs, config.RollupDisableTxPoolAdmission, eth, nil}
if eth.APIBackend.allowUnprotectedTxs {
log.Info("Unprotected transactions allowed")
}
@@ -273,6 +298,26 @@ if err != nil {
return nil, err
}
+ if config.RollupSequencerHTTP != "" {
+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ client, err := rpc.DialContext(ctx, config.RollupSequencerHTTP)
+ cancel()
+ if err != nil {
+ return nil, err
+ }
+ eth.seqRPCService = client
+ }
+
+ if config.RollupHistoricalRPC != "" {
+ ctx, cancel := context.WithTimeout(context.Background(), config.RollupHistoricalRPCTimeout)
+ client, err := rpc.DialContext(ctx, config.RollupHistoricalRPC)
+ cancel()
+ if err != nil {
+ return nil, err
+ }
+ eth.historicalRPCService = client
+ }
+
// Start the RPC service
eth.netRPCService = ethapi.NewNetAPI(eth.p2pServer, networkID)
@@ -291,7 +336,7 @@ func makeExtraData(extra []byte) []byte {
if len(extra) == 0 {
// create default extradata
extra, _ = rlp.EncodeToBytes([]interface{}{
- uint(params.VersionMajor<<16 | params.VersionMinor<<8 | params.VersionPatch),
+ uint(params.OPVersionMajor<<16 | params.OPVersionMinor<<8 | params.OPVersionPatch),
"geth",
runtime.Version(),
runtime.GOOS,
@@ -541,6 +586,12 @@ s.txPool.Close()
s.miner.Close()
s.blockchain.Stop()
s.engine.Close()
+ if s.seqRPCService != nil {
+ s.seqRPCService.Close()
+ }
+ if s.historicalRPCService != nil {
+ s.historicalRPCService.Close()
+ }
// Clean shutdown marker as the last thing before closing db
s.shutdownTracker.Stop()
@@ -550,3 +601,33 @@ s.eventMux.Stop()
return nil
}
+
+// HandleRequiredProtocolVersion handles the protocol version signal. This implements opt-in halting,
+// the protocol version data is already logged and metered when signaled through the Engine API.
+func (s *Ethereum) HandleRequiredProtocolVersion(required params.ProtocolVersion) error {
+ var needLevel int
+ switch s.config.RollupHaltOnIncompatibleProtocolVersion {
+ case "major":
+ needLevel = 3
+ case "minor":
+ needLevel = 2
+ case "patch":
+ needLevel = 1
+ default:
+ return nil // do not consider halting if not configured to
+ }
+ haveLevel := 0
+ switch params.OPStackSupport.Compare(required) {
+ case params.OutdatedMajor:
+ haveLevel = 3
+ case params.OutdatedMinor:
+ haveLevel = 2
+ case params.OutdatedPatch:
+ haveLevel = 1
+ }
+ if haveLevel >= needLevel { // halt if we opted in to do so at this granularity
+ log.Error("Opted to halt, unprepared for protocol change", "required", required, "local", params.OPStackSupport)
+ return s.nodeCloser()
+ }
+ return nil
+}
diff --git go-ethereum/internal/ethapi/backend.go op-geth/internal/ethapi/backend.go
index 458fb811edaeee090af64d1e64494190139a3257..a3ce3c9c1dea0e050934910a0f4c99af6dc05ddc 100644
--- go-ethereum/internal/ethapi/backend.go
+++ op-geth/internal/ethapi/backend.go
@@ -86,6 +86,8 @@ SubscribeNewTxsEvent(chan<- core.NewTxsEvent) event.Subscription
ChainConfig() *params.ChainConfig
Engine() consensus.Engine
+ HistoricalRPCService() *rpc.Client
+ Genesis() *types.Block
// This is copied from filters.Backend
// eth/filters needs to be initialized from this backend type, so methods needed by
Apply L1 cost in API responses
+1
-1
diff --git go-ethereum/eth/state_accessor.go op-geth/eth/state_accessor.go
index 24694df66c36cd814d2d631368bf29d75cf6d9f6..19128d12b19a038f0a70d58564e179b06970f281 100644
--- go-ethereum/eth/state_accessor.go
+++ op-geth/eth/state_accessor.go
@@ -241,7 +241,7 @@ for idx, tx := range block.Transactions() {
// Assemble the transaction call message and return if the requested offset
msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(block.Header(), eth.blockchain, nil)
+ context := core.NewEVMBlockContext(block.Header(), eth.blockchain, nil, eth.blockchain.Config(), statedb)
if idx == txIndex {
return msg, context, statedb, release, nil
}
API frontend
+251
-19
Format deposit and L1-cost data in transaction responses. Add debug_chainConfig API.
diff --git go-ethereum/internal/ethapi/api.go op-geth/internal/ethapi/api.go
index 38a7924124a622091f83fea12eace0c32e32ad32..f75caa3caa4641bbacf3b2e036e2d9c62b1b85f9 100644
--- go-ethereum/internal/ethapi/api.go
+++ op-geth/internal/ethapi/api.go
@@ -26,6 +26,9 @@ "strings"
"time"
"github.com/davecgh/go-spew/spew"
+ "github.com/tyler-smith/go-bip39"
+
+ "github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/accounts/abi"
"github.com/ethereum/go-ethereum/accounts/keystore"
@@ -47,7 +50,6 @@ "github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rlp"
"github.com/ethereum/go-ethereum/rpc"
"github.com/ethereum/go-ethereum/trie"
- "github.com/tyler-smith/go-bip39"
)
// EthereumAPI provides an API to access Ethereum related information.
@@ -632,6 +634,24 @@ // GetBalance returns the amount of wei for the given address in the state of the
// given block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta
// block numbers are also allowed.
func (s *BlockChainAPI) GetBalance(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error) {
+ header, err := headerByNumberOrHash(ctx, s.b, blockNrOrHash)
+ if err != nil {
+ return nil, err
+ }
+
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res hexutil.Big
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_getBalance", address, blockNrOrHash)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return &res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
if state == nil || err != nil {
return nil, err
@@ -671,6 +691,22 @@ }
// GetProof returns the Merkle-proof for a given account and optionally some storage keys.
func (s *BlockChainAPI) GetProof(ctx context.Context, address common.Address, storageKeys []string, blockNrOrHash rpc.BlockNumberOrHash) (*AccountResult, error) {
+ header, err := headerByNumberOrHash(ctx, s.b, blockNrOrHash)
+ if err != nil {
+ return nil, err
+ }
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res AccountResult
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_getProof", address, storageKeys, blockNrOrHash)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return &res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
var (
keys = make([]common.Hash, len(storageKeys))
keyLengths = make([]int, len(storageKeys))
@@ -773,7 +809,7 @@ func (s *BlockChainAPI) GetHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (map[string]interface{}, error) {
header, err := s.b.HeaderByNumber(ctx, number)
if header != nil && err == nil {
response := s.rpcMarshalHeader(ctx, header)
- if number == rpc.PendingBlockNumber {
+ if number == rpc.PendingBlockNumber && s.b.ChainConfig().Optimism == nil { // don't remove info if optimism
// Pending header need to nil out a few fields
for _, field := range []string{"hash", "nonce", "miner"} {
response[field] = nil
@@ -804,7 +840,7 @@ func (s *BlockChainAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber, fullTx bool) (map[string]interface{}, error) {
block, err := s.b.BlockByNumber(ctx, number)
if block != nil && err == nil {
response, err := s.rpcMarshalBlock(ctx, block, true, fullTx)
- if err == nil && number == rpc.PendingBlockNumber {
+ if err == nil && number == rpc.PendingBlockNumber && s.b.ChainConfig().Optimism == nil { // don't remove info if optimism
// Pending blocks need to nil out a few fields
for _, field := range []string{"hash", "nonce", "miner"} {
response[field] = nil
@@ -875,10 +911,29 @@ }
// GetCode returns the code stored at the given address in the state for the given block number.
func (s *BlockChainAPI) GetCode(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
+ header, err := headerByNumberOrHash(ctx, s.b, blockNrOrHash)
+ if err != nil {
+ return nil, err
+ }
+
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res hexutil.Bytes
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_getCode", address, blockNrOrHash)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
if state == nil || err != nil {
return nil, err
}
+
code := state.GetCode(address)
return code, state.Error()
}
@@ -887,10 +942,29 @@ // GetStorageAt returns the storage from the state at the given address, key and
// block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta block
// numbers are also allowed.
func (s *BlockChainAPI) GetStorageAt(ctx context.Context, address common.Address, hexKey string, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
+ header, err := headerByNumberOrHash(ctx, s.b, blockNrOrHash)
+ if err != nil {
+ return nil, err
+ }
+
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res hexutil.Bytes
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_getStorageAt", address, hexKey, blockNrOrHash)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
if state == nil || err != nil {
return nil, err
}
+
key, _, err := decodeHash(hexKey)
if err != nil {
return nil, fmt.Errorf("unable to decode storage key: %s", err)
@@ -899,6 +973,18 @@ res := state.GetState(address, key)
return res[:], state.Error()
}
+// The HeaderByNumberOrHash method returns a nil error and nil header
+// if the header is not found, but only for nonexistent block numbers. This is
+// different from StateAndHeaderByNumberOrHash. To account for this discrepancy,
+// headerOrNumberByHash will properly convert the error into an ethereum.NotFound.
+func headerByNumberOrHash(ctx context.Context, b Backend, blockNrOrHash rpc.BlockNumberOrHash) (*types.Header, error) {
+ header, err := b.HeaderByNumberOrHash(ctx, blockNrOrHash)
+ if header == nil {
+ return nil, fmt.Errorf("header %w", ethereum.NotFound)
+ }
+ return header, err
+}
+
// GetBlockReceipts returns the block receipts for the given block hash or number or tag.
func (s *BlockChainAPI) GetBlockReceipts(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) ([]map[string]interface{}, error) {
block, err := s.b.BlockByNumberOrHash(ctx, blockNrOrHash)
@@ -921,7 +1007,7 @@ signer := types.MakeSigner(s.b.ChainConfig(), block.Number(), block.Time())
result := make([]map[string]interface{}, len(receipts))
for i, receipt := range receipts {
- result[i] = marshalReceipt(receipt, block.Hash(), block.NumberU64(), signer, txs[i], i)
+ result[i] = marshalReceipt(receipt, block.Hash(), block.NumberU64(), signer, txs[i], i, s.b.ChainConfig())
}
return result, nil
@@ -1079,7 +1165,7 @@ msg, err := args.ToMessage(globalGasCap, header.BaseFee)
if err != nil {
return nil, err
}
- blockCtx := core.NewEVMBlockContext(header, NewChainContext(ctx, b), nil)
+ blockCtx := core.NewEVMBlockContext(header, NewChainContext(ctx, b), nil, b.ChainConfig(), state)
if blockOverrides != nil {
blockOverrides.Apply(&blockCtx)
}
@@ -1161,6 +1247,25 @@ if blockNrOrHash == nil {
latest := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber)
blockNrOrHash = &latest
}
+
+ header, err := headerByNumberOrHash(ctx, s.b, *blockNrOrHash)
+ if err != nil {
+ return nil, err
+ }
+
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res hexutil.Bytes
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_call", args, blockNrOrHash, overrides)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
result, err := DoCall(ctx, s.b, args, *blockNrOrHash, overrides, blockOverrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap())
if err != nil {
return nil, err
@@ -1320,6 +1425,25 @@ bNrOrHash := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber)
if blockNrOrHash != nil {
bNrOrHash = *blockNrOrHash
}
+
+ header, err := headerByNumberOrHash(ctx, s.b, bNrOrHash)
+ if err != nil {
+ return 0, err
+ }
+
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res hexutil.Uint64
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_estimateGas", args, blockNrOrHash)
+ if err != nil {
+ return 0, fmt.Errorf("historical backend error: %w", err)
+ }
+ return res, nil
+ } else {
+ return 0, rpc.ErrNoHistoricalFallback
+ }
+ }
+
return DoEstimateGas(ctx, s.b, args, bNrOrHash, overrides, s.b.RPCGasCap())
}
@@ -1364,7 +1488,7 @@
// RPCMarshalBlock converts the given block to the RPC output which depends on fullTx. If inclTx is true transactions are
// returned. When fullTx is true the returned block contains full transaction details, otherwise it will only contain
// transaction hashes.
-func RPCMarshalBlock(block *types.Block, inclTx bool, fullTx bool, config *params.ChainConfig) map[string]interface{} {
+func RPCMarshalBlock(ctx context.Context, block *types.Block, inclTx bool, fullTx bool, config *params.ChainConfig, backend Backend) (map[string]interface{}, error) {
fields := RPCMarshalHeader(block.Header())
fields["size"] = hexutil.Uint64(block.Size())
@@ -1374,7 +1498,7 @@ return tx.Hash()
}
if fullTx {
formatTx = func(idx int, tx *types.Transaction) interface{} {
- return newRPCTransactionFromBlockIndex(block, uint64(idx), config)
+ return newRPCTransactionFromBlockIndex(ctx, block, uint64(idx), config, backend)
}
}
txs := block.Transactions()
@@ -1393,7 +1517,7 @@ fields["uncles"] = uncleHashes
if block.Header().WithdrawalsHash != nil {
fields["withdrawals"] = block.Withdrawals()
}
- return fields
+ return fields, nil
}
// rpcMarshalHeader uses the generalized output filler, then adds the total difficulty field, which requires
@@ -1407,7 +1531,10 @@
// rpcMarshalBlock uses the generalized output filler, then adds the total difficulty field, which requires
// a `BlockchainAPI`.
func (s *BlockChainAPI) rpcMarshalBlock(ctx context.Context, b *types.Block, inclTx bool, fullTx bool) (map[string]interface{}, error) {
- fields := RPCMarshalBlock(b, inclTx, fullTx, s.b.ChainConfig())
+ fields, err := RPCMarshalBlock(ctx, b, inclTx, fullTx, s.b.ChainConfig(), s.b)
+ if err != nil {
+ return nil, err
+ }
if inclTx {
fields["totalDifficulty"] = (*hexutil.Big)(s.b.GetTd(ctx, b.Hash()))
}
@@ -1438,11 +1565,18 @@ V *hexutil.Big `json:"v"`
R *hexutil.Big `json:"r"`
S *hexutil.Big `json:"s"`
YParity *hexutil.Uint64 `json:"yParity,omitempty"`
+
+ // deposit-tx only
+ SourceHash *common.Hash `json:"sourceHash,omitempty"`
+ Mint *hexutil.Big `json:"mint,omitempty"`
+ IsSystemTx *bool `json:"isSystemTx,omitempty"`
+ // deposit-tx post-Canyon only
+ DepositReceiptVersion *hexutil.Uint64 `json:"depositReceiptVersion,omitempty"`
}
// 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, blockTime uint64, index uint64, baseFee *big.Int, config *params.ChainConfig) *RPCTransaction {
+func newRPCTransaction(tx *types.Transaction, blockHash common.Hash, blockNumber uint64, blockTime uint64, index uint64, baseFee *big.Int, config *params.ChainConfig, receipt *types.Receipt) *RPCTransaction {
signer := types.MakeSigner(config, new(big.Int).SetUint64(blockNumber), blockTime)
from, _ := types.Sender(signer, tx)
v, r, s := tx.RawSignatureValues()
@@ -1467,7 +1601,27 @@ result.TransactionIndex = (*hexutil.Uint64)(&index)
}
switch tx.Type() {
+ case types.DepositTxType:
+ srcHash := tx.SourceHash()
+ isSystemTx := tx.IsSystemTx()
+ result.SourceHash = &srcHash
+ if isSystemTx {
+ // Only include IsSystemTx when true
+ result.IsSystemTx = &isSystemTx
+ }
+ result.Mint = (*hexutil.Big)(tx.Mint())
+ if receipt != nil && receipt.DepositNonce != nil {
+ result.Nonce = hexutil.Uint64(*receipt.DepositNonce)
+ if receipt.DepositReceiptVersion != nil {
+ result.DepositReceiptVersion = new(hexutil.Uint64)
+ *result.DepositReceiptVersion = hexutil.Uint64(*receipt.DepositReceiptVersion)
+ }
+ }
case types.LegacyTxType:
+ if v.Sign() == 0 && r.Sign() == 0 && s.Sign() == 0 { // pre-bedrock relayed tx does not have a signature
+ result.ChainID = (*hexutil.Big)(new(big.Int).Set(config.ChainID))
+ break
+ }
// if a legacy transaction has an EIP-155 chain id, include it explicitly
if id := tx.ChainId(); id.Sign() != 0 {
result.ChainID = (*hexutil.Big)(id)
@@ -1536,20 +1690,36 @@ blockNumber = uint64(0)
blockTime = uint64(0)
)
if current != nil {
- baseFee = eip1559.CalcBaseFee(config, current)
+ baseFee = eip1559.CalcBaseFee(config, current, current.Time+1)
blockNumber = current.Number.Uint64()
blockTime = current.Time
}
- return newRPCTransaction(tx, common.Hash{}, blockNumber, blockTime, 0, baseFee, config)
+ return newRPCTransaction(tx, common.Hash{}, blockNumber, blockTime, 0, baseFee, config, nil)
}
// newRPCTransactionFromBlockIndex returns a transaction that will serialize to the RPC representation.
-func newRPCTransactionFromBlockIndex(b *types.Block, index uint64, config *params.ChainConfig) *RPCTransaction {
+func newRPCTransactionFromBlockIndex(ctx context.Context, b *types.Block, index uint64, config *params.ChainConfig, backend Backend) *RPCTransaction {
txs := b.Transactions()
if index >= uint64(len(txs)) {
return nil
}
- return newRPCTransaction(txs[index], b.Hash(), b.NumberU64(), b.Time(), index, b.BaseFee(), config)
+ tx := txs[index]
+ rcpt := depositTxReceipt(ctx, b.Hash(), index, backend, tx)
+ return newRPCTransaction(tx, b.Hash(), b.NumberU64(), b.Time(), index, b.BaseFee(), config, rcpt)
+}
+
+func depositTxReceipt(ctx context.Context, blockHash common.Hash, index uint64, backend Backend, tx *types.Transaction) *types.Receipt {
+ if tx.Type() != types.DepositTxType {
+ return nil
+ }
+ receipts, err := backend.GetReceipts(ctx, blockHash)
+ if err != nil {
+ return nil
+ }
+ if index >= uint64(len(receipts)) {
+ return nil
+ }
+ return receipts[index]
}
// newRPCRawTransactionFromBlockIndex returns the bytes of a transaction given a block and a transaction index.
@@ -1578,6 +1748,21 @@ bNrOrHash := rpc.BlockNumberOrHashWithNumber(rpc.PendingBlockNumber)
if blockNrOrHash != nil {
bNrOrHash = *blockNrOrHash
}
+
+ header, err := headerByNumberOrHash(ctx, s.b, bNrOrHash)
+ if err == nil && header != nil && s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res accessListResult
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_createAccessList", args, blockNrOrHash)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return &res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
acl, gasUsed, vmerr, err := AccessList(ctx, s.b, bNrOrHash, args)
if err != nil {
return nil, err
@@ -1688,7 +1873,7 @@
// GetTransactionByBlockNumberAndIndex returns the transaction for the given block number and index.
func (s *TransactionAPI) GetTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) *RPCTransaction {
if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil {
- return newRPCTransactionFromBlockIndex(block, uint64(index), s.b.ChainConfig())
+ return newRPCTransactionFromBlockIndex(ctx, block, uint64(index), s.b.ChainConfig(), s.b)
}
return nil
}
@@ -1696,7 +1881,7 @@
// GetTransactionByBlockHashAndIndex returns the transaction for the given block hash and index.
func (s *TransactionAPI) GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) *RPCTransaction {
if block, _ := s.b.BlockByHash(ctx, blockHash); block != nil {
- return newRPCTransactionFromBlockIndex(block, uint64(index), s.b.ChainConfig())
+ return newRPCTransactionFromBlockIndex(ctx, block, uint64(index), s.b.ChainConfig(), s.b)
}
return nil
}
@@ -1728,10 +1913,29 @@ }
return (*hexutil.Uint64)(&nonce), nil
}
// Resolve block number and use its state to ask for the nonce
+ header, err := headerByNumberOrHash(ctx, s.b, blockNrOrHash)
+ if err != nil {
+ return nil, err
+ }
+
+ if s.b.ChainConfig().IsOptimismPreBedrock(header.Number) {
+ if s.b.HistoricalRPCService() != nil {
+ var res hexutil.Uint64
+ err := s.b.HistoricalRPCService().CallContext(ctx, &res, "eth_getTransactionCount", address, blockNrOrHash)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return &res, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
if state == nil || err != nil {
return nil, err
}
+
nonce := state.GetNonce(address)
return (*hexutil.Uint64)(&nonce), state.Error()
}
@@ -1748,7 +1952,8 @@ header, err := s.b.HeaderByHash(ctx, blockHash)
if err != nil {
return nil, err
}
- return newRPCTransaction(tx, blockHash, blockNumber, header.Time, index, header.BaseFee, s.b.ChainConfig()), nil
+ rcpt := depositTxReceipt(ctx, blockHash, index, s.b, tx)
+ return newRPCTransaction(tx, blockHash, blockNumber, header.Time, index, header.BaseFee, s.b.ChainConfig(), rcpt), nil
}
// No finalized transaction, try to retrieve it from the pool
if tx := s.b.GetPoolTransaction(hash); tx != nil {
@@ -1799,11 +2004,11 @@ receipt := receipts[index]
// Derive the sender.
signer := types.MakeSigner(s.b.ChainConfig(), header.Number, header.Time)
- return marshalReceipt(receipt, blockHash, blockNumber, signer, tx, int(index)), nil
+ return marshalReceipt(receipt, blockHash, blockNumber, signer, tx, int(index), s.b.ChainConfig()), nil
}
// marshalReceipt marshals a transaction receipt into a JSON object.
-func marshalReceipt(receipt *types.Receipt, blockHash common.Hash, blockNumber uint64, signer types.Signer, tx *types.Transaction, txIndex int) map[string]interface{} {
+func marshalReceipt(receipt *types.Receipt, blockHash common.Hash, blockNumber uint64, signer types.Signer, tx *types.Transaction, txIndex int, chainConfig *params.ChainConfig) map[string]interface{} {
from, _ := types.Sender(signer, tx)
fields := map[string]interface{}{
@@ -1820,6 +2025,19 @@ "logs": receipt.Logs,
"logsBloom": receipt.Bloom,
"type": hexutil.Uint(tx.Type()),
"effectiveGasPrice": (*hexutil.Big)(receipt.EffectiveGasPrice),
+ }
+
+ if chainConfig.Optimism != nil && !tx.IsDepositTx() {
+ fields["l1GasPrice"] = (*hexutil.Big)(receipt.L1GasPrice)
+ fields["l1GasUsed"] = (*hexutil.Big)(receipt.L1GasUsed)
+ fields["l1Fee"] = (*hexutil.Big)(receipt.L1Fee)
+ fields["l1FeeScalar"] = receipt.FeeScalar.String()
+ }
+ if chainConfig.Optimism != nil && tx.IsDepositTx() && receipt.DepositNonce != nil {
+ fields["depositNonce"] = hexutil.Uint64(*receipt.DepositNonce)
+ if receipt.DepositReceiptVersion != nil {
+ fields["depositReceiptVersion"] = hexutil.Uint64(*receipt.DepositReceiptVersion)
+ }
}
// Assign receipt status or post state.
@@ -2216,6 +2434,10 @@
// SetHead rewinds the head of the blockchain to a previous block.
func (api *DebugAPI) SetHead(number hexutil.Uint64) {
api.b.SetHead(uint64(number))
+}
+
+func (api *DebugAPI) ChainConfig() *params.ChainConfig {
+ return api.b.ChainConfig()
}
// NetAPI offers network related RPC methods
diff --git go-ethereum/rpc/errors.go op-geth/rpc/errors.go
index 438aff218c2e306d322160d8be8dcac16dd0dfa2..67c523d11a36294e4448988dc4c906f38541ec04 100644
--- go-ethereum/rpc/errors.go
+++ op-geth/rpc/errors.go
@@ -73,6 +73,16 @@ errMsgResponseTooLarge = "response too large"
errMsgBatchTooLarge = "batch too large"
)
+var ErrNoHistoricalFallback = NoHistoricalFallbackError{}
+
+type NoHistoricalFallbackError struct{}
+
+func (e NoHistoricalFallbackError) ErrorCode() int { return -32801 }
+
+func (e NoHistoricalFallbackError) Error() string {
+ return "no historical RPC is available for this historical (pre-bedrock) execution request"
+}
+
type methodNotFoundError struct{ method string }
func (e *methodNotFoundError) ErrorCode() int { return -32601 }
Tracer RPC daisy-chain
+59
-12
Forward pre-bedrock tracing calls to legacy node.
diff --git go-ethereum/eth/tracers/api.go op-geth/eth/tracers/api.go
index 300d904a997005071d0484b1f924c49066bb7c4f..7e14f6939590e0fabab30adaae9437c9c0082ae4 100644
--- go-ethereum/eth/tracers/api.go
+++ op-geth/eth/tracers/api.go
@@ -22,6 +22,7 @@ "context"
"encoding/json"
"errors"
"fmt"
+ "math/big"
"os"
"runtime"
"sync"
@@ -67,8 +68,6 @@ // trace states exceed this limit.
maximumPendingTraceStates = 128
)
-var errTxNotFound = errors.New("transaction not found")
-
// StateReleaseFunc is used to deallocate resources held by constructing a
// historical state for tracing purposes.
type StateReleaseFunc func()
@@ -87,6 +86,7 @@ Engine() consensus.Engine
ChainDb() ethdb.Database
StateAtBlock(ctx context.Context, block *types.Block, reexec uint64, base *state.StateDB, readOnly bool, preferDisk bool) (*state.StateDB, StateReleaseFunc, error)
StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, StateReleaseFunc, error)
+ HistoricalRPCService() *rpc.Client
}
// API is the collection of tracing APIs exposed over the private debugging endpoint.
@@ -207,6 +207,7 @@
// TraceChain returns the structured logs created during the execution of EVM
// between two blocks (excluding start) and returns them as a JSON object.
func (api *API) TraceChain(ctx context.Context, start, end rpc.BlockNumber, config *TraceConfig) (*rpc.Subscription, error) { // Fetch the block interval that we want to trace
+ // TODO: Need to implement a fallback for this
from, err := api.blockByNumber(ctx, start)
if err != nil {
return nil, err
@@ -265,7 +266,7 @@ // Fetch and execute the block trace taskCh
for task := range taskCh {
var (
signer = types.MakeSigner(api.backend.ChainConfig(), task.block.Number(), task.block.Time())
- blockCtx = core.NewEVMBlockContext(task.block.Header(), api.chainContext(ctx), nil)
+ blockCtx = core.NewEVMBlockContext(task.block.Header(), api.chainContext(ctx), nil, api.backend.ChainConfig(), task.statedb)
)
// Trace all the transactions contained within
for i, tx := range task.block.Transactions() {
@@ -435,6 +436,20 @@ block, err := api.blockByNumber(ctx, number)
if err != nil {
return nil, err
}
+
+ if api.backend.ChainConfig().IsOptimismPreBedrock(block.Number()) {
+ if api.backend.HistoricalRPCService() != nil {
+ var histResult []*txTraceResult
+ err = api.backend.HistoricalRPCService().CallContext(ctx, &histResult, "debug_traceBlockByNumber", number, config)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return histResult, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
return api.traceBlock(ctx, block, config)
}
@@ -445,6 +460,20 @@ block, err := api.blockByHash(ctx, hash)
if err != nil {
return nil, err
}
+
+ if api.backend.ChainConfig().IsOptimismPreBedrock(block.Number()) {
+ if api.backend.HistoricalRPCService() != nil {
+ var histResult []*txTraceResult
+ err = api.backend.HistoricalRPCService().CallContext(ctx, &histResult, "debug_traceBlockByHash", hash, config)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return histResult, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
+ }
+
return api.traceBlock(ctx, block, config)
}
@@ -494,6 +523,7 @@ // IntermediateRoots executes a block (bad- or canon- or side-), and returns a list
// of intermediate roots: the stateroot after each transaction.
func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config *TraceConfig) ([]common.Hash, error) {
block, _ := api.blockByHash(ctx, hash)
+ // TODO: Cannot get intermediate roots for pre-bedrock block without daisy chain
if block == nil {
// Check in the bad blocks
block = rawdb.ReadBadBlock(api.backend.ChainDb(), hash)
@@ -522,7 +552,7 @@ var (
roots []common.Hash
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
chainConfig = api.backend.ChainConfig()
- vmctx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+ vmctx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil, chainConfig, statedb)
deleteEmptyObjects = chainConfig.IsEIP158(block.Number())
)
for i, tx := range block.Transactions() {
@@ -598,7 +628,7 @@ var (
txs = block.Transactions()
blockHash = block.Hash()
is158 = api.backend.ChainConfig().IsEIP158(block.Number())
- blockCtx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+ blockCtx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil, api.backend.ChainConfig(), statedb)
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
results = make([]*txTraceResult, len(txs))
)
@@ -631,7 +661,6 @@ // Execute all the transaction contained within the block concurrently
var (
txs = block.Transactions()
blockHash = block.Hash()
- blockCtx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
results = make([]*txTraceResult, len(txs))
pend sync.WaitGroup
@@ -647,6 +676,7 @@ go func() {
defer pend.Done()
// Fetch and execute the next transaction trace tasks
for task := range jobs {
+ blockCtx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil, api.backend.ChainConfig(), task.statedb)
msg, _ := core.TransactionToMessage(txs[task.index], signer, block.BaseFee())
txctx := &Context{
BlockHash: blockHash,
@@ -666,6 +696,7 @@ }
// Feed the transactions into the tracers and return
var failed error
+ blockCtx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil, api.backend.ChainConfig(), statedb)
txloop:
for i, tx := range txs {
// Send the trace task over for execution
@@ -743,7 +774,7 @@ var (
dumps []string
signer = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
chainConfig = api.backend.ChainConfig()
- vmctx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+ vmctx = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil, chainConfig, statedb)
canon = true
)
// Check if there are any overrides: the caller may wish to enable a future
@@ -825,14 +856,25 @@
// TraceTransaction returns the structured logs created during the execution of EVM
// and returns them as a JSON object.
func (api *API) TraceTransaction(ctx context.Context, hash common.Hash, config *TraceConfig) (interface{}, error) {
- tx, blockHash, blockNumber, index, err := api.backend.GetTransaction(ctx, hash)
+ // GetTransaction returns 0 for the blocknumber if the transaction is not found
+ _, blockHash, blockNumber, index, err := api.backend.GetTransaction(ctx, hash)
if err != nil {
return nil, err
}
- // Only mined txes are supported
- if tx == nil {
- return nil, errTxNotFound
+
+ if api.backend.ChainConfig().IsOptimismPreBedrock(new(big.Int).SetUint64(blockNumber)) {
+ if api.backend.HistoricalRPCService() != nil {
+ var histResult json.RawMessage
+ err := api.backend.HistoricalRPCService().CallContext(ctx, &histResult, "debug_traceTransaction", hash, config)
+ if err != nil {
+ return nil, fmt.Errorf("historical backend error: %w", err)
+ }
+ return histResult, nil
+ } else {
+ return nil, rpc.ErrNoHistoricalFallback
+ }
}
+
// It shouldn't happen in practice.
if blockNumber == 0 {
return nil, errors.New("genesis is not traceable")
@@ -887,6 +929,11 @@ }
if err != nil {
return nil, err
}
+
+ if api.backend.ChainConfig().IsOptimismPreBedrock(block.Number()) {
+ return nil, errors.New("l2geth does not have a debug_traceCall method")
+ }
+
// try to recompute the state
reexec := defaultTraceReexec
if config != nil && config.Reexec != nil {
@@ -898,7 +945,7 @@ return nil, err
}
defer release()
- vmctx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+ vmctx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil, api.backend.ChainConfig(), statedb)
// Apply the customization rules if required.
if config != nil {
if err := config.StateOverrides.Apply(statedb); err != nil {
Light Ethereum Subprotocol (LES) RPC
+37
-4
Match the RPC changes in the LES RPC
diff --git go-ethereum/les/client.go op-geth/les/client.go
index be5e9fd5641dc23ce2f0268703607ac14a45bf0d..2c1d348e672b68f52adc2f8ba4d2d5fc387916d9 100644
--- go-ethereum/les/client.go
+++ op-geth/les/client.go
@@ -18,6 +18,7 @@ // Package les implements the Light Ethereum Subprotocol.
package les
import (
+ "context"
"errors"
"strings"
"time"
@@ -64,6 +65,9 @@ blockchain *light.LightChain
serverPool *vfc.ServerPool
serverPoolIterator enode.Iterator
merger *consensus.Merger
+
+ seqRPCService *rpc.Client
+ historicalRPCService *rpc.Client
bloomRequests chan chan *bloombits.Retrieval // Channel receiving bloom data retrieval requests
bloomIndexer *core.ChainIndexer // Bloom indexer operating during block imports
@@ -188,6 +192,27 @@ }
leth.ApiBackend.gpo = gasprice.NewOracle(leth.ApiBackend, gpoParams)
leth.handler = newClientHandler(leth)
+
+ if config.RollupSequencerHTTP != "" {
+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ client, err := rpc.DialContext(ctx, config.RollupSequencerHTTP)
+ cancel()
+ if err != nil {
+ return nil, err
+ }
+ leth.seqRPCService = client
+ }
+
+ if config.RollupHistoricalRPC != "" {
+ ctx, cancel := context.WithTimeout(context.Background(), config.RollupHistoricalRPCTimeout)
+ client, err := rpc.DialContext(ctx, config.RollupHistoricalRPC)
+ cancel()
+ if err != nil {
+ return nil, err
+ }
+ leth.historicalRPCService = client
+ }
+
leth.netRPCService = ethapi.NewNetAPI(leth.p2pServer, leth.config.NetworkId)
// Register the backend on the node
diff --git go-ethereum/les/odr_test.go op-geth/les/odr_test.go
index 69824a92dd083958d1d02f03ee956d9cddc35223..d5fb42589c5a133c6ecb1f2d27f9a6ad75dc68a0 100644
--- go-ethereum/les/odr_test.go
+++ op-geth/les/odr_test.go
@@ -148,7 +148,7 @@ Data: data,
SkipAccountChecks: true,
}
- context := core.NewEVMBlockContext(header, bc, nil)
+ context := core.NewEVMBlockContext(header, bc, nil, config, statedb)
txContext := core.NewEVMTxContext(msg)
vmenv := vm.NewEVM(context, txContext, statedb, config, vm.Config{NoBaseFee: true})
@@ -172,7 +172,7 @@ GasTipCap: new(big.Int),
Data: data,
SkipAccountChecks: true,
}
- context := core.NewEVMBlockContext(header, lc, nil)
+ context := core.NewEVMBlockContext(header, lc, nil, config, state)
txContext := core.NewEVMTxContext(msg)
vmenv := vm.NewEVM(context, txContext, state, config, vm.Config{NoBaseFee: true})
gp := new(core.GasPool).AddGas(math.MaxUint64)
diff --git go-ethereum/les/api_backend.go op-geth/les/api_backend.go
index 3e9dbadce86b4181ec63917a4425829754028ab0..fce7f0175870f5ed7a56e8d65ac49a88e5e71de8 100644
--- go-ethereum/les/api_backend.go
+++ op-geth/les/api_backend.go
@@ -188,7 +188,7 @@ if vmConfig == nil {
vmConfig = new(vm.Config)
}
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(header, b.eth.blockchain, nil)
+ context := core.NewEVMBlockContext(header, b.eth.blockchain, nil, b.eth.chainConfig, state)
if blockCtx != nil {
context = *blockCtx
}
@@ -335,3 +335,11 @@
func (b *LesApiBackend) StateAtTransaction(ctx context.Context, block *types.Block, txIndex int, reexec uint64) (*core.Message, vm.BlockContext, *state.StateDB, tracers.StateReleaseFunc, error) {
return b.eth.stateAtTransaction(ctx, block, txIndex, reexec)
}
+
+func (b *LesApiBackend) HistoricalRPCService() *rpc.Client {
+ return b.eth.historicalRPCService
+}
+
+func (b *LesApiBackend) Genesis() *types.Block {
+ return b.eth.blockchain.Genesis()
+}
diff --git go-ethereum/les/state_accessor.go op-geth/les/state_accessor.go
index 9a8214ac2f8f044493965fe989c54316a690a883..9383c2cc35019ff747ae8ec24edbac4a39121658 100644
--- go-ethereum/les/state_accessor.go
+++ op-geth/les/state_accessor.go
@@ -62,7 +62,7 @@ for idx, tx := range block.Transactions() {
// Assemble the transaction call message and return if the requested offset
msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(block.Header(), leth.blockchain, nil)
+ context := core.NewEVMBlockContext(block.Header(), leth.blockchain, nil, leth.blockchain.Config(), statedb)
statedb.SetTxContext(tx.Hash(), idx)
if idx == txIndex {
return msg, context, statedb, release, nil
Daisy Chain tests
+361
-18
diff --git go-ethereum/internal/ethapi/transaction_args_test.go op-geth/internal/ethapi/transaction_args_test.go
index 9161d5e681f2ff2afd8f90f0838a3bbb7bb840ab..b743064625b779b46a73ad00196d0fe07bcc5aa2 100644
--- go-ethereum/internal/ethapi/transaction_args_test.go
+++ op-geth/internal/ethapi/transaction_args_test.go
@@ -342,4 +342,6 @@ func (b *backendMock) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
return nil
}
-func (b *backendMock) Engine() consensus.Engine { return nil }
+func (b *backendMock) Engine() consensus.Engine { return nil }
+func (b *backendMock) HistoricalRPCService() *rpc.Client { return nil }
+func (b *backendMock) Genesis() *types.Block { return nil }
diff --git go-ethereum/ethclient/ethclient_test.go op-geth/ethclient/ethclient_test.go
index 0f87ad5f5cd3721224388a2ad3d729a32dc8a3b0..c2b87481106ce25768eb73f61653907378f97a03 100644
--- go-ethereum/ethclient/ethclient_test.go
+++ op-geth/ethclient/ethclient_test.go
@@ -20,10 +20,16 @@ import (
"bytes"
"context"
"errors"
+ "fmt"
"math/big"
+ "net"
+ "net/http"
"reflect"
"testing"
"time"
+
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/internal/ethapi"
"github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/common"
@@ -193,6 +199,21 @@ Timestamp: 9000,
BaseFee: big.NewInt(params.InitialBaseFee),
}
+var genesisForHistorical = &core.Genesis{
+ Config: params.OptimismTestConfig,
+ Alloc: core.GenesisAlloc{testAddr: {Balance: testBalance}},
+ ExtraData: []byte("test genesis"),
+ Timestamp: 9000,
+ BaseFee: big.NewInt(params.InitialBaseFee),
+}
+
+var depositTx = types.NewTx(&types.DepositTx{
+ Value: big.NewInt(12),
+ Gas: params.TxGas + 2000,
+ To: &common.Address{2},
+ Data: make([]byte, 500),
+})
+
var testTx1 = types.MustSignNewTx(testKey, types.LatestSigner(genesis.Config), &types.LegacyTx{
Nonce: 0,
Value: big.NewInt(12),
@@ -209,9 +230,64 @@ Gas: params.TxGas,
To: &common.Address{2},
})
-func newTestBackend(t *testing.T) (*node.Node, []*types.Block) {
+type mockHistoricalBackend struct{}
+
+func (m *mockHistoricalBackend) Call(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *ethapi.StateOverride) (hexutil.Bytes, error) {
+ num, ok := blockNrOrHash.Number()
+ if ok && num == 1 {
+ return hexutil.Bytes("test"), nil
+ }
+ return nil, ethereum.NotFound
+}
+
+func (m *mockHistoricalBackend) EstimateGas(ctx context.Context, args ethapi.TransactionArgs, blockNrOrHash *rpc.BlockNumberOrHash) (hexutil.Uint64, error) {
+ num, ok := blockNrOrHash.Number()
+ if ok && num == 1 {
+ return hexutil.Uint64(12345), nil
+ }
+ return 0, ethereum.NotFound
+}
+
+func newMockHistoricalBackend(t *testing.T) string {
+ s := rpc.NewServer()
+ err := node.RegisterApis([]rpc.API{
+ {
+ Namespace: "eth",
+ Service: new(mockHistoricalBackend),
+ Public: true,
+ Authenticated: false,
+ },
+ }, nil, s)
+ if err != nil {
+ t.Fatalf("error creating mock historical backend: %v", err)
+ }
+
+ hdlr := node.NewHTTPHandlerStack(s, []string{"*"}, []string{"*"}, nil)
+ mux := http.NewServeMux()
+ mux.Handle("/", hdlr)
+
+ listener, err := net.Listen("tcp", "127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("error creating mock historical backend listener: %v", err)
+ }
+
+ go func() {
+ httpS := &http.Server{Handler: mux}
+ httpS.Serve(listener)
+
+ t.Cleanup(func() {
+ httpS.Shutdown(context.Background())
+ })
+ }()
+
+ return fmt.Sprintf("http://%s", listener.Addr().String())
+}
+
+func newTestBackend(t *testing.T, enableHistoricalState bool) (*node.Node, []*types.Block) {
+ histAddr := newMockHistoricalBackend(t)
+
// Generate test chain.
- blocks := generateTestChain()
+ blocks := generateTestChain(enableHistoricalState)
// Create node
n, err := node.New(&node.Config{})
@@ -219,7 +295,17 @@ if err != nil {
t.Fatalf("can't create new node: %v", err)
}
// Create Ethereum Service
- config := ðconfig.Config{Genesis: genesis}
+ var actualGenesis *core.Genesis
+ if enableHistoricalState {
+ actualGenesis = genesisForHistorical
+ } else {
+ actualGenesis = genesis
+ }
+ config := ðconfig.Config{Genesis: actualGenesis}
+ if enableHistoricalState {
+ config.RollupHistoricalRPC = histAddr
+ config.RollupHistoricalRPCTimeout = time.Second * 5
+ }
ethservice, err := eth.New(n, config)
if err != nil {
t.Fatalf("can't create new ethereum service: %v", err)
@@ -234,22 +320,40 @@ }
return n, blocks
}
-func generateTestChain() []*types.Block {
+func generateTestChain(enableHistoricalState bool) []*types.Block {
generate := func(i int, g *core.BlockGen) {
g.OffsetTime(5)
g.SetExtra([]byte("test"))
if i == 1 {
// Test transactions are included in block #2.
+ if enableHistoricalState {
+ g.AddTx(depositTx)
+ }
g.AddTx(testTx1)
g.AddTx(testTx2)
}
}
- _, blocks, _ := core.GenerateChainWithGenesis(genesis, ethash.NewFaker(), 2, generate)
- return append([]*types.Block{genesis.ToBlock()}, blocks...)
+ var actualGenesis *core.Genesis
+ if enableHistoricalState {
+ actualGenesis = genesisForHistorical
+ } else {
+ actualGenesis = genesis
+ }
+ _, blocks, _ := core.GenerateChainWithGenesis(actualGenesis, ethash.NewFaker(), 2, generate)
+ return append([]*types.Block{actualGenesis.ToBlock()}, blocks...)
+}
+
+func TestEthClientHistoricalBackend(t *testing.T) {
+ backend, _ := newTestBackend(t, true)
+ client := backend.Attach()
+ defer backend.Close()
+ defer client.Close()
+
+ testHistoricalRPC(t, client)
}
func TestEthClient(t *testing.T) {
- backend, chain := newTestBackend(t)
+ backend, chain := newTestBackend(t, false)
client := backend.Attach()
defer backend.Close()
defer client.Close()
@@ -286,6 +390,9 @@ func(t *testing.T) { testAtFunctions(t, client) },
},
"TransactionSender": {
func(t *testing.T) { testTransactionSender(t, client) },
+ },
+ "EstimateGas": {
+ func(t *testing.T) { testEstimateGas(t, client) },
},
}
@@ -717,6 +824,54 @@ t.Fatal(err)
}
if sender2 != testAddr {
t.Fatal("wrong sender:", sender2)
+ }
+}
+
+func testEstimateGas(t *testing.T, client *rpc.Client) {
+ ec := NewClient(client)
+
+ // EstimateGas
+ msg := ethereum.CallMsg{
+ From: testAddr,
+ To: &common.Address{},
+ Gas: 21000,
+ Value: big.NewInt(1),
+ }
+ gas, err := ec.EstimateGas(context.Background(), msg)
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if gas != 21000 {
+ t.Fatalf("unexpected gas price: %v", gas)
+ }
+}
+
+func testHistoricalRPC(t *testing.T, client *rpc.Client) {
+ ec := NewClient(client)
+
+ // Estimate Gas RPC
+ msg := ethereum.CallMsg{
+ From: testAddr,
+ To: &common.Address{},
+ Gas: 21000,
+ Value: big.NewInt(1),
+ }
+ var res hexutil.Uint64
+ err := client.CallContext(context.Background(), &res, "eth_estimateGas", toCallArg(msg), rpc.BlockNumberOrHashWithNumber(1))
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if res != 12345 {
+ t.Fatalf("invalid result: %d", res)
+ }
+
+ // Call Contract RPC
+ histVal, err := ec.CallContract(context.Background(), msg, big.NewInt(1))
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if string(histVal) != "test" {
+ t.Fatalf("expected %s to equal test", string(histVal))
}
}
diff --git go-ethereum/eth/tracers/api_test.go op-geth/eth/tracers/api_test.go
index 0f78af9a01e5c4857ccc0475f9067bed83276159..b2d68e09e8cff52079b7906ecfb7f4f3162133d6 100644
--- go-ethereum/eth/tracers/api_test.go
+++ op-geth/eth/tracers/api_test.go
@@ -23,11 +23,14 @@ "encoding/json"
"errors"
"fmt"
"math/big"
+ "net"
+ "net/http"
"reflect"
"sync/atomic"
"testing"
"time"
+ "github.com/davecgh/go-spew/spew"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/consensus"
@@ -41,16 +44,79 @@ "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/eth/tracers/logger"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/internal/ethapi"
+ "github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rpc"
+ "github.com/stretchr/testify/mock"
"golang.org/x/exp/slices"
)
var (
- errStateNotFound = errors.New("state not found")
- errBlockNotFound = errors.New("block not found")
+ errStateNotFound = errors.New("state not found")
+ errBlockNotFound = errors.New("block not found")
+ errTransactionNotFound = errors.New("transaction not found")
)
+type mockHistoricalBackend struct {
+ mock.Mock
+}
+
+// mockHistoricalBackend does not have a TraceCall, because pre-bedrock there is no debug_traceCall available
+
+func (m *mockHistoricalBackend) TraceBlockByNumber(ctx context.Context, number rpc.BlockNumber, config *TraceConfig) ([]*txTraceResult, error) {
+ ret := m.Mock.MethodCalled("TraceBlockByNumber", number, config)
+ return ret[0].([]*txTraceResult), *ret[1].(*error)
+}
+
+func (m *mockHistoricalBackend) ExpectTraceBlockByNumber(number rpc.BlockNumber, config *TraceConfig, out []*txTraceResult, err error) {
+ m.Mock.On("TraceBlockByNumber", number, config).Once().Return(out, &err)
+}
+
+func (m *mockHistoricalBackend) TraceTransaction(ctx context.Context, hash common.Hash, config *TraceConfig) (interface{}, error) {
+ ret := m.Mock.MethodCalled("TraceTransaction", hash, config)
+ return ret[0], *ret[1].(*error)
+}
+
+func (m *mockHistoricalBackend) ExpectTraceTransaction(hash common.Hash, config *TraceConfig, out interface{}, err error) {
+ jsonOut, _ := json.Marshal(out)
+ m.Mock.On("TraceTransaction", hash, config).Once().Return(json.RawMessage(jsonOut), &err)
+}
+
+func newMockHistoricalBackend(t *testing.T, backend *mockHistoricalBackend) string {
+ s := rpc.NewServer()
+ err := node.RegisterApis([]rpc.API{
+ {
+ Namespace: "debug",
+ Service: backend,
+ Public: true,
+ Authenticated: false,
+ },
+ }, nil, s)
+ if err != nil {
+ t.Fatalf("error creating mock historical backend: %v", err)
+ }
+
+ hdlr := node.NewHTTPHandlerStack(s, []string{"*"}, []string{"*"}, nil)
+ mux := http.NewServeMux()
+ mux.Handle("/", hdlr)
+
+ listener, err := net.Listen("tcp", "127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("error creating mock historical backend listener: %v", err)
+ }
+
+ go func() {
+ httpS := &http.Server{Handler: mux}
+ httpS.Serve(listener)
+
+ t.Cleanup(func() {
+ httpS.Shutdown(context.Background())
+ })
+ }()
+
+ return fmt.Sprintf("http://%s", listener.Addr().String())
+}
+
type testBackend struct {
chainConfig *params.ChainConfig
engine consensus.Engine
@@ -59,15 +125,28 @@ chain *core.BlockChain
refHook func() // Hook is invoked when the requested state is referenced
relHook func() // Hook is invoked when the requested state is released
+
+ historical *rpc.Client
+ mockHistorical *mockHistoricalBackend
}
// testBackend creates a new test backend. OBS: After test is done, teardown must be
// invoked in order to release associated resources.
func newTestBackend(t *testing.T, n int, gspec *core.Genesis, generator func(i int, b *core.BlockGen)) *testBackend {
+ mock := new(mockHistoricalBackend)
+ historicalAddr := newMockHistoricalBackend(t, mock)
+
+ historicalClient, err := rpc.Dial(historicalAddr)
+ if err != nil {
+ t.Fatalf("error making historical client: %v", err)
+ }
+
backend := &testBackend{
- chainConfig: gspec.Config,
- engine: ethash.NewFaker(),
- chaindb: rawdb.NewMemoryDatabase(),
+ chainConfig: gspec.Config,
+ engine: ethash.NewFaker(),
+ chaindb: rawdb.NewMemoryDatabase(),
+ historical: historicalClient,
+ mockHistorical: mock,
}
// Generate blocks for testing
_, blocks, _ := core.GenerateChainWithGenesis(gspec, backend.engine, n, generator)
@@ -115,6 +194,9 @@ }
func (b *testBackend) GetTransaction(ctx context.Context, txHash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, error) {
tx, hash, blockNumber, index := rawdb.ReadTransaction(b.chaindb, txHash)
+ if tx == nil {
+ return nil, common.Hash{}, 0, 0, errTransactionNotFound
+ }
return tx, hash, blockNumber, index, nil
}
@@ -172,7 +254,7 @@ signer := types.MakeSigner(b.chainConfig, block.Number(), block.Time())
for idx, tx := range block.Transactions() {
msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee())
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(block.Header(), b.chain, nil)
+ context := core.NewEVMBlockContext(block.Header(), b.chain, nil, b.chainConfig, statedb)
if idx == txIndex {
return msg, context, statedb, release, nil
}
@@ -183,6 +265,10 @@ }
statedb.Finalise(vmenv.ChainConfig().IsEIP158(block.Number()))
}
return nil, vm.BlockContext{}, nil, nil, fmt.Errorf("transaction index %d out of range for block %#x", txIndex, block.Hash())
+}
+
+func (b *testBackend) HistoricalRPCService() *rpc.Client {
+ return b.historical
}
func TestTraceCall(t *testing.T) {
@@ -360,11 +446,58 @@ StructLogs: []logger.StructLogRes{},
}) {
t.Error("Transaction tracing result is different")
}
+}
+func TestTraceTransactionHistorical(t *testing.T) {
+ t.Parallel()
- // Test non-existent transaction
- _, err = api.TraceTransaction(context.Background(), common.Hash{42}, nil)
- if !errors.Is(err, errTxNotFound) {
- t.Fatalf("want %v, have %v", errTxNotFound, err)
+ // Initialize test accounts
+ accounts := newAccounts(2)
+ genesis := &core.Genesis{
+ Config: params.OptimismTestConfig,
+ Alloc: core.GenesisAlloc{
+ accounts[0].addr: {Balance: big.NewInt(params.Ether)},
+ accounts[1].addr: {Balance: big.NewInt(params.Ether)},
+ },
+ }
+ target := common.Hash{}
+ signer := types.HomesteadSigner{}
+ backend := newTestBackend(t, 1, genesis, func(i int, b *core.BlockGen) {
+ // Transfer from account[0] to account[1]
+ // value: 1000 wei
+ // fee: 0 wei
+ tx, _ := types.SignTx(types.NewTransaction(uint64(i), accounts[1].addr, big.NewInt(1000), params.TxGas, b.BaseFee(), nil), signer, accounts[0].key)
+ b.AddTx(tx)
+ target = tx.Hash()
+ })
+ defer backend.mockHistorical.AssertExpectations(t)
+ defer backend.chain.Stop()
+ backend.mockHistorical.ExpectTraceTransaction(
+ target,
+ nil,
+ logger.ExecutionResult{
+ Gas: params.TxGas,
+ Failed: false,
+ ReturnValue: "",
+ StructLogs: []logger.StructLogRes{},
+ },
+ nil)
+ api := NewAPI(backend)
+ result, err := api.TraceTransaction(context.Background(), target, nil)
+ if err != nil {
+ t.Errorf("Failed to trace transaction %v", err)
+ }
+ var have *logger.ExecutionResult
+ spew.Dump(result)
+ if err := json.Unmarshal(result.(json.RawMessage), &have); err != nil {
+ t.Errorf("failed to unmarshal result %v", err)
+ }
+ if !reflect.DeepEqual(have, &logger.ExecutionResult{
+ Gas: params.TxGas,
+ Failed: false,
+ ReturnValue: "",
+ StructLogs: []logger.StructLogRes{},
+ }) {
+ t.Error("Transaction tracing result is different")
}
}
@@ -448,6 +581,59 @@ want := tc.want
if string(have) != want {
t.Errorf("test %d, result mismatch, have\n%v\n, want\n%v\n", i, string(have), want)
}
+ }
+}
+
+func TestTraceBlockHistorical(t *testing.T) {
+ t.Parallel()
+
+ // Initialize test accounts
+ accounts := newAccounts(3)
+ genesis := &core.Genesis{
+ Config: params.OptimismTestConfig,
+ Alloc: core.GenesisAlloc{
+ accounts[0].addr: {Balance: big.NewInt(params.Ether)},
+ accounts[1].addr: {Balance: big.NewInt(params.Ether)},
+ accounts[2].addr: {Balance: big.NewInt(params.Ether)},
+ },
+ }
+ genBlocks := 10
+ signer := types.HomesteadSigner{}
+ backend := newTestBackend(t, genBlocks, genesis, func(i int, b *core.BlockGen) {
+ // Transfer from account[0] to account[1]
+ // value: 1000 wei
+ // fee: 0 wei
+ tx, _ := types.SignTx(types.NewTransaction(uint64(i), accounts[1].addr, big.NewInt(1000), params.TxGas, b.BaseFee(), nil), signer, accounts[0].key)
+ b.AddTx(tx)
+ })
+ defer backend.mockHistorical.AssertExpectations(t)
+ defer backend.chain.Stop()
+ api := NewAPI(backend)
+
+ var expectErr error
+ var config *TraceConfig
+ blockNumber := rpc.BlockNumber(3)
+ want := `[{"txHash":"0x0000000000000000000000000000000000000000000000000000000000000000","result":{"failed":false,"gas":21000,"returnValue":"","structLogs":[]}}]`
+ var ret []*txTraceResult
+ _ = json.Unmarshal([]byte(want), &ret)
+
+ backend.mockHistorical.ExpectTraceBlockByNumber(blockNumber, config, ret, nil)
+
+ result, err := api.TraceBlockByNumber(context.Background(), blockNumber, config)
+ if expectErr != nil {
+ if err == nil {
+ t.Errorf("want error %v", expectErr)
+ }
+ if !reflect.DeepEqual(err, expectErr) {
+ t.Errorf("error mismatch, want %v, get %v", expectErr, err)
+ }
+ }
+ if err != nil {
+ t.Errorf("want no error, have %v", err)
+ }
+ have, _ := json.Marshal(result)
+ if string(have) != want {
+ t.Errorf("result mismatch, have\n%v\n, want\n%v\n", string(have), want)
}
}
Debug API
+4
-1
Fix Debug API block marshaling to include deposits
diff --git go-ethereum/eth/api_debug.go op-geth/eth/api_debug.go
index dc9f56814699fcb26388741e29bd725cf0bcf225..5dec47de7942680d8d26f24d9ba6f2af423de260 100644
--- go-ethereum/eth/api_debug.go
+++ op-geth/eth/api_debug.go
@@ -119,7 +119,10 @@ blockRlp = err.Error() // Hacky, but hey, it works
} else {
blockRlp = fmt.Sprintf("%#x", rlpBytes)
}
- blockJSON = ethapi.RPCMarshalBlock(block, true, true, api.eth.APIBackend.ChainConfig())
+ var err error
+ if blockJSON, err = ethapi.RPCMarshalBlock(ctx, block, true, true, api.eth.APIBackend.ChainConfig(), api.eth.APIBackend); err != nil {
+ blockJSON = map[string]interface{}{"error": err.Error()}
+ }
results = append(results, &BadBlockArgs{
Hash: block.Hash(),
RLP: blockRlp,
Eth gasprice suggestions
+139
-1
gasprice suggestion adjustments to accommodate faster L2 blocks and lower fees.
diff --git go-ethereum/eth/gasprice/gasprice.go op-geth/eth/gasprice/gasprice.go
index b71964981145fa58b7894a2be4637d8a7e2a6c9a..e8ef6c7459ecd92841f902d54f9bf124930053df 100644
--- go-ethereum/eth/gasprice/gasprice.go
+++ op-geth/eth/gasprice/gasprice.go
@@ -37,6 +37,8 @@
var (
DefaultMaxPrice = big.NewInt(500 * params.GWei)
DefaultIgnorePrice = big.NewInt(2 * params.Wei)
+
+ DefaultMinSuggestedPriorityFee = big.NewInt(1e6 * params.Wei) // 0.001 gwei, for Optimism fee suggestion
)
type Config struct {
@@ -47,6 +49,8 @@ MaxBlockHistory uint64
Default *big.Int `toml:",omitempty"`
MaxPrice *big.Int `toml:",omitempty"`
IgnorePrice *big.Int `toml:",omitempty"`
+
+ MinSuggestedPriorityFee *big.Int `toml:",omitempty"` // for Optimism fee suggestion
}
// OracleBackend includes all necessary background APIs for oracle.
@@ -74,6 +78,8 @@ checkBlocks, percentile int
maxHeaderHistory, maxBlockHistory uint64
historyCache *lru.Cache[cacheKey, processedFees]
+
+ minSuggestedPriorityFee *big.Int // for Optimism fee suggestion
}
// NewOracle returns a new gasprice oracle which can recommend suitable
@@ -128,7 +134,7 @@ lastHead = ev.Block.Hash()
}
}()
- return &Oracle{
+ r := &Oracle{
backend: backend,
lastPrice: params.Default,
maxPrice: maxPrice,
@@ -139,6 +145,17 @@ maxHeaderHistory: maxHeaderHistory,
maxBlockHistory: maxBlockHistory,
historyCache: cache,
}
+
+ if backend.ChainConfig().IsOptimism() {
+ r.minSuggestedPriorityFee = params.MinSuggestedPriorityFee
+ if r.minSuggestedPriorityFee == nil || r.minSuggestedPriorityFee.Int64() <= 0 {
+ r.minSuggestedPriorityFee = DefaultMinSuggestedPriorityFee
+ log.Warn("Sanitizing invalid optimism gasprice oracle min priority fee suggestion",
+ "provided", params.MinSuggestedPriorityFee,
+ "updated", r.minSuggestedPriorityFee)
+ }
+ }
+ return r
}
// SuggestTipCap returns a tip cap so that newly created transaction can have a
@@ -168,6 +185,11 @@ oracle.cacheLock.RUnlock()
if headHash == lastHead {
return new(big.Int).Set(lastPrice), nil
}
+
+ if oracle.backend.ChainConfig().IsOptimism() {
+ return oracle.SuggestOptimismPriorityFee(ctx, head, headHash), nil
+ }
+
var (
sent, exp int
number = head.Number.Uint64()
@@ -274,3 +296,9 @@ case result <- results{prices, nil}:
case <-quit:
}
}
+
+type bigIntArray []*big.Int
+
+func (s bigIntArray) Len() int { return len(s) }
+func (s bigIntArray) Less(i, j int) bool { return s[i].Cmp(s[j]) < 0 }
+func (s bigIntArray) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
diff --git go-ethereum/eth/gasprice/optimism-gasprice.go op-geth/eth/gasprice/optimism-gasprice.go
new file mode 100644
index 0000000000000000000000000000000000000000..71cd021f637f92e4b6d99ec5fc337d27edf547e5
--- /dev/null
+++ op-geth/eth/gasprice/optimism-gasprice.go
@@ -0,0 +1,110 @@
+package gasprice
+
+import (
+ "context"
+ "math/big"
+ "sort"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/rpc"
+)
+
+// SuggestOptimismPriorityFee returns a max priority fee value that can be used such that newly
+// created transactions have a very high chance to be included in the following blocks, using a
+// simplified and more predictable algorithm appropriate for chains like Optimism with a single
+// known block builder.
+//
+// In the typical case, which results whenever the last block had room for more transactions, this
+// function returns a minimum suggested priority fee value. Otherwise it returns the higher of this
+// minimum suggestion or 10% over the median effective priority fee from the last block.
+//
+// Rationale: For a chain such as Optimism where there is a single block builder whose behavior is
+// known, we know priority fee (as long as it is non-zero) has no impact on the probability for tx
+// inclusion as long as there is capacity for it in the block. In this case then, there's no reason
+// to return any value higher than some fixed minimum. Blocks typically reach capacity only under
+// extreme events such as airdrops, meaning predicting whether the next block is going to be at
+// capacity is difficult *except* in the case where we're already experiencing the increased demand
+// from such an event. We therefore expect whether the last known block is at capacity to be one of
+// the best predictors of whether the next block is likely to be at capacity. (An even better
+// predictor is to look at the state of the transaction pool, but we want an algorithm that works
+// even if the txpool is private or unavailable.)
+//
+// In the event the next block may be at capacity, the algorithm should allow for average fees to
+// rise in order to reach a market price that appropriately reflects demand. We accomplish this by
+// returning a suggestion that is a significant amount (10%) higher than the median effective
+// priority fee from the previous block.
+func (oracle *Oracle) SuggestOptimismPriorityFee(ctx context.Context, h *types.Header, headHash common.Hash) *big.Int {
+ suggestion := new(big.Int).Set(oracle.minSuggestedPriorityFee)
+
+ // find the maximum gas used by any of the transactions in the block to use as the capacity
+ // margin
+ receipts, err := oracle.backend.GetReceipts(ctx, headHash)
+ if receipts == nil || err != nil {
+ log.Error("failed to get block receipts", "err", err)
+ return suggestion
+ }
+ var maxTxGasUsed uint64
+ for i := range receipts {
+ gu := receipts[i].GasUsed
+ if gu > maxTxGasUsed {
+ maxTxGasUsed = gu
+ }
+ }
+
+ // sanity check the max gas used value
+ if maxTxGasUsed > h.GasLimit {
+ log.Error("found tx consuming more gas than the block limit", "gas", maxTxGasUsed)
+ return suggestion
+ }
+
+ if h.GasUsed+maxTxGasUsed > h.GasLimit {
+ // A block is "at capacity" if, when it is built, there is a pending tx in the txpool that
+ // could not be included because the block's gas limit would be exceeded. Since we don't
+ // have access to the txpool, we instead adopt the following heuristic: consider a block as
+ // at capacity if the total gas consumed by its transactions is within max-tx-gas-used of
+ // the block limit, where max-tx-gas-used is the most gas used by any one transaction
+ // within the block. This heuristic is almost perfectly accurate when transactions always
+ // consume the same amount of gas, but becomes less accurate as tx gas consumption begins
+ // to vary. The typical error is we assume a block is at capacity when it was not because
+ // max-tx-gas-used will in most cases over-estimate the "capacity margin". But it's better
+ // to err on the side of returning a higher-than-needed suggestion than a lower-than-needed
+ // one in order to satisfy our desire for high chance of inclusion and rising fees under
+ // high demand.
+ block, err := oracle.backend.BlockByNumber(ctx, rpc.BlockNumber(h.Number.Int64()))
+ if block == nil || err != nil {
+ log.Error("failed to get last block", "err", err)
+ return suggestion
+ }
+ baseFee := block.BaseFee()
+ txs := block.Transactions()
+ if len(txs) == 0 {
+ log.Error("block was at capacity but doesn't have transactions")
+ return suggestion
+ }
+ tips := bigIntArray(make([]*big.Int, len(txs)))
+ for i := range txs {
+ tips[i] = txs[i].EffectiveGasTipValue(baseFee)
+ }
+ sort.Sort(tips)
+ median := tips[len(tips)/2]
+ newSuggestion := new(big.Int).Add(median, new(big.Int).Div(median, big.NewInt(10)))
+ // use the new suggestion only if it's bigger than the minimum
+ if newSuggestion.Cmp(suggestion) > 0 {
+ suggestion = newSuggestion
+ }
+ }
+
+ // the suggestion should be capped by oracle.maxPrice
+ if suggestion.Cmp(oracle.maxPrice) > 0 {
+ suggestion.Set(oracle.maxPrice)
+ }
+
+ oracle.cacheLock.Lock()
+ oracle.lastHead = headHash
+ oracle.lastPrice = suggestion
+ oracle.cacheLock.Unlock()
+
+ return new(big.Int).Set(suggestion)
+}
API testvector fix
+1
-1
Upstream test of broken behavior; in Optimism, a zero signature is valid (pre-bedrock for deposit-txs), and the chain ID formula on signature data must not be used, or an underflow happens.
diff --git go-ethereum/internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json op-geth/internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json
index 1d524d6eced19249ab7f1d7beeb04863087e81c1..7087932286ea7facdae1e56caf15e618b5307e71 100644
--- go-ethereum/internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json
+++ op-geth/internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json
@@ -30,7 +30,7 @@ "to": "0x0d3ab14bbad3d99f4203bd7a11acb94882050e7e",
"transactionIndex": "0x0",
"value": "0x6f",
"type": "0x0",
- "chainId": "0x7fffffffffffffee",
+ "chainId": "0x1",
"v": "0x0",
"r": "0x0",
"s": "0x0"
Geth extras
+91
-19
Extend the tools available in geth to improve external testing and tooling.
Simulated Backend
+91
-19
diff --git go-ethereum/accounts/abi/bind/backends/simulated.go op-geth/accounts/abi/bind/backends/simulated.go
index a26ee12e0ad11ac2bd76d74ea4ccba53a45f0a77..d3d55fd052ef89a2cf413c91e86b376144950742 100644
--- go-ethereum/accounts/abi/bind/backends/simulated.go
+++ op-geth/accounts/abi/bind/backends/simulated.go
@@ -30,6 +30,7 @@ "github.com/ethereum/go-ethereum/accounts/abi/bind"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/common/math"
+ "github.com/ethereum/go-ethereum/consensus"
"github.com/ethereum/go-ethereum/consensus/ethash"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/bloombits"
@@ -43,6 +44,7 @@ "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rpc"
+ "github.com/ethereum/go-ethereum/trie"
)
// This nil assignment ensures at compile time that SimulatedBackend implements bind.ContractBackend.
@@ -63,6 +65,8 @@ // DeployBackend, GasEstimator, GasPricer, LogFilterer, PendingContractCaller, TransactionReader, and TransactionSender
type SimulatedBackend struct {
database ethdb.Database // In memory database to store our testing data
blockchain *core.BlockChain // Ethereum blockchain to handle the consensus
+
+ consensus consensus.Engine
mu sync.Mutex
pendingBlock *types.Block // Currently pending block that will be imported on request
@@ -79,20 +83,93 @@ // NewSimulatedBackendWithDatabase creates a new binding backend based on the given database
// and uses a simulated blockchain for testing purposes.
// A simulated backend always uses chainID 1337.
func NewSimulatedBackendWithDatabase(database ethdb.Database, alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend {
- genesis := core.Genesis{
- Config: params.AllEthashProtocolChanges,
- GasLimit: gasLimit,
- Alloc: alloc,
+ return NewSimulatedBackendWithOpts(WithDatabase(database), WithAlloc(alloc), WithGasLimit(gasLimit))
+}
+
+// NewSimulatedBackend creates a new binding backend using a simulated blockchain
+// for testing purposes.
+// A simulated backend always uses chainID 1337.
+func NewSimulatedBackend(alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend {
+ return NewSimulatedBackendWithOpts(WithGasLimit(gasLimit), WithAlloc(alloc))
+}
+
+type simulatedBackendConfig struct {
+ genesis core.Genesis
+ cacheConfig *core.CacheConfig
+ database ethdb.Database
+ vmConfig vm.Config
+ consensus consensus.Engine
+}
+
+type SimulatedBackendOpt func(s *simulatedBackendConfig)
+
+func WithDatabase(database ethdb.Database) SimulatedBackendOpt {
+ return func(s *simulatedBackendConfig) {
+ s.database = database
}
- blockchain, _ := core.NewBlockChain(database, nil, &genesis, nil, ethash.NewFaker(), vm.Config{}, nil, nil)
+}
+
+func WithGasLimit(gasLimit uint64) SimulatedBackendOpt {
+ return func(s *simulatedBackendConfig) {
+ s.genesis.GasLimit = gasLimit
+ }
+}
+
+func WithAlloc(alloc core.GenesisAlloc) SimulatedBackendOpt {
+ return func(s *simulatedBackendConfig) {
+ s.genesis.Alloc = alloc
+ }
+}
+
+func WithCacheConfig(cacheConfig *core.CacheConfig) SimulatedBackendOpt {
+ return func(s *simulatedBackendConfig) {
+ s.cacheConfig = cacheConfig
+ }
+}
+
+func WithGenesis(genesis core.Genesis) SimulatedBackendOpt {
+ return func(s *simulatedBackendConfig) {
+ s.genesis = genesis
+ }
+}
+
+func WithVMConfig(vmConfig vm.Config) SimulatedBackendOpt {
+ return func(s *simulatedBackendConfig) {
+ s.vmConfig = vmConfig
+ }
+}
+
+func WithConsensus(consensus consensus.Engine) SimulatedBackendOpt {
+ return func(s *simulatedBackendConfig) {
+ s.consensus = consensus
+ }
+}
+
+// NewSimulatedBackendWithOpts creates a new binding backend based on the given database
+// and uses a simulated blockchain for testing purposes. It exposes additional configuration
+// options that are useful to
+func NewSimulatedBackendWithOpts(opts ...SimulatedBackendOpt) *SimulatedBackend {
+ config := &simulatedBackendConfig{
+ genesis: core.Genesis{Config: params.AllEthashProtocolChanges, GasLimit: 100000000, Alloc: make(core.GenesisAlloc)},
+ database: rawdb.NewMemoryDatabase(),
+ consensus: ethash.NewFaker(),
+ }
+
+ for _, opt := range opts {
+ opt(config)
+ }
+
+ config.genesis.MustCommit(config.database, trie.NewDatabase(config.database, trie.HashDefaults))
+ blockchain, _ := core.NewBlockChain(config.database, config.cacheConfig, &config.genesis, nil, config.consensus, config.vmConfig, nil, nil)
backend := &SimulatedBackend{
- database: database,
+ database: config.database,
blockchain: blockchain,
- config: genesis.Config,
+ config: config.genesis.Config,
+ consensus: config.consensus,
}
- filterBackend := &filterBackend{database, blockchain, backend}
+ filterBackend := &filterBackend{config.database, blockchain, backend}
backend.filterSystem = filters.NewFilterSystem(filterBackend, filters.Config{})
backend.events = filters.NewEventSystem(backend.filterSystem, false)
@@ -103,13 +180,6 @@ backend.rollback(block)
return backend
}
-// NewSimulatedBackend creates a new binding backend using a simulated blockchain
-// for testing purposes.
-// A simulated backend always uses chainID 1337.
-func NewSimulatedBackend(alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend {
- return NewSimulatedBackendWithDatabase(rawdb.NewMemoryDatabase(), alloc, gasLimit)
-}
-
// Close terminates the underlying blockchain's update loop.
func (b *SimulatedBackend) Close() error {
b.blockchain.Stop()
@@ -125,6 +195,8 @@
if _, err := b.blockchain.InsertChain([]*types.Block{b.pendingBlock}); err != nil {
panic(err) // This cannot happen unless the simulator is wrong, fail in that case
}
+ // Don't wait for the async tx indexing
+ rawdb.WriteTxLookupEntriesByBlock(b.database, b.pendingBlock)
blockHash := b.pendingBlock.Hash()
// Using the last inserted block here makes it possible to build on a side
@@ -146,7 +218,7 @@ b.rollback(block)
}
func (b *SimulatedBackend) rollback(parent *types.Block) {
- blocks, _ := core.GenerateChain(b.config, parent, ethash.NewFaker(), b.database, 1, func(int, *core.BlockGen) {})
+ blocks, _ := core.GenerateChain(b.config, parent, b.consensus, b.database, 1, func(int, *core.BlockGen) {})
b.pendingBlock = blocks[0]
b.pendingState, _ = state.New(b.pendingBlock.Root(), b.blockchain.StateCache(), nil)
@@ -700,7 +772,7 @@
// Create a new environment which holds all relevant information
// about the transaction and calling mechanisms.
txContext := core.NewEVMTxContext(msg)
- evmContext := core.NewEVMBlockContext(header, b.blockchain, nil)
+ evmContext := core.NewEVMBlockContext(header, b.blockchain, nil, b.config, stateDB)
vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{NoBaseFee: true})
gasPool := new(core.GasPool).AddGas(math.MaxUint64)
@@ -728,7 +800,7 @@ if tx.Nonce() != nonce {
return fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), nonce)
}
// Include tx in chain
- blocks, receipts := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
+ blocks, receipts := core.GenerateChain(b.config, block, b.consensus, b.database, 1, func(number int, block *core.BlockGen) {
for _, tx := range b.pendingBlock.Transactions() {
block.AddTxWithChain(b.blockchain, tx)
}
@@ -854,7 +926,7 @@ if block == nil {
return errors.New("could not find parent")
}
- blocks, _ := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
+ blocks, _ := core.GenerateChain(b.config, block, b.consensus, b.database, 1, func(number int, block *core.BlockGen) {
block.OffsetTime(int64(adjustment.Seconds()))
})
stateDB, err := b.blockchain.State()
Other changes
+1517
-53
diff --git go-ethereum/Makefile op-geth/Makefile
index d736ef61c001ec02581a6867982291cdf684b3ab..226bac2d1e1b87b26dd70989b37e32117a1837fe 100644
--- go-ethereum/Makefile
+++ op-geth/Makefile
@@ -36,3 +36,9 @@ env GOBIN= go install github.com/golang/protobuf/protoc-gen-go@latest
env GOBIN= go install ./cmd/abigen
@type "solc" 2> /dev/null || echo 'Please install solc'
@type "protoc" 2> /dev/null || echo 'Please install protoc'
+
+forkdiff:
+ docker run --rm \
+ --mount src=$(shell pwd),target=/host-pwd,type=bind \
+ protolambda/forkdiff:latest \
+ -repo /host-pwd/ -fork /host-pwd/fork.yaml -out /host-pwd/forkdiff.html
diff --git go-ethereum/cmd/devp2p/internal/ethtest/snap.go op-geth/cmd/devp2p/internal/ethtest/snap.go
index 54eb63f3deb2f1dcb16f5b70582473c832852e8e..14087af4f8f94f146d942035a669e88cda1c754e 100644
--- go-ethereum/cmd/devp2p/internal/ethtest/snap.go
+++ op-geth/cmd/devp2p/internal/ethtest/snap.go
@@ -249,11 +249,11 @@ for i, tc := range []byteCodesTest{
// A few stateroots
{
nBytes: 10000, hashes: []common.Hash{s.chain.RootAt(0), s.chain.RootAt(999)},
- expHashes: 0,
+ expHashes: 1, // 32-byte keys are detected as code, even if not code (like genesis hash), in legacy lookups.
},
{
nBytes: 10000, hashes: []common.Hash{s.chain.RootAt(0), s.chain.RootAt(0)},
- expHashes: 0,
+ expHashes: 2, // 32-byte keys are detected as code, even if not code (like genesis hash), in legacy lookups.
},
// Empties
{
diff --git go-ethereum/cmd/evm/internal/t8ntool/transition.go op-geth/cmd/evm/internal/t8ntool/transition.go
index d517592e5cfb4693533baf1d5b199b00e50b7a8b..971adffec2200eb8cefa21e947ad11ef7b6bc702 100644
--- go-ethereum/cmd/evm/internal/t8ntool/transition.go
+++ op-geth/cmd/evm/internal/t8ntool/transition.go
@@ -231,7 +231,7 @@ Number: new(big.Int).SetUint64(env.Number - 1),
BaseFee: env.ParentBaseFee,
GasUsed: env.ParentGasUsed,
GasLimit: env.ParentGasLimit,
- })
+ }, env.Timestamp)
return nil
}
diff --git go-ethereum/consensus/misc/create2deployer.go op-geth/consensus/misc/create2deployer.go
new file mode 100644
index 0000000000000000000000000000000000000000..27c87a4a8c45b1e859719e8d4f8e5775ff3da0ca
--- /dev/null
+++ op-geth/consensus/misc/create2deployer.go
@@ -0,0 +1,37 @@
+package misc
+
+import (
+ "github.com/ethereum-optimism/superchain-registry/superchain"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/params"
+)
+
+// The original create2deployer contract could not be deployed to Base mainnet at
+// the canonical address of 0x13b0D85CcB8bf860b6b79AF3029fCA081AE9beF2 due to
+// an accidental nonce increment from a deposit transaction. See
+// https://github.com/pcaversaccio/create2deployer/issues/128 for context. This
+// file applies the contract code to the canonical address manually in the Canyon
+// hardfork.
+
+var create2DeployerAddress = common.HexToAddress("0x13b0D85CcB8bf860b6b79AF3029fCA081AE9beF2")
+var create2DeployerCodeHash = common.HexToHash("0xb0550b5b431e30d38000efb7107aaa0ade03d48a7198a140edda9d27134468b2")
+var create2DeployerCode []byte
+
+func init() {
+ code, err := superchain.LoadContractBytecode(superchain.Hash(create2DeployerCodeHash))
+ if err != nil {
+ panic(err)
+ }
+ create2DeployerCode = code
+}
+
+func EnsureCreate2Deployer(c *params.ChainConfig, timestamp uint64, db vm.StateDB) {
+ if !c.IsOptimism() || c.CanyonTime == nil || *c.CanyonTime != timestamp {
+ return
+ }
+ log.Info("Setting Create2Deployer code", "address", create2DeployerAddress, "codeHash", create2DeployerCodeHash)
+ db.SetCode(create2DeployerAddress, create2DeployerCode)
+}
diff --git go-ethereum/consensus/misc/create2deployer_test.go op-geth/consensus/misc/create2deployer_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..fc0ef79fd7739d92431085d515481be8621e8fcb
--- /dev/null
+++ op-geth/consensus/misc/create2deployer_test.go
@@ -0,0 +1,95 @@
+package misc
+
+import (
+ "math/big"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/params"
+)
+
+func TestEnsureCreate2Deployer(t *testing.T) {
+ canyonTime := uint64(1000)
+ var tests = []struct {
+ name string
+ override func(cfg *params.ChainConfig)
+ timestamp uint64
+ codeExists bool
+ applied bool
+ }{
+ {
+ name: "at hardfork",
+ timestamp: canyonTime,
+ applied: true,
+ },
+ {
+ name: "another chain ID",
+ override: func(cfg *params.ChainConfig) {
+ cfg.ChainID = big.NewInt(params.OPMainnetChainID)
+ },
+ timestamp: canyonTime,
+ applied: true,
+ },
+ {
+ name: "code already exists",
+ timestamp: canyonTime,
+ codeExists: true,
+ applied: true,
+ },
+ {
+ name: "pre canyon",
+ timestamp: canyonTime - 1,
+ applied: false,
+ },
+ {
+ name: "post hardfork",
+ timestamp: canyonTime + 1,
+ applied: false,
+ },
+ {
+ name: "canyon not configured",
+ override: func(cfg *params.ChainConfig) {
+ cfg.CanyonTime = nil
+ },
+ timestamp: canyonTime,
+ applied: false,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ cfg := params.ChainConfig{
+ ChainID: big.NewInt(params.BaseMainnetChainID),
+ Optimism: ¶ms.OptimismConfig{},
+ CanyonTime: &canyonTime,
+ }
+ if tt.override != nil {
+ tt.override(&cfg)
+ }
+ state := &stateDb{
+ codeExists: tt.codeExists,
+ }
+ EnsureCreate2Deployer(&cfg, tt.timestamp, state)
+ assert.Equal(t, tt.applied, state.codeSet)
+ })
+ }
+}
+
+type stateDb struct {
+ vm.StateDB
+ codeExists bool
+ codeSet bool
+}
+
+func (s *stateDb) GetCodeSize(_ common.Address) int {
+ if s.codeExists {
+ return 1
+ }
+ return 0
+}
+
+func (s *stateDb) SetCode(_ common.Address, _ []byte) {
+ s.codeSet = true
+}
diff --git go-ethereum/consensus/misc/eip1559/eip1559_test.go op-geth/consensus/misc/eip1559/eip1559_test.go
index b5afdf0fe5e56ca6ced6031be233c6aafb17dcdd..d34da8fd8bbb21a6a649384435c3926a6735083d 100644
--- go-ethereum/consensus/misc/eip1559/eip1559_test.go
+++ op-geth/consensus/misc/eip1559/eip1559_test.go
@@ -55,6 +55,19 @@ config.LondonBlock = big.NewInt(5)
return config
}
+func opConfig() *params.ChainConfig {
+ config := copyConfig(params.TestChainConfig)
+ config.LondonBlock = big.NewInt(5)
+ ct := uint64(10)
+ config.CanyonTime = &ct
+ config.Optimism = ¶ms.OptimismConfig{
+ EIP1559Elasticity: 6,
+ EIP1559Denominator: 50,
+ EIP1559DenominatorCanyon: 250,
+ }
+ return config
+}
+
// TestBlockGasLimits tests the gasLimit checks for blocks both across
// the EIP-1559 boundary and post-1559 blocks
func TestBlockGasLimits(t *testing.T) {
@@ -124,7 +137,40 @@ GasLimit: test.parentGasLimit,
GasUsed: test.parentGasUsed,
BaseFee: big.NewInt(test.parentBaseFee),
}
- if have, want := CalcBaseFee(config(), parent), big.NewInt(test.expectedBaseFee); have.Cmp(want) != 0 {
+ if have, want := CalcBaseFee(config(), parent, 0), big.NewInt(test.expectedBaseFee); have.Cmp(want) != 0 {
+ t.Errorf("test %d: have %d want %d, ", i, have, want)
+ }
+ }
+}
+
+// TestCalcBaseFeeOptimism assumes all blocks are 1559-blocks but tests the Canyon activation
+func TestCalcBaseFeeOptimism(t *testing.T) {
+ tests := []struct {
+ parentBaseFee int64
+ parentGasLimit uint64
+ parentGasUsed uint64
+ expectedBaseFee int64
+ postCanyon bool
+ }{
+ {params.InitialBaseFee, 30_000_000, 5_000_000, params.InitialBaseFee, false}, // usage == target
+ {params.InitialBaseFee, 30_000_000, 4_000_000, 996000000, false}, // usage below target
+ {params.InitialBaseFee, 30_000_000, 10_000_000, 1020000000, false}, // usage above target
+ {params.InitialBaseFee, 30_000_000, 5_000_000, params.InitialBaseFee, true}, // usage == target
+ {params.InitialBaseFee, 30_000_000, 4_000_000, 999200000, true}, // usage below target
+ {params.InitialBaseFee, 30_000_000, 10_000_000, 1004000000, true}, // usage above target
+ }
+ for i, test := range tests {
+ parent := &types.Header{
+ Number: common.Big32,
+ GasLimit: test.parentGasLimit,
+ GasUsed: test.parentGasUsed,
+ BaseFee: big.NewInt(test.parentBaseFee),
+ Time: 6,
+ }
+ if test.postCanyon {
+ parent.Time = 8
+ }
+ if have, want := CalcBaseFee(opConfig(), parent, parent.Time+2), big.NewInt(test.expectedBaseFee); have.Cmp(want) != 0 {
t.Errorf("test %d: have %d want %d, ", i, have, want)
}
}
diff --git go-ethereum/core/chain_makers.go op-geth/core/chain_makers.go
index 31c111b73e06eb252274754bf320835fbc0a5897..90b5b1fcee370a8b5d23f567de0b9ed68b923107 100644
--- go-ethereum/core/chain_makers.go
+++ op-geth/core/chain_makers.go
@@ -97,7 +97,7 @@ // block.
func (b *BlockGen) SetParentBeaconRoot(root common.Hash) {
b.header.ParentBeaconRoot = &root
var (
- blockContext = NewEVMBlockContext(b.header, b.cm, &b.header.Coinbase)
+ blockContext = NewEVMBlockContext(b.header, b.cm, &b.header.Coinbase, b.cm.config, b.statedb)
vmenv = vm.NewEVM(blockContext, vm.TxContext{}, b.statedb, b.cm.config, vm.Config{})
)
ProcessBeaconBlockRoot(root, vmenv, b.statedb)
@@ -229,7 +229,7 @@
// The gas limit and price should be derived from the parent
h.GasLimit = parent.GasLimit
if b.cm.config.IsLondon(h.Number) {
- h.BaseFee = eip1559.CalcBaseFee(b.cm.config, parent)
+ h.BaseFee = eip1559.CalcBaseFee(b.cm.config, parent, h.Time)
if !b.cm.config.IsLondon(parent.Number) {
parentGasLimit := parent.GasLimit * b.cm.config.ElasticityMultiplier()
h.GasLimit = CalcGasLimit(parentGasLimit, parentGasLimit)
@@ -429,7 +429,7 @@ Time: time,
}
if cm.config.IsLondon(header.Number) {
- header.BaseFee = eip1559.CalcBaseFee(cm.config, parent.Header())
+ header.BaseFee = eip1559.CalcBaseFee(cm.config, parent.Header(), header.Time)
if !cm.config.IsLondon(parent.Number()) {
parentGasLimit := parent.GasLimit() * cm.config.ElasticityMultiplier()
header.GasLimit = CalcGasLimit(parentGasLimit, parentGasLimit)
diff --git go-ethereum/core/rawdb/accessors_chain_test.go op-geth/core/rawdb/accessors_chain_test.go
index a7ceb72998a115653130a19932f443dfda3f7cc4..3340c7f15c8200a11b2831abb90dd4a052b2b6f8 100644
--- go-ethereum/core/rawdb/accessors_chain_test.go
+++ op-geth/core/rawdb/accessors_chain_test.go
@@ -27,10 +27,12 @@ "reflect"
"testing"
"github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/math"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rlp"
+ "github.com/stretchr/testify/require"
"golang.org/x/crypto/sha3"
)
@@ -347,6 +349,9 @@ // Create a live block since we need metadata to reconstruct the receipt
tx1 := types.NewTransaction(1, common.HexToAddress("0x1"), big.NewInt(1), 1, big.NewInt(1), nil)
tx2 := types.NewTransaction(2, common.HexToAddress("0x2"), big.NewInt(2), 2, big.NewInt(2), nil)
+ header := &types.Header{
+ Number: big.NewInt(0),
+ }
body := &types.Body{Transactions: types.Transactions{tx1, tx2}}
// Create the two receipts to manage afterwards
@@ -378,13 +383,16 @@ receipt2.Bloom = types.CreateBloom(types.Receipts{receipt2})
receipts := []*types.Receipt{receipt1, receipt2}
// Check that no receipt entries are in a pristine database
- hash := common.BytesToHash([]byte{0x03, 0x14})
+ hash := header.Hash()
if rs := ReadReceipts(db, hash, 0, 0, params.TestChainConfig); len(rs) != 0 {
t.Fatalf("non existent receipts returned: %v", rs)
}
// Insert the body that corresponds to the receipts
WriteBody(db, hash, 0, body)
+ // Insert the header that corresponds to the receipts
+ WriteHeader(db, header)
+
// Insert the receipt slice into the database and check presence
WriteReceipts(db, hash, 0, receipts)
if rs := ReadReceipts(db, hash, 0, 0, params.TestChainConfig); len(rs) == 0 {
@@ -694,36 +702,56 @@
// Create a live block since we need metadata to reconstruct the receipt
tx1 := types.NewTransaction(1, common.HexToAddress("0x1"), big.NewInt(1), 1, big.NewInt(1), nil)
tx2 := types.NewTransaction(2, common.HexToAddress("0x2"), big.NewInt(2), 2, big.NewInt(2), nil)
+ tx3 := types.NewTransaction(3, common.HexToAddress("0x3"), big.NewInt(3), 3, big.NewInt(3), nil)
- body := &types.Body{Transactions: types.Transactions{tx1, tx2}}
+ body := &types.Body{Transactions: types.Transactions{tx1, tx2, tx3}}
- // Create the two receipts to manage afterwards
- receipt1 := &types.Receipt{
+ // Create the three receipts to manage afterwards
+ depositNonce := uint64(math.MaxUint64)
+ depositReceipt := types.Receipt{
Status: types.ReceiptStatusFailed,
CumulativeGasUsed: 1,
Logs: []*types.Log{
{Address: common.BytesToAddress([]byte{0x11})},
{Address: common.BytesToAddress([]byte{0x01, 0x11})},
},
- TxHash: tx1.Hash(),
- ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
- GasUsed: 111111,
+ TxHash: tx1.Hash(),
+ ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
+ GasUsed: 111111,
+ DepositNonce: &depositNonce,
+ DepositReceiptVersion: nil,
}
- receipt1.Bloom = types.CreateBloom(types.Receipts{receipt1})
+ depositReceipt.Bloom = types.CreateBloom(types.Receipts{&depositReceipt})
- receipt2 := &types.Receipt{
- PostState: common.Hash{2}.Bytes(),
+ receiptVersion := types.CanyonDepositReceiptVersion
+ versionedDepositReceipt := types.Receipt{
+ Status: types.ReceiptStatusFailed,
CumulativeGasUsed: 2,
Logs: []*types.Log{
{Address: common.BytesToAddress([]byte{0x22})},
- {Address: common.BytesToAddress([]byte{0x02, 0x22})},
+ {Address: common.BytesToAddress([]byte{0x01, 0x11})},
+ },
+ TxHash: tx2.Hash(),
+ ContractAddress: common.BytesToAddress([]byte{0x02, 0x22, 0x22}),
+ GasUsed: 222222,
+ DepositNonce: &depositNonce,
+ DepositReceiptVersion: &receiptVersion,
+ }
+ versionedDepositReceipt.Bloom = types.CreateBloom(types.Receipts{&versionedDepositReceipt})
+
+ receipt := types.Receipt{
+ PostState: common.Hash{3}.Bytes(),
+ CumulativeGasUsed: 3,
+ Logs: []*types.Log{
+ {Address: common.BytesToAddress([]byte{0x33})},
+ {Address: common.BytesToAddress([]byte{0x03, 0x33})},
},
- TxHash: tx2.Hash(),
- ContractAddress: common.BytesToAddress([]byte{0x02, 0x22, 0x22}),
- GasUsed: 222222,
+ TxHash: tx3.Hash(),
+ ContractAddress: common.BytesToAddress([]byte{0x03, 0x33, 0x33}),
+ GasUsed: 333333,
}
- receipt2.Bloom = types.CreateBloom(types.Receipts{receipt2})
- receipts := []*types.Receipt{receipt1, receipt2}
+ receipt.Bloom = types.CreateBloom(types.Receipts{&receipt})
+ receipts := []*types.Receipt{&receipt, &depositReceipt, &versionedDepositReceipt}
hash := common.BytesToHash([]byte{0x03, 0x14})
// Check that no receipt entries are in a pristine database
@@ -740,14 +768,13 @@ logs := ReadLogs(db, hash, 0)
if len(logs) == 0 {
t.Fatalf("no logs returned")
}
- if have, want := len(logs), 2; have != want {
+ if have, want := len(logs), 3; have != want {
t.Fatalf("unexpected number of logs returned, have %d want %d", have, want)
}
- if have, want := len(logs[0]), 2; have != want {
- t.Fatalf("unexpected number of logs[0] returned, have %d want %d", have, want)
- }
- if have, want := len(logs[1]), 2; have != want {
- t.Fatalf("unexpected number of logs[1] returned, have %d want %d", have, want)
+ for i := range logs {
+ if have, want := len(logs[i]), 2; have != want {
+ t.Fatalf("unexpected number of logs[%d] returned, have %d want %d", i, have, want)
+ }
}
for i, pr := range receipts {
@@ -765,6 +792,36 @@ t.Fatalf("receipt #%d: receipt mismatch: have %s, want %s", i, hex.EncodeToString(rlpHave), hex.EncodeToString(rlpWant))
}
}
}
+}
+
+func TestParseLegacyReceiptRLP(t *testing.T) {
+ // Create a gasUsed value greater than a uint64 can represent
+ gasUsed := big.NewInt(0)
+ gasUsed = gasUsed.SetUint64(math.MaxUint64)
+ gasUsed = gasUsed.Add(gasUsed, big.NewInt(math.MaxInt64))
+ sanityCheck := (&big.Int{}).SetUint64(gasUsed.Uint64())
+ require.NotEqual(t, gasUsed, sanityCheck)
+ receipt := types.LegacyOptimismStoredReceiptRLP{
+ CumulativeGasUsed: 1,
+ Logs: []*types.LogForStorage{
+ {Address: common.BytesToAddress([]byte{0x11})},
+ {Address: common.BytesToAddress([]byte{0x01, 0x11})},
+ },
+ L1GasUsed: gasUsed,
+ L1GasPrice: gasUsed,
+ L1Fee: gasUsed,
+ FeeScalar: "6",
+ }
+
+ data, err := rlp.EncodeToBytes(receipt)
+ require.NoError(t, err)
+ var result storedReceiptRLP
+ err = rlp.DecodeBytes(data, &result)
+ require.NoError(t, err)
+ require.Equal(t, receipt.L1GasUsed, result.L1GasUsed)
+ require.Equal(t, receipt.L1GasPrice, result.L1GasPrice)
+ require.Equal(t, receipt.L1Fee, result.L1Fee)
+ require.Equal(t, receipt.FeeScalar, result.FeeScalar)
}
func TestDeriveLogFields(t *testing.T) {
diff --git go-ethereum/core/state_processor_test.go op-geth/core/state_processor_test.go
index 5ff9353bd9a4640e5911797b958d59ed50bd7d01..5bfb5947a7d409b9cd6cd7a0ef296a91bc791499 100644
--- go-ethereum/core/state_processor_test.go
+++ op-geth/core/state_processor_test.go
@@ -379,7 +379,7 @@ Time: parent.Time() + 10,
UncleHash: types.EmptyUncleHash,
}
if config.IsLondon(header.Number) {
- header.BaseFee = eip1559.CalcBaseFee(config, parent.Header())
+ header.BaseFee = eip1559.CalcBaseFee(config, parent.Header(), header.Time)
}
if config.IsShanghai(header.Number, header.Time) {
header.WithdrawalsHash = &types.EmptyWithdrawalsHash
diff --git go-ethereum/core/superchain_test.go op-geth/core/superchain_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..9959374bddc1e87dd95e5995811054c581068d71
--- /dev/null
+++ op-geth/core/superchain_test.go
@@ -0,0 +1,54 @@
+package core
+
+import (
+ "testing"
+
+ "github.com/ethereum-optimism/superchain-registry/superchain"
+
+ "github.com/ethereum/go-ethereum/core/rawdb"
+ "github.com/ethereum/go-ethereum/trie"
+)
+
+func TestOPStackGenesis(t *testing.T) {
+ for id := range superchain.OPChains {
+ gen, err := LoadOPStackGenesis(id)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Logf("chain: %d, genesis block hash: %s", id, gen.ToBlock().Hash())
+ }
+}
+
+func TestRegistryChainConfigOverride(t *testing.T) {
+ db := rawdb.NewMemoryDatabase()
+ genesis, err := LoadOPStackGenesis(10)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if genesis.Config.RegolithTime == nil {
+ t.Fatal("expected non-nil regolith time")
+ }
+ expectedRegolithTime := *genesis.Config.RegolithTime
+ genesis.Config.RegolithTime = nil
+
+ // initialize the DB
+ tdb := trie.NewDatabase(db, newDbConfig(rawdb.PathScheme))
+ genesis.MustCommit(db, tdb)
+ bl := genesis.ToBlock()
+ rawdb.WriteCanonicalHash(db, bl.Hash(), 0)
+ rawdb.WriteBlock(db, bl)
+
+ // create chain config, even with incomplete genesis input: the chain config should be corrected
+ chainConfig, _, err := SetupGenesisBlockWithOverride(db, tdb, genesis, &ChainOverrides{
+ ApplySuperchainUpgrades: true,
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ // check if we have a corrected chain config
+ if chainConfig.RegolithTime == nil {
+ t.Fatal("expected regolith time to be corrected, but time is still nil")
+ } else if *chainConfig.RegolithTime != expectedRegolithTime {
+ t.Fatalf("expected regolith time to be %d, but got %d", expectedRegolithTime, *chainConfig.RegolithTime)
+ }
+}
diff --git go-ethereum/core/txpool/blobpool/blobpool.go op-geth/core/txpool/blobpool/blobpool.go
index 32c6c0e8feeff9db0bf2ebaedb9869decc82b336..3b6292d6423ee550657a479176ea85403add7341 100644
--- go-ethereum/core/txpool/blobpool/blobpool.go
+++ op-geth/core/txpool/blobpool/blobpool.go
@@ -399,7 +399,7 @@ for addr := range p.index {
p.recheck(addr, nil)
}
var (
- basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), p.head))
+ basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), p.head, p.head.Time+1))
blobfee = uint256.MustFromBig(big.NewInt(params.BlobTxMinBlobGasprice))
)
if p.head.ExcessBlobGas != nil {
@@ -782,7 +782,7 @@ p.limbo.finalize(p.chain.CurrentFinalBlock())
}
// Reset the price heap for the new set of basefee/blobfee pairs
var (
- basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), newHead))
+ basefee = uint256.MustFromBig(eip1559.CalcBaseFee(p.chain.Config(), newHead, newHead.Time+1))
blobfee = uint256.MustFromBig(big.NewInt(params.BlobTxMinBlobGasprice))
)
if newHead.ExcessBlobGas != nil {
diff --git go-ethereum/core/txpool/blobpool/blobpool_test.go op-geth/core/txpool/blobpool/blobpool_test.go
index 8914301e14c32648498077d51ee1d3ddc5484734..6011f33bfa42117a1d7446cd0145f2b7e7ecf2ae 100644
--- go-ethereum/core/txpool/blobpool/blobpool_test.go
+++ op-geth/core/txpool/blobpool/blobpool_test.go
@@ -114,7 +114,7 @@ Number: blockNumber,
GasLimit: gasLimit,
GasUsed: 0,
BaseFee: mid,
- }).Cmp(bc.basefee.ToBig()) > 0 {
+ }, blockTime).Cmp(bc.basefee.ToBig()) > 0 {
hi = mid
} else {
lo = mid
diff --git go-ethereum/core/types/receipt_test.go op-geth/core/types/receipt_test.go
index a7b26444712fe8c669ea732fa423588a58497f32..766640129cb4f59229ae5c2ea0f5dde1301bdc01 100644
--- go-ethereum/core/types/receipt_test.go
+++ op-geth/core/types/receipt_test.go
@@ -19,6 +19,7 @@
import (
"bytes"
"encoding/json"
+ "fmt"
"math"
"math/big"
"reflect"
@@ -29,6 +30,7 @@ "github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rlp"
"github.com/holiman/uint256"
"github.com/kylelemons/godebug/diff"
+ "github.com/stretchr/testify/require"
)
var (
@@ -82,6 +84,63 @@ },
},
Type: DynamicFeeTxType,
}
+ depositReceiptNoNonce = &Receipt{
+ Status: ReceiptStatusFailed,
+ CumulativeGasUsed: 1,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x11}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ Data: []byte{0x01, 0x00, 0xff},
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x01, 0x11}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ Data: []byte{0x01, 0x00, 0xff},
+ },
+ },
+ Type: DepositTxType,
+ }
+ nonce = uint64(1234)
+ depositReceiptWithNonce = &Receipt{
+ Status: ReceiptStatusFailed,
+ CumulativeGasUsed: 1,
+ DepositNonce: &nonce,
+ DepositReceiptVersion: nil,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x11}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ Data: []byte{0x01, 0x00, 0xff},
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x01, 0x11}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ Data: []byte{0x01, 0x00, 0xff},
+ },
+ },
+ Type: DepositTxType,
+ }
+ version = CanyonDepositReceiptVersion
+ depositReceiptWithNonceAndVersion = &Receipt{
+ Status: ReceiptStatusFailed,
+ CumulativeGasUsed: 1,
+ DepositNonce: &nonce,
+ DepositReceiptVersion: &version,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x11}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ Data: []byte{0x01, 0x00, 0xff},
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x01, 0x11}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ Data: []byte{0x01, 0x00, 0xff},
+ },
+ },
+ Type: DepositTxType,
+ }
// Create a few transactions to have receipts for
to2 = common.HexToAddress("0x2")
@@ -149,11 +208,23 @@ GasFeeCap: uint256.NewInt(1077),
BlobFeeCap: uint256.NewInt(100077),
BlobHashes: []common.Hash{{}, {}, {}},
}),
+ NewTx(&DepositTx{
+ To: nil, // contract creation
+ Value: big.NewInt(6),
+ Gas: 50,
+ }),
+ NewTx(&DepositTx{
+ To: nil, // contract creation
+ Value: big.NewInt(6),
+ Gas: 60,
+ }),
}
-
- blockNumber = big.NewInt(1)
- blockTime = uint64(2)
- blockHash = common.BytesToHash([]byte{0x03, 0x14})
+ depNonce1 = uint64(7)
+ depNonce2 = uint64(8)
+ blockNumber = big.NewInt(1)
+ blockTime = uint64(2)
+ blockHash = common.BytesToHash([]byte{0x03, 0x14})
+ canyonDepositReceiptVersion = CanyonDepositReceiptVersion
// Create the corresponding receipts
receipts = Receipts{
@@ -293,6 +364,78 @@ BlockHash: blockHash,
BlockNumber: blockNumber,
TransactionIndex: 6,
},
+ &Receipt{
+ Type: DepositTxType,
+ PostState: common.Hash{5}.Bytes(),
+ CumulativeGasUsed: 50 + 28,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x33}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[7].Hash(),
+ TxIndex: 7,
+ BlockHash: blockHash,
+ Index: 4,
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x03, 0x33}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[7].Hash(),
+ TxIndex: 7,
+ BlockHash: blockHash,
+ Index: 5,
+ },
+ },
+ TxHash: txs[7].Hash(),
+ ContractAddress: common.HexToAddress("0x3bb898b4bbe24f68a4e9be46cfe72d1787fd74f4"),
+ GasUsed: 50,
+ EffectiveGasPrice: big.NewInt(0),
+ BlockHash: blockHash,
+ BlockNumber: blockNumber,
+ TransactionIndex: 7,
+ DepositNonce: &depNonce1,
+ DepositReceiptVersion: nil,
+ },
+ &Receipt{
+ Type: DepositTxType,
+ PostState: common.Hash{5}.Bytes(),
+ CumulativeGasUsed: 60 + 50 + 28,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x33}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[8].Hash(),
+ TxIndex: 8,
+ BlockHash: blockHash,
+ Index: 6,
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x03, 0x33}),
+ Topics: []common.Hash{common.HexToHash("dead"), common.HexToHash("beef")},
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[8].Hash(),
+ TxIndex: 8,
+ BlockHash: blockHash,
+ Index: 7,
+ },
+ },
+ TxHash: txs[8].Hash(),
+ ContractAddress: common.HexToAddress("0x117814af22cb83d8ad6e8489e9477d28265bc105"),
+ GasUsed: 60,
+ EffectiveGasPrice: big.NewInt(0),
+ BlockHash: blockHash,
+ BlockNumber: blockNumber,
+ TransactionIndex: 8,
+ DepositNonce: &depNonce2,
+ DepositReceiptVersion: &canyonDepositReceiptVersion,
+ },
}
)
@@ -344,6 +487,18 @@ r := Receipt{}
err = r.UnmarshalJSON(b)
if err != nil {
t.Fatal("error unmarshaling receipt from json:", err)
+ }
+
+ // Make sure marshal/unmarshal doesn't affect receipt hash root computation by comparing
+ // the output of EncodeIndex
+ rsBefore := Receipts([]*Receipt{receipts[i]})
+ rsAfter := Receipts([]*Receipt{&r})
+
+ encBefore, encAfter := bytes.Buffer{}, bytes.Buffer{}
+ rsBefore.EncodeIndex(0, &encBefore)
+ rsAfter.EncodeIndex(0, &encAfter)
+ if !bytes.Equal(encBefore.Bytes(), encAfter.Bytes()) {
+ t.Errorf("%v: EncodeIndex differs after JSON marshal/unmarshal", i)
}
}
}
@@ -527,3 +682,257 @@ l[i] = &cpy
}
return l
}
+
+func TestDeriveOptimismTxReceipt(t *testing.T) {
+ to4 := common.HexToAddress("0x4")
+ // Create a few transactions to have receipts for
+ txs := Transactions{
+ NewTx(&DepositTx{
+ To: nil, // contract creation
+ Value: big.NewInt(6),
+ Gas: 50,
+ // System config with L1Scalar=2_000_000 (becomes 2 after division), L1Overhead=2500, L1BaseFee=5000
+ Data: common.Hex2Bytes("015d8eb900000000000000000000000000000000000000000000000026b39534042076f70000000000000000000000000000000000000000000000007e33b7c4995967580000000000000000000000000000000000000000000000000000000000001388547dea8ff339566349ed0ef6384876655d1b9b955e36ac165c6b8ab69b9af5cd0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123400000000000000000000000000000000000000000000000000000000000009c400000000000000000000000000000000000000000000000000000000001e8480"),
+ }),
+ NewTx(&DynamicFeeTx{
+ To: &to4,
+ Nonce: 4,
+ Value: big.NewInt(4),
+ Gas: 4,
+ GasTipCap: big.NewInt(44),
+ GasFeeCap: big.NewInt(1045),
+ Data: []byte{0, 1, 255, 0},
+ }),
+ }
+ depNonce := uint64(7)
+ blockNumber := big.NewInt(1)
+ blockHash := common.BytesToHash([]byte{0x03, 0x14})
+
+ // Create the corresponding receipts
+ receipts := Receipts{
+ &Receipt{
+ Type: DepositTxType,
+ PostState: common.Hash{5}.Bytes(),
+ CumulativeGasUsed: 50 + 15,
+ Logs: []*Log{
+ {
+ Address: common.BytesToAddress([]byte{0x33}),
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[0].Hash(),
+ TxIndex: 0,
+ BlockHash: blockHash,
+ Index: 0,
+ },
+ {
+ Address: common.BytesToAddress([]byte{0x03, 0x33}),
+ // derived fields:
+ BlockNumber: blockNumber.Uint64(),
+ TxHash: txs[0].Hash(),
+ TxIndex: 0,
+ BlockHash: blockHash,
+ Index: 1,
+ },
+ },
+ TxHash: txs[0].Hash(),
+ ContractAddress: common.HexToAddress("0x3bb898b4bbe24f68a4e9be46cfe72d1787fd74f4"),
+ GasUsed: 65,
+ EffectiveGasPrice: big.NewInt(0),
+ BlockHash: blockHash,
+ BlockNumber: blockNumber,
+ TransactionIndex: 0,
+ DepositNonce: &depNonce,
+ },
+ &Receipt{
+ Type: DynamicFeeTxType,
+ PostState: common.Hash{4}.Bytes(),
+ CumulativeGasUsed: 10,
+ Logs: []*Log{},
+ // derived fields:
+ TxHash: txs[1].Hash(),
+ GasUsed: 18446744073709551561,
+ EffectiveGasPrice: big.NewInt(1044),
+ BlockHash: blockHash,
+ BlockNumber: blockNumber,
+ TransactionIndex: 1,
+ L1GasPrice: big.NewInt(5000),
+ L1GasUsed: big.NewInt(3976),
+ L1Fee: big.NewInt(39760000),
+ FeeScalar: big.NewFloat(2),
+ },
+ }
+
+ // Re-derive receipts.
+ basefee := big.NewInt(1000)
+ derivedReceipts := clearComputedFieldsOnReceipts(receipts)
+ err := Receipts(derivedReceipts).DeriveFields(params.OptimismTestConfig, blockHash, blockNumber.Uint64(), 0, basefee, nil, txs)
+ if err != nil {
+ t.Fatalf("DeriveFields(...) = %v, want <nil>", err)
+ }
+
+ // Check diff of receipts against derivedReceipts.
+ r1, err := json.MarshalIndent(receipts, "", " ")
+ if err != nil {
+ t.Fatal("error marshaling input receipts:", err)
+ }
+ r2, err := json.MarshalIndent(derivedReceipts, "", " ")
+ if err != nil {
+ t.Fatal("error marshaling derived receipts:", err)
+ }
+ d := diff.Diff(string(r1), string(r2))
+ if d != "" {
+ t.Fatal("receipts differ:", d)
+ }
+
+ // Check that we preserved the invariant: l1Fee = l1GasPrice * l1GasUsed * l1FeeScalar
+ // but with more difficult int math...
+ l2Rcpt := derivedReceipts[1]
+ l1GasCost := new(big.Int).Mul(l2Rcpt.L1GasPrice, l2Rcpt.L1GasUsed)
+ l1Fee := new(big.Float).Mul(new(big.Float).SetInt(l1GasCost), l2Rcpt.FeeScalar)
+ require.Equal(t, new(big.Float).SetInt(l2Rcpt.L1Fee), l1Fee)
+}
+
+func TestBedrockDepositReceiptUnchanged(t *testing.T) {
+ expectedRlp := common.FromHex("7EF90156A003000000000000000000000000000000000000000000000000000000000000000AB9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F0D7940000000000000000000000000000000000000033C001D7940000000000000000000000000000000000000333C002")
+ // Deposit receipt with no nonce
+ receipt := &Receipt{
+ Type: DepositTxType,
+ PostState: common.Hash{3}.Bytes(),
+ CumulativeGasUsed: 10,
+ Logs: []*Log{
+ {Address: common.BytesToAddress([]byte{0x33}), Data: []byte{1}, Topics: []common.Hash{}},
+ {Address: common.BytesToAddress([]byte{0x03, 0x33}), Data: []byte{2}, Topics: []common.Hash{}},
+ },
+ TxHash: common.Hash{},
+ ContractAddress: common.BytesToAddress([]byte{0x03, 0x33, 0x33}),
+ GasUsed: 4,
+ }
+
+ rlp, err := receipt.MarshalBinary()
+ require.NoError(t, err)
+ require.Equal(t, expectedRlp, rlp)
+
+ // Consensus values should be unchanged after reparsing
+ parsed := new(Receipt)
+ err = parsed.UnmarshalBinary(rlp)
+ require.NoError(t, err)
+ require.Equal(t, receipt.Status, parsed.Status)
+ require.Equal(t, receipt.CumulativeGasUsed, parsed.CumulativeGasUsed)
+ require.Equal(t, receipt.Bloom, parsed.Bloom)
+ require.EqualValues(t, receipt.Logs, parsed.Logs)
+ // And still shouldn't have a nonce
+ require.Nil(t, parsed.DepositNonce)
+ // ..or a deposit nonce
+ require.Nil(t, parsed.DepositReceiptVersion)
+}
+
+// Regolith introduced an inconsistency in behavior between EncodeIndex and MarshalBinary for a
+// deposit transaction receipt. TestReceiptEncodeIndexBugIsEnshrined makes sure this difference is
+// preserved for backwards compatibility purposes, but also that there is no discrepancy for the
+// post-Canyon encoding.
+func TestReceiptEncodeIndexBugIsEnshrined(t *testing.T) {
+ // Check that a post-Regolith, pre-Canyon receipt produces the expected difference between
+ // EncodeIndex and MarshalBinary.
+ buf := new(bytes.Buffer)
+ receipts := Receipts{depositReceiptWithNonce}
+ receipts.EncodeIndex(0, buf)
+ indexBytes := buf.Bytes()
+
+ regularBytes, _ := receipts[0].MarshalBinary()
+
+ require.NotEqual(t, indexBytes, regularBytes)
+
+ // Confirm the buggy encoding is as expected, which means it should encode as if it had no
+ // nonce specified (like that of a non-deposit receipt, whose encoding would differ only in the
+ // type byte).
+ buf.Reset()
+ tempReceipt := *depositReceiptWithNonce
+ tempReceipt.Type = eip1559Receipt.Type
+ buggyBytes, _ := tempReceipt.MarshalBinary()
+
+ require.Equal(t, indexBytes[1:], buggyBytes[1:])
+
+ // check that the post-Canyon encoding has no differences between EncodeIndex and
+ // MarshalBinary.
+ buf.Reset()
+ receipts = Receipts{depositReceiptWithNonceAndVersion}
+ receipts.EncodeIndex(0, buf)
+ indexBytes = buf.Bytes()
+
+ regularBytes, _ = receipts[0].MarshalBinary()
+
+ require.Equal(t, indexBytes, regularBytes)
+
+ // Check that bumping the nonce post-canyon changes the hash
+ bumpedReceipt := *depositReceiptWithNonceAndVersion
+ bumpedNonce := nonce + 1
+ bumpedReceipt.DepositNonce = &bumpedNonce
+ bumpedBytes, _ := bumpedReceipt.MarshalBinary()
+ require.NotEqual(t, regularBytes, bumpedBytes)
+}
+
+func TestRoundTripReceipt(t *testing.T) {
+ tests := []struct {
+ name string
+ rcpt *Receipt
+ }{
+ {name: "Legacy", rcpt: legacyReceipt},
+ {name: "AccessList", rcpt: accessListReceipt},
+ {name: "EIP1559", rcpt: eip1559Receipt},
+ {name: "DepositNoNonce", rcpt: depositReceiptNoNonce},
+ {name: "DepositWithNonce", rcpt: depositReceiptWithNonce},
+ {name: "DepositWithNonceAndVersion", rcpt: depositReceiptWithNonceAndVersion},
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ data, err := test.rcpt.MarshalBinary()
+ require.NoError(t, err)
+
+ d := &Receipt{}
+ err = d.UnmarshalBinary(data)
+ require.NoError(t, err)
+ require.Equal(t, test.rcpt, d)
+ require.Equal(t, test.rcpt.DepositNonce, d.DepositNonce)
+ require.Equal(t, test.rcpt.DepositReceiptVersion, d.DepositReceiptVersion)
+ })
+
+ t.Run(fmt.Sprintf("%sRejectExtraData", test.name), func(t *testing.T) {
+ data, err := test.rcpt.MarshalBinary()
+ require.NoError(t, err)
+ data = append(data, 1, 2, 3, 4)
+ d := &Receipt{}
+ err = d.UnmarshalBinary(data)
+ require.Error(t, err)
+ })
+ }
+}
+
+func TestRoundTripReceiptForStorage(t *testing.T) {
+ tests := []struct {
+ name string
+ rcpt *Receipt
+ }{
+ {name: "Legacy", rcpt: legacyReceipt},
+ {name: "AccessList", rcpt: accessListReceipt},
+ {name: "EIP1559", rcpt: eip1559Receipt},
+ {name: "DepositNoNonce", rcpt: depositReceiptNoNonce},
+ {name: "DepositWithNonce", rcpt: depositReceiptWithNonce},
+ {name: "DepositWithNonceAndVersion", rcpt: depositReceiptWithNonceAndVersion},
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ data, err := rlp.EncodeToBytes((*ReceiptForStorage)(test.rcpt))
+ require.NoError(t, err)
+
+ d := &ReceiptForStorage{}
+ err = rlp.DecodeBytes(data, d)
+ require.NoError(t, err)
+ // Only check the stored fields - the others are derived later
+ require.Equal(t, test.rcpt.Status, d.Status)
+ require.Equal(t, test.rcpt.CumulativeGasUsed, d.CumulativeGasUsed)
+ require.Equal(t, test.rcpt.Logs, d.Logs)
+ require.Equal(t, test.rcpt.DepositNonce, d.DepositNonce)
+ require.Equal(t, test.rcpt.DepositReceiptVersion, d.DepositReceiptVersion)
+ })
+ }
+}
diff --git go-ethereum/core/types/rollup_l1_cost_test.go op-geth/core/types/rollup_l1_cost_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..e43ea967ee87a257cfc2afa58396c2eb6685ed76
--- /dev/null
+++ op-geth/core/types/rollup_l1_cost_test.go
@@ -0,0 +1,30 @@
+package types
+
+import (
+ "math/rand"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/params"
+ "github.com/stretchr/testify/require"
+)
+
+func TestRollupGasData(t *testing.T) {
+ for i := 0; i < 100; i++ {
+ zeroes := rand.Uint64()
+ ones := rand.Uint64()
+
+ r := RollupGasData{
+ Zeroes: zeroes,
+ Ones: ones,
+ }
+ time := uint64(1)
+ cfg := ¶ms.ChainConfig{
+ RegolithTime: &time,
+ }
+ gasPreRegolith := r.DataGas(0, cfg)
+ gasPostRegolith := r.DataGas(1, cfg)
+
+ require.Equal(t, r.Zeroes*params.TxDataZeroGas+(r.Ones+68)*params.TxDataNonZeroGasEIP2028, gasPreRegolith)
+ require.Equal(t, r.Zeroes*params.TxDataZeroGas+r.Ones*params.TxDataNonZeroGasEIP2028, gasPostRegolith)
+ }
+}
diff --git go-ethereum/core/types/transaction_marshalling_test.go op-geth/core/types/transaction_marshalling_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..4ab93a539d19bbcffa0293738b2e4dcc3ebe7ad2
--- /dev/null
+++ op-geth/core/types/transaction_marshalling_test.go
@@ -0,0 +1,103 @@
+package types
+
+import (
+ "encoding/json"
+ "math/big"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/stretchr/testify/require"
+)
+
+func TestTransactionUnmarshalJsonDeposit(t *testing.T) {
+ tx := NewTx(&DepositTx{
+ SourceHash: common.HexToHash("0x1234"),
+ IsSystemTransaction: true,
+ Mint: big.NewInt(34),
+ })
+ json, err := tx.MarshalJSON()
+ require.NoError(t, err, "Failed to marshal tx JSON")
+
+ got := &Transaction{}
+ err = got.UnmarshalJSON(json)
+ require.NoError(t, err, "Failed to unmarshal tx JSON")
+ require.Equal(t, tx.Hash(), got.Hash())
+}
+
+func TestTransactionUnmarshalJSON(t *testing.T) {
+ tests := []struct {
+ name string
+ json string
+ expectedError string
+ }{
+ {
+ name: "No gas",
+ json: `{"type":"0x7e","nonce":null,"gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","from":"0x0000000000000000000000000000000000000001","isSystemTx":false,"hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ expectedError: "missing required field 'gas'",
+ },
+ {
+ name: "No value",
+ json: `{"type":"0x7e","nonce":null,"gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","from":"0x0000000000000000000000000000000000000001","isSystemTx":false,"hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ expectedError: "missing required field 'value'",
+ },
+ {
+ name: "No input",
+ json: `{"type":"0x7e","nonce":null,"gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","from":"0x0000000000000000000000000000000000000001","isSystemTx":false,"hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ expectedError: "missing required field 'input'",
+ },
+ {
+ name: "No from",
+ json: `{"type":"0x7e","nonce":null,"gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","isSystemTx":false,"hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ expectedError: "missing required field 'from'",
+ },
+ {
+ name: "No sourceHash",
+ json: `{"type":"0x7e","nonce":null,"gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"from":"0x0000000000000000000000000000000000000001","isSystemTx":false,"hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ expectedError: "missing required field 'sourceHash'",
+ },
+ {
+ name: "No mint",
+ json: `{"type":"0x7e","nonce":null,"gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","from":"0x0000000000000000000000000000000000000001","isSystemTx":false,"hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ // Allowed
+ },
+ {
+ name: "No IsSystemTx",
+ json: `{"type":"0x7e","nonce":null,"gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","from":"0x0000000000000000000000000000000000000001","hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ // Allowed
+ },
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ var parsedTx = &Transaction{}
+ err := json.Unmarshal([]byte(test.json), &parsedTx)
+ if test.expectedError == "" {
+ require.NoError(t, err)
+ } else {
+ require.ErrorContains(t, err, test.expectedError)
+ }
+ })
+ }
+
+ tests = []struct {
+ name string
+ json string
+ expectedError string
+ }{
+ {
+ name: "Valid deposit sender",
+ json: `{"type":"0x7e","nonce":"0x1","gas": "0x1234", "gasPrice":null,"maxPriorityFeePerGas":null,"maxFeePerGas":null,"value":"0x1","input":"0x616263646566","v":null,"r":null,"s":null,"to":null,"sourceHash":"0x0000000000000000000000000000000000000000000000000000000000000000","from":"0x0000000000000000000000000000000000000001","hash":"0xa4341f3db4363b7ca269a8538bd027b2f8784f84454ca917668642d5f6dffdf9"}`,
+ },
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ var parsedTx = &Transaction{}
+ err := json.Unmarshal([]byte(test.json), &parsedTx)
+ require.NoError(t, err)
+
+ signer := NewLondonSigner(big.NewInt(123))
+ sender, err := signer.Sender(parsedTx)
+ require.NoError(t, err)
+ require.Equal(t, common.HexToAddress("0x1"), sender)
+ })
+ }
+}
diff --git go-ethereum/eth/catalyst/api_test.go op-geth/eth/catalyst/api_test.go
index 59f44fafea4e0273b5db5b81b1609526e77c9d05..116bca1af9e14a40ab0031fd1b88161e8316360e 100644
--- go-ethereum/eth/catalyst/api_test.go
+++ op-geth/eth/catalyst/api_test.go
@@ -437,6 +437,11 @@ }
// startEthService creates a full node instance for testing.
func startEthService(t *testing.T, genesis *core.Genesis, blocks []*types.Block) (*node.Node, *eth.Ethereum) {
+ ethcfg := ðconfig.Config{Genesis: genesis, SyncMode: downloader.FullSync, TrieTimeout: time.Minute, TrieDirtyCache: 256, TrieCleanCache: 256}
+ return startEthServiceWithConfigFn(t, blocks, ethcfg)
+}
+
+func startEthServiceWithConfigFn(t *testing.T, blocks []*types.Block, ethcfg *ethconfig.Config) (*node.Node, *eth.Ethereum) {
t.Helper()
n, err := node.New(&node.Config{
@@ -449,7 +454,7 @@ if err != nil {
t.Fatal("can't create node:", err)
}
- ethcfg := ðconfig.Config{Genesis: genesis, SyncMode: downloader.FullSync, TrieTimeout: time.Minute, TrieDirtyCache: 256, TrieCleanCache: 256}
+ // default eth config is moved to startEthService
ethservice, err := eth.New(n, ethcfg)
if err != nil {
t.Fatal("can't create eth service:", err)
diff --git go-ethereum/eth/catalyst/superchain_test.go op-geth/eth/catalyst/superchain_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..4fd46a4c1257c38998878071ef618a71849e6d6e
--- /dev/null
+++ op-geth/eth/catalyst/superchain_test.go
@@ -0,0 +1,120 @@
+package catalyst
+
+import (
+ "testing"
+ "time"
+
+ "github.com/ethereum/go-ethereum/eth/downloader"
+ "github.com/ethereum/go-ethereum/eth/ethconfig"
+ "github.com/ethereum/go-ethereum/node"
+ "github.com/ethereum/go-ethereum/params"
+)
+
+func TestSignalSuperchainV1(t *testing.T) {
+ genesis, preMergeBlocks := generateMergeChain(2, false)
+ n, ethservice := startEthService(t, genesis, preMergeBlocks)
+ defer n.Close()
+ api := NewConsensusAPI(ethservice)
+ t.Run("matching", func(t *testing.T) {
+ out, err := api.SignalSuperchainV1(&SuperchainSignal{
+ Recommended: params.OPStackSupport,
+ Required: params.OPStackSupport,
+ })
+ if err != nil {
+ t.Fatalf("failed to process signal: %v", err)
+ }
+ if out != params.OPStackSupport {
+ t.Fatalf("expected %s but got %s", params.OPStackSupport, out)
+ }
+ })
+ t.Run("null_arg", func(t *testing.T) {
+ out, err := api.SignalSuperchainV1(nil)
+ if err != nil {
+ t.Fatalf("failed to process signal: %v", err)
+ }
+ if out != params.OPStackSupport {
+ t.Fatalf("expected %s but got %s", params.OPStackSupport, out)
+ }
+ })
+}
+
+func TestSignalSuperchainV1Halt(t *testing.T) {
+ // Note: depending on the params.OPStackSupport some types of bumps are not possible with active prerelease
+ testCases := []struct {
+ cfg string
+ bump string
+ halt bool
+ }{
+ {"none", "major", false},
+ {"major", "major", true},
+ {"minor", "major", true},
+ {"patch", "major", true},
+ {"major", "minor", false},
+ {"minor", "minor", true},
+ {"patch", "minor", true},
+ {"major", "patch", false},
+ {"minor", "patch", false},
+ {"patch", "patch", true},
+ }
+ for _, tc := range testCases {
+ tc := tc
+ t.Run(tc.cfg+"_"+tc.bump, func(t *testing.T) {
+ genesis, preMergeBlocks := generateMergeChain(2, false)
+ ethcfg := ðconfig.Config{Genesis: genesis, SyncMode: downloader.FullSync, TrieTimeout: time.Minute, TrieDirtyCache: 256, TrieCleanCache: 256}
+ ethcfg.RollupHaltOnIncompatibleProtocolVersion = tc.cfg // opt-in to halting (or not)
+ n, ethservice := startEthServiceWithConfigFn(t, preMergeBlocks, ethcfg)
+ defer n.Close() // close at the end, regardless of any prior (failed) closing
+ api := NewConsensusAPI(ethservice)
+ _, build, major, minor, patch, preRelease := params.OPStackSupport.Parse()
+ if preRelease != 0 { // transform back from prerelease, so we can do a clean version bump
+ if patch != 0 {
+ patch -= 1
+ } else if minor != 0 {
+ // can't patch-bump e.g. v3.1.0-1, the prerelease forces a minor bump:
+ // v3.0.999 is lower than the prerelease, v3.1.1-1 is a prerelease of v3.1.1.
+ if tc.bump == "patch" {
+ t.Skip()
+ }
+ minor -= 1
+ } else if major != 0 {
+ if tc.bump == "minor" || tc.bump == "patch" { // can't minor-bump or patch-bump
+ t.Skip()
+ }
+ major -= 1
+ }
+ preRelease = 0
+ }
+ majorSignal, minorSignal, patchSignal := major, minor, patch
+ switch tc.bump {
+ case "major":
+ majorSignal += 1
+ case "minor":
+ minorSignal += 1
+ case "patch":
+ patchSignal += 1
+ }
+ out, err := api.SignalSuperchainV1(&SuperchainSignal{
+ Recommended: params.OPStackSupport, // required version change should be enough
+ Required: params.ProtocolVersionV0{Build: build, Major: majorSignal, Minor: minorSignal, Patch: patchSignal, PreRelease: preRelease}.Encode(),
+ })
+ if err != nil {
+ t.Fatalf("failed to process signal: %v", err)
+ }
+ if out != params.OPStackSupport {
+ t.Fatalf("expected %s but got %s", params.OPStackSupport, out)
+ }
+ closeErr := n.Close()
+ if !tc.halt {
+ // assert no halt by closing, and not getting any error
+ if closeErr != nil {
+ t.Fatalf("expected not to have closed already, but just closed without error")
+ }
+ } else {
+ // assert halt by closing again, and seeing if we are not stopped already
+ if closeErr != node.ErrNodeStopped {
+ t.Fatalf("expected to have already closed and get a ErrNodeStopped error, but got %v", closeErr)
+ }
+ }
+ })
+ }
+}
diff --git go-ethereum/eth/gasprice/feehistory.go op-geth/eth/gasprice/feehistory.go
index 226991b24b2c635f2c7708bbcbb828e05676aacb..13f36499d4222a259aa89eef27fa958026d85ab7 100644
--- go-ethereum/eth/gasprice/feehistory.go
+++ op-geth/eth/gasprice/feehistory.go
@@ -83,7 +83,7 @@ if bf.results.baseFee = bf.header.BaseFee; bf.results.baseFee == nil {
bf.results.baseFee = new(big.Int)
}
if chainconfig.IsLondon(big.NewInt(int64(bf.blockNumber + 1))) {
- bf.results.nextBaseFee = eip1559.CalcBaseFee(chainconfig, bf.header)
+ bf.results.nextBaseFee = eip1559.CalcBaseFee(chainconfig, bf.header, bf.header.Time+1)
} else {
bf.results.nextBaseFee = new(big.Int)
}
diff --git go-ethereum/eth/gasprice/optimism-gasprice_test.go op-geth/eth/gasprice/optimism-gasprice_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..dd0140839d91e45be16d06faae9b714ad53265fa
--- /dev/null
+++ op-geth/eth/gasprice/optimism-gasprice_test.go
@@ -0,0 +1,142 @@
+// 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 gasprice
+
+import (
+ "context"
+ "math/big"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/params"
+ "github.com/ethereum/go-ethereum/rpc"
+ "github.com/ethereum/go-ethereum/trie"
+)
+
+const (
+ blockGasLimit = params.TxGas * 3
+)
+
+type testTxData struct {
+ priorityFee int64
+ gasLimit uint64
+}
+
+type opTestBackend struct {
+ block *types.Block
+ receipts []*types.Receipt
+}
+
+func (b *opTestBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
+ panic("not implemented")
+}
+
+func (b *opTestBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {
+ return b.block, nil
+}
+
+func (b *opTestBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
+ return b.receipts, nil
+}
+
+func (b *opTestBackend) PendingBlockAndReceipts() (*types.Block, types.Receipts) {
+ panic("not implemented")
+}
+
+func (b *opTestBackend) ChainConfig() *params.ChainConfig {
+ return params.OptimismTestConfig
+}
+
+func (b *opTestBackend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription {
+ return nil
+}
+
+func newOpTestBackend(t *testing.T, txs []testTxData) *opTestBackend {
+ var (
+ key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+ signer = types.LatestSigner(params.TestChainConfig)
+ )
+ // only the most recent block is considered for optimism priority fee suggestions, so this is
+ // where we add the test transactions
+ ts := []*types.Transaction{}
+ rs := []*types.Receipt{}
+ header := types.Header{}
+ header.GasLimit = blockGasLimit
+ var nonce uint64
+ for _, tx := range txs {
+ txdata := &types.DynamicFeeTx{
+ ChainID: params.TestChainConfig.ChainID,
+ Nonce: nonce,
+ To: &common.Address{},
+ Gas: params.TxGas,
+ GasFeeCap: big.NewInt(100 * params.GWei),
+ GasTipCap: big.NewInt(tx.priorityFee),
+ Data: []byte{},
+ }
+ t := types.MustSignNewTx(key, signer, txdata)
+ ts = append(ts, t)
+ r := types.Receipt{}
+ r.GasUsed = tx.gasLimit
+ header.GasUsed += r.GasUsed
+ rs = append(rs, &r)
+ nonce++
+ }
+ hasher := trie.NewStackTrie(nil)
+ b := types.NewBlock(&header, ts, nil, nil, hasher)
+ return &opTestBackend{block: b, receipts: rs}
+}
+
+func TestSuggestOptimismPriorityFee(t *testing.T) {
+ minSuggestion := new(big.Int).SetUint64(1e8 * params.Wei)
+ var cases = []struct {
+ txdata []testTxData
+ want *big.Int
+ }{
+ {
+ // block well under capacity, expect min priority fee suggestion
+ txdata: []testTxData{testTxData{params.GWei, 21000}},
+ want: minSuggestion,
+ },
+ {
+ // 2 txs, still under capacity, expect min priority fee suggestion
+ txdata: []testTxData{testTxData{params.GWei, 21000}, testTxData{params.GWei, 21000}},
+ want: minSuggestion,
+ },
+ {
+ // 2 txs w same priority fee (1 gwei), but second tx puts it right over capacity
+ txdata: []testTxData{testTxData{params.GWei, 21000}, testTxData{params.GWei, 21001}},
+ want: big.NewInt(1100000000), // 10 percent over 1 gwei, the median
+ },
+ {
+ // 3 txs, full block. return 10% over the median tx (10 gwei * 10% == 11 gwei)
+ txdata: []testTxData{testTxData{10 * params.GWei, 21000}, testTxData{1 * params.GWei, 21000}, testTxData{100 * params.GWei, 21000}},
+ want: big.NewInt(11 * params.GWei),
+ },
+ }
+ for i, c := range cases {
+ backend := newOpTestBackend(t, c.txdata)
+ oracle := NewOracle(backend, Config{MinSuggestedPriorityFee: minSuggestion})
+ got := oracle.SuggestOptimismPriorityFee(context.Background(), backend.block.Header(), backend.block.Hash())
+ if got.Cmp(c.want) != 0 {
+ t.Errorf("Gas price mismatch for test case %d: want %d, got %d", i, c.want, got)
+ }
+ }
+}
diff --git go-ethereum/graphql/graphql.go op-geth/graphql/graphql.go
index 49be23af69dd8caebd8ecc44e84f342d12d2f1ac..d8330dffc68323dad92b0ce2d0a7d581922b84f0 100644
--- go-ethereum/graphql/graphql.go
+++ op-geth/graphql/graphql.go
@@ -773,7 +773,7 @@ if !chaincfg.IsLondon(new(big.Int).Add(header.Number, common.Big1)) {
return nil, nil
}
}
- nextBaseFee := eip1559.CalcBaseFee(chaincfg, header)
+ nextBaseFee := eip1559.CalcBaseFee(chaincfg, header, header.Time+1)
return (*hexutil.Big)(nextBaseFee), nil
}
diff --git go-ethereum/internal/ethapi/api_test.go op-geth/internal/ethapi/api_test.go
index a67bd1203b9a34f06d76f4b5800dccd6e615f31e..3380a591c05dca2162eb95ca66aeb0fadcce448e 100644
--- go-ethereum/internal/ethapi/api_test.go
+++ op-geth/internal/ethapi/api_test.go
@@ -29,6 +29,10 @@ "reflect"
"testing"
"time"
+ "github.com/holiman/uint256"
+ "github.com/stretchr/testify/require"
+ "golang.org/x/exp/slices"
+
"github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/common"
@@ -48,11 +52,166 @@ "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/internal/blocktest"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rpc"
- "github.com/holiman/uint256"
- "github.com/stretchr/testify/require"
- "golang.org/x/exp/slices"
)
+func TestNewRPCTransactionDepositTx(t *testing.T) {
+ tx := types.NewTx(&types.DepositTx{
+ SourceHash: common.HexToHash("0x1234"),
+ IsSystemTransaction: true,
+ Mint: big.NewInt(34),
+ })
+ nonce := uint64(7)
+ receipt := &types.Receipt{
+ DepositNonce: &nonce,
+ }
+ got := newRPCTransaction(tx, common.Hash{}, uint64(12), uint64(1234), uint64(1), big.NewInt(0), ¶ms.ChainConfig{}, receipt)
+ // Should provide zero values for unused fields that are required in other transactions
+ require.Equal(t, got.GasPrice, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().GasPrice = %v, want 0x0", got.GasPrice)
+ require.Equal(t, got.V, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().V = %v, want 0x0", got.V)
+ require.Equal(t, got.R, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().R = %v, want 0x0", got.R)
+ require.Equal(t, got.S, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().S = %v, want 0x0", got.S)
+
+ // Should include deposit tx specific fields
+ require.Equal(t, *got.SourceHash, tx.SourceHash(), "newRPCTransaction().SourceHash = %v, want %v", got.SourceHash, tx.SourceHash())
+ require.Equal(t, *got.IsSystemTx, tx.IsSystemTx(), "newRPCTransaction().IsSystemTx = %v, want %v", got.IsSystemTx, tx.IsSystemTx())
+ require.Equal(t, got.Mint, (*hexutil.Big)(tx.Mint()), "newRPCTransaction().Mint = %v, want %v", got.Mint, tx.Mint())
+ require.Equal(t, got.Nonce, (hexutil.Uint64)(nonce), "newRPCTransaction().Nonce = %v, want %v", got.Nonce, nonce)
+}
+
+func TestRPCTransactionDepositTxWithVersion(t *testing.T) {
+ tx := types.NewTx(&types.DepositTx{
+ SourceHash: common.HexToHash("0x1234"),
+ IsSystemTransaction: true,
+ Mint: big.NewInt(34),
+ })
+ nonce := uint64(7)
+ version := types.CanyonDepositReceiptVersion
+ receipt := &types.Receipt{
+ DepositNonce: &nonce,
+ DepositReceiptVersion: &version,
+ }
+ got := newRPCTransaction(tx, common.Hash{}, uint64(12), uint64(1234), uint64(1), big.NewInt(0), ¶ms.ChainConfig{}, receipt)
+ // Should provide zero values for unused fields that are required in other transactions
+ require.Equal(t, got.GasPrice, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().GasPrice = %v, want 0x0", got.GasPrice)
+ require.Equal(t, got.V, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().V = %v, want 0x0", got.V)
+ require.Equal(t, got.R, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().R = %v, want 0x0", got.R)
+ require.Equal(t, got.S, (*hexutil.Big)(big.NewInt(0)), "newRPCTransaction().S = %v, want 0x0", got.S)
+
+ // Should include versioned deposit tx specific fields
+ require.Equal(t, *got.SourceHash, tx.SourceHash(), "newRPCTransaction().SourceHash = %v, want %v", got.SourceHash, tx.SourceHash())
+ require.Equal(t, *got.IsSystemTx, tx.IsSystemTx(), "newRPCTransaction().IsSystemTx = %v, want %v", got.IsSystemTx, tx.IsSystemTx())
+ require.Equal(t, got.Mint, (*hexutil.Big)(tx.Mint()), "newRPCTransaction().Mint = %v, want %v", got.Mint, tx.Mint())
+ require.Equal(t, got.Nonce, (hexutil.Uint64)(nonce), "newRPCTransaction().Nonce = %v, want %v", got.Nonce, nonce)
+ require.Equal(t, *got.DepositReceiptVersion, (hexutil.Uint64(version)), "newRPCTransaction().DepositReceiptVersion = %v, want %v", *got.DepositReceiptVersion, version)
+
+ // Make sure json marshal/unmarshal of the rpc tx preserves the receipt version
+ b, err := json.Marshal(got)
+ require.NoError(t, err, "marshalling failed: %w", err)
+ parsed := make(map[string]interface{})
+ err = json.Unmarshal(b, &parsed)
+ require.NoError(t, err, "unmarshalling failed: %w", err)
+ require.Equal(t, "0x1", parsed["depositReceiptVersion"])
+}
+
+func TestNewRPCTransactionOmitIsSystemTxFalse(t *testing.T) {
+ tx := types.NewTx(&types.DepositTx{
+ IsSystemTransaction: false,
+ })
+ got := newRPCTransaction(tx, common.Hash{}, uint64(12), uint64(1234), uint64(1), big.NewInt(0), ¶ms.ChainConfig{}, nil)
+
+ require.Nil(t, got.IsSystemTx, "should omit IsSystemTx when false")
+}
+
+func TestUnmarshalRpcDepositTx(t *testing.T) {
+ version := hexutil.Uint64(types.CanyonDepositReceiptVersion)
+ tests := []struct {
+ name string
+ modifier func(tx *RPCTransaction)
+ valid bool
+ }{
+ {
+ name: "Unmodified",
+ modifier: func(tx *RPCTransaction) {},
+ valid: true,
+ },
+ {
+ name: "Zero Values",
+ modifier: func(tx *RPCTransaction) {
+ tx.V = (*hexutil.Big)(common.Big0)
+ tx.R = (*hexutil.Big)(common.Big0)
+ tx.S = (*hexutil.Big)(common.Big0)
+ tx.GasPrice = (*hexutil.Big)(common.Big0)
+ },
+ valid: true,
+ },
+ {
+ name: "Nil Values",
+ modifier: func(tx *RPCTransaction) {
+ tx.V = nil
+ tx.R = nil
+ tx.S = nil
+ tx.GasPrice = nil
+ },
+ valid: true,
+ },
+ {
+ name: "Non-Zero GasPrice",
+ modifier: func(tx *RPCTransaction) {
+ tx.GasPrice = (*hexutil.Big)(big.NewInt(43))
+ },
+ valid: false,
+ },
+ {
+ name: "Non-Zero V",
+ modifier: func(tx *RPCTransaction) {
+ tx.V = (*hexutil.Big)(big.NewInt(43))
+ },
+ valid: false,
+ },
+ {
+ name: "Non-Zero R",
+ modifier: func(tx *RPCTransaction) {
+ tx.R = (*hexutil.Big)(big.NewInt(43))
+ },
+ valid: false,
+ },
+ {
+ name: "Non-Zero S",
+ modifier: func(tx *RPCTransaction) {
+ tx.S = (*hexutil.Big)(big.NewInt(43))
+ },
+ valid: false,
+ },
+ {
+ name: "Non-nil deposit receipt version",
+ modifier: func(tx *RPCTransaction) {
+ tx.DepositReceiptVersion = &version
+ },
+ valid: true,
+ },
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ tx := types.NewTx(&types.DepositTx{
+ SourceHash: common.HexToHash("0x1234"),
+ IsSystemTransaction: true,
+ Mint: big.NewInt(34),
+ })
+ rpcTx := newRPCTransaction(tx, common.Hash{}, uint64(12), uint64(1234), uint64(1), big.NewInt(0), ¶ms.ChainConfig{}, nil)
+ test.modifier(rpcTx)
+ json, err := json.Marshal(rpcTx)
+ require.NoError(t, err, "marshalling failed: %w", err)
+ parsed := &types.Transaction{}
+ err = parsed.UnmarshalJSON(json)
+ if test.valid {
+ require.NoError(t, err, "unmarshal failed: %w", err)
+ } else {
+ require.Error(t, err, "unmarshal should have failed but did not")
+ }
+ })
+ }
+}
+
func testTransactionMarshal(t *testing.T, tests []txData, config *params.ChainConfig) {
t.Parallel()
var (
@@ -76,7 +235,7 @@ t.Fatalf("test %d: stx changed, want %x have %x", i, want, have)
}
// rpcTransaction
- rpcTx := newRPCTransaction(tx, common.Hash{}, 0, 0, 0, nil, config)
+ rpcTx := newRPCTransaction(tx, common.Hash{}, 0, 0, 0, nil, config, nil)
if data, err := json.Marshal(rpcTx); err != nil {
t.Fatalf("test %d: marshalling failed; %v", i, err)
} else if err = tx2.UnmarshalJSON(data); err != nil {
@@ -542,7 +701,7 @@ if vmConfig == nil {
vmConfig = b.chain.GetVMConfig()
}
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(header, b.chain, nil)
+ context := core.NewEVMBlockContext(header, b.chain, nil, b.ChainConfig(), state)
if blockContext != nil {
context = *blockContext
}
@@ -595,6 +754,12 @@ panic("implement me")
}
func (b testBackend) BloomStatus() (uint64, uint64) { panic("implement me") }
func (b testBackend) ServiceFilter(ctx context.Context, session *bloombits.MatcherSession) {
+ panic("implement me")
+}
+func (b testBackend) HistoricalRPCService() *rpc.Client {
+ panic("implement me")
+}
+func (b testBackend) Genesis() *types.Block {
panic("implement me")
}
@@ -804,7 +969,7 @@ From: &accounts[0].addr,
To: &accounts[1].addr,
Value: (*hexutil.Big)(big.NewInt(1000)),
},
- expectErr: errors.New("header not found"),
+ expectErr: ethereum.NotFound,
},
// transfer on the latest block
{
@@ -1084,7 +1249,7 @@ "to": "0x0000000000000000000000000000000000000011",
"transactionIndex": "0x1",
"value": "0x6f",
"type": "0x0",
- "chainId": "0x7fffffffffffffee",
+ "chainId": "0x1",
"v": "0x0",
"r": "0x0",
"s": "0x0"
@@ -1122,7 +1287,7 @@ "to": "0x0000000000000000000000000000000000000011",
"transactionIndex": "0x3",
"value": "0x6f",
"type": "0x0",
- "chainId": "0x7fffffffffffffee",
+ "chainId": "0x1",
"v": "0x0",
"r": "0x0",
"s": "0x0"
@@ -1135,7 +1300,11 @@ },
}
for i, tc := range testSuite {
- resp := RPCMarshalBlock(block, tc.inclTx, tc.fullTx, params.MainnetChainConfig)
+ resp, err := RPCMarshalBlock(context.Background(), block, tc.inclTx, tc.fullTx, params.MainnetChainConfig, testBackend{})
+ if err != nil {
+ t.Errorf("test %d: got error %v", i, err)
+ continue
+ }
out, err := json.Marshal(resp)
if err != nil {
t.Errorf("test %d: json marshal error: %v", i, err)
diff --git go-ethereum/light/odr_test.go op-geth/light/odr_test.go
index c415d73e7ef2396556eeed0e4a81da016c4512c8..b8fd99b3e1633bdd7faea7191486d8854c88712b 100644
--- go-ethereum/light/odr_test.go
+++ op-geth/light/odr_test.go
@@ -214,7 +214,7 @@ Data: data,
SkipAccountChecks: true,
}
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(header, chain, nil)
+ context := core.NewEVMBlockContext(header, chain, nil, config, st)
vmenv := vm.NewEVM(context, txContext, st, config, vm.Config{NoBaseFee: true})
gp := new(core.GasPool).AddGas(math.MaxUint64)
result, _ := core.ApplyMessage(vmenv, msg, gp)
diff --git go-ethereum/params/config_test.go op-geth/params/config_test.go
index bf8ce2fc5e247242615ff478a455785f9f07f88b..14d7f833bb978c2bb7cefc70cff2015079c9a04a 100644
--- go-ethereum/params/config_test.go
+++ op-geth/params/config_test.go
@@ -137,3 +137,22 @@ if r := c.Rules(big.NewInt(0), true, stamp); !r.IsShanghai {
t.Errorf("expected %v to be shanghai", stamp)
}
}
+
+func TestConfigRulesRegolith(t *testing.T) {
+ c := &ChainConfig{
+ RegolithTime: newUint64(500),
+ Optimism: &OptimismConfig{},
+ }
+ var stamp uint64
+ if r := c.Rules(big.NewInt(0), true, stamp); r.IsOptimismRegolith {
+ t.Errorf("expected %v to not be regolith", stamp)
+ }
+ stamp = 500
+ if r := c.Rules(big.NewInt(0), true, stamp); !r.IsOptimismRegolith {
+ t.Errorf("expected %v to be regolith", stamp)
+ }
+ stamp = math.MaxInt64
+ if r := c.Rules(big.NewInt(0), true, stamp); !r.IsOptimismRegolith {
+ t.Errorf("expected %v to be regolith", stamp)
+ }
+}
diff --git go-ethereum/params/superchain_test.go op-geth/params/superchain_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..abb72bbd351f4c0a99ea8b78deac222a816a9ccc
--- /dev/null
+++ op-geth/params/superchain_test.go
@@ -0,0 +1,172 @@
+package params
+
+import (
+ "fmt"
+ "testing"
+)
+
+type HumanProtocolVersion struct {
+ VersionType uint8
+ Major, Minor, Patch uint32
+ Prerelease uint32
+ Build [8]byte
+}
+
+type ComparisonCase struct {
+ A, B HumanProtocolVersion
+ Cmp ProtocolVersionComparison
+}
+
+func TestProtocolVersion_Compare(t *testing.T) {
+ testCases := []ComparisonCase{
+ {
+ A: HumanProtocolVersion{0, 2, 1, 1, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 1, 2, 2, 2, [8]byte{}},
+ Cmp: AheadMajor,
+ },
+ {
+ A: HumanProtocolVersion{0, 1, 2, 1, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 1, 1, 2, 2, [8]byte{}},
+ Cmp: AheadMinor,
+ },
+ {
+ A: HumanProtocolVersion{0, 1, 1, 2, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 1, 1, 1, 2, [8]byte{}},
+ Cmp: AheadPatch,
+ },
+ {
+ A: HumanProtocolVersion{0, 1, 1, 1, 2, [8]byte{}},
+ B: HumanProtocolVersion{0, 1, 1, 1, 1, [8]byte{}},
+ Cmp: AheadPrerelease,
+ },
+ {
+ A: HumanProtocolVersion{0, 1, 2, 3, 4, [8]byte{}},
+ B: HumanProtocolVersion{0, 1, 2, 3, 4, [8]byte{}},
+ Cmp: Matching,
+ },
+ {
+ A: HumanProtocolVersion{0, 3, 2, 1, 5, [8]byte{3}},
+ B: HumanProtocolVersion{1, 1, 2, 3, 3, [8]byte{6}},
+ Cmp: DiffVersionType,
+ },
+ {
+ A: HumanProtocolVersion{0, 3, 2, 1, 5, [8]byte{3}},
+ B: HumanProtocolVersion{0, 1, 2, 3, 3, [8]byte{6}},
+ Cmp: DiffBuild,
+ },
+ {
+ A: HumanProtocolVersion{0, 0, 0, 0, 0, [8]byte{}},
+ B: HumanProtocolVersion{0, 1, 3, 3, 3, [8]byte{3}},
+ Cmp: EmptyVersion,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 0, 0, 0, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 1, [8]byte{}},
+ Cmp: AheadMajor,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 1, 0, 0, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 1, 0, 1, [8]byte{}},
+ Cmp: AheadMinor,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 0, 1, 0, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 1, 1, [8]byte{}},
+ Cmp: AheadPatch,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 0, 0, 2, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 1, [8]byte{}},
+ Cmp: AheadPrerelease,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 1, 0, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 0, [8]byte{}},
+ Cmp: AheadPatch,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 0, 1, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 0, [8]byte{}},
+ Cmp: AheadPrerelease,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 1, 1, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 0, [8]byte{}},
+ Cmp: AheadMinor,
+ },
+ {
+ A: HumanProtocolVersion{0, 4, 0, 2, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 0, [8]byte{}},
+ Cmp: AheadPatch,
+ },
+ {
+ A: HumanProtocolVersion{0, 5, 0, 1, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 4, 0, 0, 0, [8]byte{}},
+ Cmp: AheadMajor,
+ },
+ {
+ A: HumanProtocolVersion{0, 1, 0, 0, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 0, 9, 0, 0, [8]byte{}},
+ Cmp: AheadMinor,
+ },
+ {
+ A: HumanProtocolVersion{0, 0, 1, 0, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 0, 0, 9, 0, [8]byte{}},
+ Cmp: AheadPatch,
+ },
+ {
+ A: HumanProtocolVersion{0, 1, ^uint32(0), 0, 1, [8]byte{}},
+ B: HumanProtocolVersion{0, 0, 1, 0, 0, [8]byte{}},
+ Cmp: InvalidVersion,
+ },
+ }
+ for i, tc := range testCases {
+ tc := tc // not a parallel sub-test, but better than a flake
+ t.Run(fmt.Sprintf("case_%d", i), func(t *testing.T) {
+ a := ProtocolVersionV0{tc.A.Build, tc.A.Major, tc.A.Minor, tc.A.Patch, tc.A.Prerelease}.Encode()
+ a[0] = tc.A.VersionType
+ b := ProtocolVersionV0{tc.B.Build, tc.B.Major, tc.B.Minor, tc.B.Patch, tc.B.Prerelease}.Encode()
+ b[0] = tc.B.VersionType
+ cmp := a.Compare(b)
+ if cmp != tc.Cmp {
+ t.Fatalf("expected %d but got %d", tc.Cmp, cmp)
+ }
+ switch tc.Cmp {
+ case AheadMajor, AheadMinor, AheadPatch, AheadPrerelease:
+ inv := b.Compare(a)
+ if inv != -tc.Cmp {
+ t.Fatalf("expected inverse when reversing the comparison, %d but got %d", -tc.Cmp, inv)
+ }
+ case DiffVersionType, DiffBuild, EmptyVersion, Matching:
+ inv := b.Compare(a)
+ if inv != tc.Cmp {
+ t.Fatalf("expected comparison reversed to hold the same, expected %d but got %d", tc.Cmp, inv)
+ }
+ }
+ })
+ }
+}
+func TestProtocolVersion_String(t *testing.T) {
+ testCases := []struct {
+ version ProtocolVersion
+ expected string
+ }{
+ {ProtocolVersionV0{[8]byte{}, 0, 0, 0, 0}.Encode(), "v0.0.0"},
+ {ProtocolVersionV0{[8]byte{}, 0, 0, 0, 1}.Encode(), "v0.0.0-1"},
+ {ProtocolVersionV0{[8]byte{}, 0, 0, 1, 0}.Encode(), "v0.0.1"},
+ {ProtocolVersionV0{[8]byte{}, 4, 3, 2, 1}.Encode(), "v4.3.2-1"},
+ {ProtocolVersionV0{[8]byte{}, 0, 100, 2, 0}.Encode(), "v0.100.2"},
+ {ProtocolVersionV0{[8]byte{'O', 'P', '-', 'm', 'o', 'd'}, 42, 0, 2, 1}.Encode(), "v42.0.2-1+OP-mod"},
+ {ProtocolVersionV0{[8]byte{'b', 'e', 't', 'a', '.', '1', '2', '3'}, 1, 0, 0, 0}.Encode(), "v1.0.0+beta.123"},
+ {ProtocolVersionV0{[8]byte{'a', 'b', 1}, 42, 0, 2, 0}.Encode(), "v42.0.2+0x6162010000000000"}, // do not render invalid alpha numeric
+ {ProtocolVersionV0{[8]byte{1, 2, 3, 4, 5, 6, 7, 8}, 42, 0, 2, 0}.Encode(), "v42.0.2+0x0102030405060708"},
+ }
+ for _, tc := range testCases {
+ t.Run(tc.expected, func(t *testing.T) {
+ got := tc.version.String()
+ if got != tc.expected {
+ t.Fatalf("got %q but expected %q", got, tc.expected)
+ }
+ })
+ }
+}
diff --git go-ethereum/rpc/http.go op-geth/rpc/http.go
index 741fa1c0eb4f63ed864dc406685d91b9707dbfe3..19e44a2e8cd2f433e9e939b953a97c18cf1e1806 100644
--- go-ethereum/rpc/http.go
+++ op-geth/rpc/http.go
@@ -33,7 +33,7 @@ "time"
)
const (
- maxRequestContentLength = 1024 * 1024 * 5
+ maxRequestContentLength = 1024 * 1024 * 32
contentType = "application/json"
)
diff --git go-ethereum/tests/state_test.go op-geth/tests/state_test.go
index 094dafcafd7a372b7f8331d14fe1b387bc5a7357..42b46e9c40a70e40432268b1351bdf7dbeeb547b 100644
--- go-ethereum/tests/state_test.go
+++ op-geth/tests/state_test.go
@@ -259,7 +259,7 @@ }
// Prepare the EVM.
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(block.Header(), nil, &t.json.Env.Coinbase)
+ context := core.NewEVMBlockContext(block.Header(), nil, &t.json.Env.Coinbase, config, statedb)
context.GetHash = vmTestBlockHash
context.BaseFee = baseFee
evm := vm.NewEVM(context, txContext, statedb, config, vmconfig)
diff --git go-ethereum/tests/state_test_util.go op-geth/tests/state_test_util.go
index 745a3c6b287ad1c9827c81784b030d8595e0adc8..39864b77b8f963d4e869e8d409c72aae7a776a65 100644
--- go-ethereum/tests/state_test_util.go
+++ op-geth/tests/state_test_util.go
@@ -271,7 +271,7 @@ }
// Prepare the EVM.
txContext := core.NewEVMTxContext(msg)
- context := core.NewEVMBlockContext(block.Header(), nil, &t.json.Env.Coinbase)
+ context := core.NewEVMBlockContext(block.Header(), nil, &t.json.Env.Coinbase, config, statedb)
context.GetHash = vmTestBlockHash
context.BaseFee = baseFee
context.Random = nil
Ignored changes
+550
-0
diff --git go-ethereum/.circleci/check-releases.sh op-geth/.circleci/check-releases.sh
new file mode 100755
index 0000000000000000000000000000000000000000..f3595e1320377bea4b17c13326d87342083071c0
--- /dev/null
+++ op-geth/.circleci/check-releases.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+set -euo pipefail
+
+LATEST_RELEASE=$(curl -s --fail -L \
+ -H "Accept: application/vnd.github+json" \
+ -H "X-GitHub-Api-Version: 2022-11-28" \
+ https://api.github.com/repos/ethereum/go-ethereum/releases \
+ | jq -r '(.[] | select(.draft==false) | select(.prerelease==false)).tag_name' | head -n 1)
+
+echo "Detected latest go-ethereum release as ${LATEST_RELEASE}"
+
+git remote add upstream https://github.com/ethereum/go-ethereum
+git fetch upstream > /dev/null
+
+if git branch --contains "${LATEST_RELEASE}" 2>&1 | grep -e '^[ *]*optimism$' > /dev/null
+then
+ echo "Up to date with latest release. Great job! 🎉"
+else
+ echo "Release has not been merged"
+ exit 1
+fi
diff --git go-ethereum/.circleci/ci-docker-tag-op-geth-release.sh op-geth/.circleci/ci-docker-tag-op-geth-release.sh
new file mode 100755
index 0000000000000000000000000000000000000000..7b66e789a4d7e50699f2d22ff037117c0d7a3a35
--- /dev/null
+++ op-geth/.circleci/ci-docker-tag-op-geth-release.sh
@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+DOCKER_REPO=$1
+GIT_TAG=$2
+GIT_SHA=$3
+
+IMAGE_NAME="op-geth"
+IMAGE_TAG=$GIT_TAG
+
+SOURCE_IMAGE_TAG="$DOCKER_REPO/$IMAGE_NAME:$GIT_SHA"
+TARGET_IMAGE_TAG="$DOCKER_REPO/$IMAGE_NAME:$IMAGE_TAG"
+TARGET_IMAGE_TAG_LATEST="$DOCKER_REPO/$IMAGE_NAME:latest"
+
+echo "Checking if docker images exist for '$IMAGE_NAME'"
+echo ""
+tags=$(gcloud container images list-tags "$DOCKER_REPO/$IMAGE_NAME" --limit 1 --format json)
+if [ "$tags" = "[]" ]; then
+ echo "No existing docker images were found for '$IMAGE_NAME'. The code tagged with '$GIT_TAG' may not have an associated dockerfile or docker build job."
+ echo "If this service has a dockerfile, add a docker-publish job for it in the circleci config."
+ echo ""
+ echo "Exiting"
+ exit 0
+fi
+
+echo "Tagging $SOURCE_IMAGE_TAG with '$IMAGE_TAG'"
+gcloud container images add-tag -q "$SOURCE_IMAGE_TAG" "$TARGET_IMAGE_TAG"
+
+# Do not tag with latest if the release is a release candidate.
+if [[ "$IMAGE_TAG" == *"rc"* ]]; then
+ echo "Not tagging with 'latest' because the release is a release candidate."
+ exit 0
+fi
+
+echo "Tagging $SOURCE_IMAGE_TAG with 'latest'"
+gcloud container images add-tag -q "$SOURCE_IMAGE_TAG" "$TARGET_IMAGE_TAG_LATEST"
+
diff --git go-ethereum/.circleci/config.yml op-geth/.circleci/config.yml
new file mode 100644
index 0000000000000000000000000000000000000000..374313392f10ecfe03d7971e7dd15d3eb5bfa493
--- /dev/null
+++ op-geth/.circleci/config.yml
@@ -0,0 +1,198 @@
+version: 2.1
+
+orbs:
+ gcp-cli: circleci/gcp-cli@3.0.1
+ slack: circleci/slack@4.10.1
+
+commands:
+ gcp-oidc-authenticate:
+ description: "Authenticate with GCP using a CircleCI OIDC token."
+ parameters:
+ project_id:
+ type: env_var_name
+ default: GCP_PROJECT_ID
+ workload_identity_pool_id:
+ type: env_var_name
+ default: GCP_WIP_ID
+ workload_identity_pool_provider_id:
+ type: env_var_name
+ default: GCP_WIP_PROVIDER_ID
+ service_account_email:
+ type: env_var_name
+ default: GCP_SERVICE_ACCOUNT_EMAIL
+ gcp_cred_config_file_path:
+ type: string
+ default: /home/circleci/gcp_cred_config.json
+ oidc_token_file_path:
+ type: string
+ default: /home/circleci/oidc_token.json
+ steps:
+ - run:
+ name: "Create OIDC credential configuration"
+ command: |
+ # Store OIDC token in temp file
+ echo $CIRCLE_OIDC_TOKEN > << parameters.oidc_token_file_path >>
+ # Create a credential configuration for the generated OIDC ID Token
+ gcloud iam workload-identity-pools create-cred-config \
+ "projects/${<< parameters.project_id >>}/locations/global/workloadIdentityPools/${<< parameters.workload_identity_pool_id >>}/providers/${<< parameters.workload_identity_pool_provider_id >>}"\
+ --output-file="<< parameters.gcp_cred_config_file_path >>" \
+ --service-account="${<< parameters.service_account_email >>}" \
+ --credential-source-file=<< parameters.oidc_token_file_path >>
+ - run:
+ name: "Authenticate with GCP using OIDC"
+ command: |
+ # Configure gcloud to leverage the generated credential configuration
+ gcloud auth login --brief --cred-file "<< parameters.gcp_cred_config_file_path >>"
+ # Configure ADC
+ echo "export GOOGLE_APPLICATION_CREDENTIALS='<< parameters.gcp_cred_config_file_path >>'" | tee -a "$BASH_ENV"
+
+jobs:
+ docker-release:
+ environment:
+ DOCKER_BUILDKIT: 1
+ parameters:
+ docker_name:
+ description: Docker image name
+ type: string
+ default: "op-geth"
+ docker_tags:
+ description: Docker image tags as csv
+ type: string
+ registry:
+ description: Docker registry
+ type: string
+ default: "us-docker.pkg.dev"
+ repo:
+ description: Docker repo
+ type: string
+ default: "oplabs-tools-artifacts/images"
+ push_tags:
+ description: Push release push tags
+ type: boolean
+ default: false
+ machine:
+ image: ubuntu-2204:2022.07.1
+ resource_class: xlarge
+ steps:
+ - gcp-cli/install
+ - gcp-oidc-authenticate
+ - checkout
+ - run:
+ name: Configure Docker
+ command: |
+ gcloud auth configure-docker <<parameters.registry>>
+ - run:
+ name: Build and push
+ command: |
+ RAW_TAGS="<<parameters.docker_tags>>"
+ if [ "$CIRCLE_BRANCH" = "optimism" ]; then
+ RAW_TAGS="$RAW_TAGS,optimism"
+ fi
+ IMAGE_BASE="<<parameters.registry>>/<<parameters.repo>>/<<parameters.docker_name>>"
+ DOCKER_TAGS=$(echo -ne "$RAW_TAGS" | sed "s/,/\n/g" | sed "s/[^a-zA-Z0-9\n.]/-/g" | sed -e "s|^|-t ${IMAGE_BASE}:|")
+ docker context create buildx-build
+ docker buildx create --use buildx-build
+ docker buildx build --push \
+ $(echo -ne $DOCKER_TAGS | tr '\n' ' ') \
+ --platform=linux/arm64,linux/amd64 \
+ --build-arg VERSION=$CIRCLE_TAG \
+ --build-arg COMMIT=$CIRCLE_SHA \
+ --build-arg BUILDNUM=$CIRCLE_BUILD_NUM \
+ --progress plain \
+ -f Dockerfile .
+ - when:
+ condition:
+ equal: [ true, <<parameters.push_tags>> ]
+ steps:
+ - run:
+ name: Tag
+ command: |
+ ./.circleci/ci-docker-tag-op-geth-release.sh <<parameters.registry>>/<<parameters.repo>> $CIRCLE_TAG $CIRCLE_SHA1
+
+
+ build-geth:
+ docker:
+ - image: cimg/go:1.20
+ resource_class: xlarge
+ steps:
+ - checkout
+ - run:
+ command: go run build/ci.go install
+ unit-test:
+ resource_class: xlarge
+ docker:
+ - image: cimg/go:1.20
+ steps:
+ - checkout
+ - run:
+ command: go run build/ci.go test
+ lint-geth:
+ resource_class: medium
+ docker:
+ - image: cimg/go:1.20
+ steps:
+ - checkout
+ - run:
+ command: go run build/ci.go lint
+ check-releases:
+ docker:
+ - image: cimg/go:1.20
+ steps:
+ - checkout
+ - run:
+ command: .circleci/check-releases.sh
+ - slack/notify:
+ channel: C03N11M0BBN
+ branch_pattern: optimism
+ event: fail
+ template: basic_fail_1
+
+
+workflows:
+ main:
+ jobs:
+ - build-geth:
+ name: Build geth
+ - unit-test:
+ name: Run unit tests for geth
+ - lint-geth:
+ name: Run linter over geth
+ - docker-release:
+ name: Push to Docker
+ docker_tags: <<pipeline.git.revision>>
+ context:
+ - oplabs-gcr
+ release:
+ jobs:
+ - hold:
+ type: approval
+ filters:
+ tags:
+ only: /^v.*/
+ branches:
+ ignore: /.*/
+ - docker-release:
+ name: Push to Docker (release)
+ filters:
+ tags:
+ only: /^v.*/
+ branches:
+ ignore: /.*/
+ docker_tags: <<pipeline.git.revision>>,<<pipeline.git.tag>>
+ push_tags: true
+ context:
+ - oplabs-gcr-release
+ requires:
+ - hold
+ scheduled:
+ triggers:
+ - schedule:
+ # run daily
+ cron: "0 0 * * *"
+ filters:
+ branches:
+ only: [ "optimism" ]
+ jobs:
+ - check-releases:
+ name: Check for new upstream releases
+ context: slack
diff --git go-ethereum/.github/workflows/pages.yaml op-geth/.github/workflows/pages.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..6973b227ce779be6138ee2084e71bb5a5cdd57de
--- /dev/null
+++ op-geth/.github/workflows/pages.yaml
@@ -0,0 +1,36 @@
+name: Build and publish forkdiff github-pages
+permissions:
+ contents: write
+on:
+ push:
+ branches:
+ - optimism
+jobs:
+ deploy:
+ concurrency: ci-${{ github.ref }}
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v3
+ with:
+ fetch-depth: 1000 # make sure to fetch the old commit we diff against
+
+ - name: Build forkdiff
+ uses: "docker://protolambda/forkdiff:latest"
+ with:
+ args: -repo=/github/workspace -fork=/github/workspace/fork.yaml -out=/github/workspace/index.html
+
+ - name: Build pages
+ run: |
+ mkdir -p tmp/pages
+ mv index.html tmp/pages/index.html
+ touch tmp/pages/.nojekyll
+ if [ "$GITHUB_REPOSITORY" == "ethereum-optimism/op-geth" ]; then
+ echo "op-geth.optimism.io" > tmp/pages/CNAME
+ fi;
+
+ - name: Deploy
+ uses: JamesIves/github-pages-deploy-action@v4
+ with:
+ folder: tmp/pages
+ clean: true
diff --git go-ethereum/fork.yaml op-geth/fork.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..eb697a7ae83b3a2d1f5255d4f9e48050e8491e0c
--- /dev/null
+++ op-geth/fork.yaml
@@ -0,0 +1,246 @@
+title: "op-geth - go-ethereum fork diff overview"
+footer: |
+ Fork-diff overview of [`op-geth`](https://github.com/ethereum-optimism/op-geth), a fork of [`go-ethereum`](https://github.com/ethereum/go-ethereum).
+ and execution-engine of the [OP-stack](https://github.com/ethereum-optimism/optimism).
+base:
+ name: go-ethereum
+ url: https://github.com/ethereum/go-ethereum
+ hash: 916d6a441a866cb618ae826c220866de118899f7 # v1.13.5
+fork:
+ name: op-geth
+ url: https://github.com/ethereum-optimism/op-geth
+ ref: refs/heads/optimism
+def:
+ title: "op-geth"
+ description: |
+ This is an overview of the changes in [`op-geth`](https://github.com/ethereum-optimism/op-geth),
+ a fork of [`go-ethereum`](https://github.com/ethereum/go-ethereum), part of the OP-stack.
+
+ The OP-stack architecture is modular, following the Consensus/Execution split of post-Merge Ethereum L1:
+
+ - [`op-node`](https://github.com/ethereum-optimism/optimism/tree/develop/op-node) implements most rollup-specific functionality as Consensus-Layer, similar to a L1 beacon-node.
+ - [`op-geth`](https://github.com/ethereum-optimism/op-geth) implements the Execution-Layer, with **minimal changes** for a secure Ethereum-equivalent application environment.
+
+ Related [op-stack specifications](https://github.com/ethereum-optimism/optimism/tree/develop/specs):
+
+ - [L2 Execution Engine spec](https://github.com/ethereum-optimism/optimism/blob/develop/specs/exec-engine.md)
+ - [Deposit Transaction spec](https://github.com/ethereum-optimism/optimism/blob/develop/specs/deposits.md)
+ sub:
+ - title: "Core modifications"
+ sub:
+ - title: "State-transition modifications"
+ description: ""
+ sub:
+ - title: "Deposit Transaction type"
+ description: |
+ The Bedrock upgrade introduces a `Deposit` transaction-type (`0x7E`) to enable both users and the
+ rollup system itself to change the L2 state based on L1 events and system rules as
+ [specified](https://github.com/ethereum-optimism/optimism/blob/develop/specs/deposits.md).
+ globs:
+ - "core/types/deposit_tx.go"
+ - "core/types/transaction_marshalling.go"
+ - "core/types/transaction_signing.go"
+ - title: "Transaction properties"
+ description: |
+ The `Transaction` type now exposes the deposit-transaction and L1-cost properties required for the rollup.
+ globs:
+ - "core/types/transaction.go"
+ - "core/types/tx_access_list.go"
+ - "core/types/tx_dynamic_fee.go"
+ - "core/types/tx_legacy.go"
+ - "core/types/tx_blob.go"
+ - title: "L1 cost computation"
+ description: |
+ Transactions must pay an additional L1 cost based on the amount of rollup-data-gas they consume,
+ estimated based on gas-price-oracle information and encoded tx size."
+ globs:
+ - "core/vm/evm.go"
+ - "core/evm.go"
+ - "core/types/rollup_l1_cost.go"
+ - "core/state_processor.go"
+ - "core/state_prefetcher.go"
+ - title: Transaction processing
+ description: |
+ Deposit transactions have special processing rules: gas is pre-paid on L1,
+ and deposits with EVM-failure are included with rolled back changes (except mint).
+ For regular transactions, at the end of the transition, the 1559 burn and L1 cost are routed to vaults.
+ globs:
+ - "core/state_transition.go"
+ - title: "Core Error definitions"
+ globs:
+ - "core/error.go"
+ - title: "Gaslimit"
+ description: |
+ The gaslimit is free to be set by the Engine API caller, instead of enforcing adjustments of the
+ gaslimit in increments of 1/1024 of the previous gaslimit.
+ The gaslimit is changed (and limited) through the `SystemConfig` contract.
+ globs:
+ - "consensus/misc/eip1559/eip1559.go"
+ - title: "Consensus tweaks"
+ description: |
+ The Engine API is activated at the Merge transition, with a Total Terminal Difficulty (TTD).
+ The rollup starts post-merge, and thus sets the TTD to 0.
+ globs:
+ - "consensus/beacon/consensus.go"
+ - title: "Engine API modifications"
+ description: |
+ The Engine API is extended to insert transactions into the block and optionally exclude the tx-pool,
+ to reproduce the exact block of the sequencer from just the inputs, as derived from L1 by the rollup-node.
+ See [L2 execution engine specs](https://github.com/ethereum-optimism/optimism/blob/develop/specs/exec-engine.md).
+ globs:
+ - "beacon/engine/types.go"
+ - "beacon/engine/gen_blockparams.go"
+ - "eth/catalyst/api.go"
+ - title: "Block-building modifications"
+ description: |
+ The block-building code (in the "miner" package because of Proof-Of-Work legacy of ethereum) implements the
+ changes to support the transaction-inclusion, tx-pool toggle and gaslimit parameters of the Engine API.
+ globs:
+ - "miner/*"
+ - title: "Tx-pool tx cost updates"
+ description: |
+ Transaction queueing and inclusion needs to account for the L1 cost component.
+ globs:
+ - "core/txpool/*"
+ - "core/txpool/legacypool/*"
+ - title: "Chain Configuration"
+ sub:
+ - title: "Chain config"
+ description: |
+ The rollup functionality is enabled with the `optimism` field in the chain config.
+ The EIP-1559 parameters are configurable to adjust for faster more frequent and smaller blocks.
+ The parameters can be overriden for testing.
+ globs:
+ - "params/config.go"
+ - "params/protocol_params.go"
+ - "core/genesis.go"
+ - title: "Chain config cleanup"
+ description: |
+ The optimism Goerli testnet used clique-config data to make geth internals accept blocks.
+ Post-bedrock the beacon-consensus (i.e. follow Engine API) is now used, and the clique config is removed.
+ globs:
+ - "core/rawdb/accessors_metadata.go"
+ - title: Genesis loading
+ globs:
+ - "core/gen_genesis.go"
+ - title: "Superchain config"
+ description: Testing of the superchain configuration
+ globs:
+ - "core/superchain.go"
+ - "params/superchain.go"
+ - title: "Node modifications"
+ description: Changes to the node configuration and services.
+ sub:
+ - title: "CLI"
+ sub:
+ - title: "Flags"
+ description: |
+ Flag changes:
+ - Transactions can be forwarded to an RPC for sequencing.
+ - Historical calls can be forwarded to a legacy node.
+ - The tx pool propagation can be enabled/disabled.
+ - The Optimism bedrock fork activation can be changed for testing.
+ globs:
+ - "cmd/utils/flags.go"
+ - "cmd/geth/main.go"
+ - "internal/flags/categories.go"
+ - "cmd/geth/config.go"
+ - title: "Versioning"
+ description: List the op-geth and upstream go-ethereum versions.
+ globs:
+ - "cmd/geth/misccmd.go"
+ - "params/version.go"
+ - "build/ci.go"
+ - title: Node config
+ globs:
+ - "eth/ethconfig/config.go"
+ - title: Tx gossip disable option
+ globs:
+ - "eth/handler.go"
+ - "eth/handler_eth.go"
+ - title: Warn on missing hardfork data
+ globs:
+ - "core/blockchain.go"
+ - title: Optional Engine API extensions
+ globs:
+ - "eth/catalyst/superchain.go"
+ - title: Support legacy DBs when snap-syncing
+ description: Snap-sync does not serve unprefixed code by default.
+ globs:
+ - "core/blockchain_reader.go"
+ - "eth/protocols/snap/handler.go"
+ - title: Discv5 node discovery
+ description: Fix discv5 option to allow discv5 to be an active source for node-discovery.
+ globs:
+ - "p2p/server.go"
+ - title: Generated TOML config update
+ globs:
+ - "eth/ethconfig/gen_config.go"
+ - title: "User API enhancements"
+ description: "Encode the Deposit Tx properties, the L1 costs, and daisy-chain RPC-calls for pre-Bedrock historical data"
+ sub:
+ - title: "Receipts metadata"
+ description: |
+ Pre-Bedrock L1-cost receipt data is loaded from the database if available, and post-Bedrock the L1-cost
+ metadata is hydrated on-the-fly based on the L1 fee information in the corresponding block.
+ globs:
+ - "core/types/receipt.go"
+ - "core/types/gen_receipt_json.go"
+ - "core/rawdb/accessors_chain.go"
+ - title: "API Backend"
+ description: |
+ Forward transactions to the sequencer if configured.
+ globs:
+ - "eth/api_backend.go"
+ - "eth/backend.go"
+ - "internal/ethapi/backend.go"
+ - title: "Apply L1 cost in API responses"
+ globs:
+ - "eth/state_accessor.go"
+ - title: API frontend
+ description: Format deposit and L1-cost data in transaction responses. Add `debug_chainConfig` API.
+ globs:
+ - "internal/ethapi/api.go"
+ - "rpc/errors.go"
+ - title: Tracer RPC daisy-chain
+ description: Forward pre-bedrock tracing calls to legacy node.
+ globs:
+ - "eth/tracers/api.go"
+ - title: "Light Ethereum Subprotocol (LES) RPC"
+ description: Match the RPC changes in the LES RPC
+ globs:
+ - "les/*"
+ - title: "Daisy Chain tests"
+ globs:
+ - "internal/ethapi/transaction_args_test.go"
+ - "ethclient/ethclient_test.go"
+ - "eth/tracers/api_test.go"
+ - title: Debug API
+ description: Fix Debug API block marshaling to include deposits
+ globs:
+ - "eth/api_debug.go"
+ - title: Eth gasprice suggestions
+ description: gasprice suggestion adjustments to accommodate faster L2 blocks and lower fees.
+ globs:
+ - "eth/gasprice/gasprice.go"
+ - "eth/gasprice/optimism-gasprice.go"
+ - title: API testvector fix
+ description: |
+ Upstream test of broken behavior; in Optimism, a zero signature is valid (pre-bedrock for deposit-txs),
+ and the chain ID formula on signature data must not be used, or an underflow happens.
+ globs:
+ - "internal/ethapi/testdata/eth_getBlockByNumber-tag-pending-fullTx.json"
+ - title: "Geth extras"
+ description: Extend the tools available in geth to improve external testing and tooling.
+ sub:
+ - title: Simulated Backend
+ globs:
+ - "accounts/abi/bind/backends/simulated.go"
+
+# ignored globally, does not count towards line count
+ignore:
+ - ".circleci/*"
+ - "*.sum"
+ - "go.mod"
+ - "fork.yaml"
+ - ".github/workflows/*"
diff --git go-ethereum/go.mod op-geth/go.mod
index 385d5afdc80000a4e7fd020d00a4fc8b554d4b2a..48e534b9561a1891153f1c4d85e9feb03f410ef6 100644
--- go-ethereum/go.mod
+++ op-geth/go.mod
@@ -20,6 +20,7 @@ github.com/crate-crypto/go-kzg-4844 v0.7.0
github.com/davecgh/go-spew v1.1.1
github.com/deckarep/golang-set/v2 v2.1.0
github.com/dop251/goja v0.0.0-20230806174421-c933cf95e127
+ github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20231030223232-e16eae11e492
github.com/ethereum/c-kzg-4844 v0.4.0
github.com/fatih/color v1.13.0
github.com/fjl/gencodec v0.0.0-20230517082657-f9840df7b83e
@@ -133,6 +134,7 @@ github.com/prometheus/procfs v0.7.3 // indirect
github.com/rivo/uniseg v0.2.0 // indirect
github.com/rogpeppe/go-internal v1.9.0 // indirect
github.com/russross/blackfriday/v2 v2.1.0 // indirect
+ github.com/stretchr/objx v0.5.0 // indirect
github.com/tklauser/go-sysconf v0.3.12 // indirect
github.com/tklauser/numcpus v0.6.1 // indirect
github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
@@ -142,3 +144,5 @@ google.golang.org/protobuf v1.27.1 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
rsc.io/tmplfunc v0.0.3 // indirect
)
+
+//replace github.com/ethereum-optimism/superchain-registry/superchain => ../superchain-registry/superchain
diff --git go-ethereum/go.sum op-geth/go.sum
index cc38e7975f17c7823b2b5571e25ebc256a7da4d3..91aed70e7eff22c9d084d55454282bc18468e50d 100644
--- go-ethereum/go.sum
+++ op-geth/go.sum
@@ -181,6 +181,8 @@ github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
+github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20231030223232-e16eae11e492 h1:FyzLzMLKMc9zcDYcSxbrLDglIRrGQJE9juFzIO35RmE=
+github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20231030223232-e16eae11e492/go.mod h1:/70H/KqrtKcvWvNGVj6S3rAcLC+kUPr3t2aDmYIS+Xk=
github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY=
github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8=
@@ -557,11 +559,16 @@ github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA=
github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4=