op-erigon

diff --git erigontech/erigon/core/types/deposit_tx.go testinprod-io/erigon/core/types/deposit_tx.go new file mode 100644 index 0000000000000000000000000000000000000000..b166fab29aafe4551977298782e8621fdba479aa --- /dev/null +++ testinprod-io/erigon/core/types/deposit_tx.go @@ -0,0 +1,474 @@ +// 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 ( + "fmt" + "io" + "math/big" + "math/bits" + "sync/atomic" + "time" + + "github.com/ledgerwatch/erigon-lib/chain" + libcommon "github.com/ledgerwatch/erigon-lib/common" + types2 "github.com/ledgerwatch/erigon-lib/types" + + "github.com/ledgerwatch/erigon/rlp" + + "github.com/holiman/uint256" + "github.com/ledgerwatch/erigon/common" +) + +type DepositTx struct { + time time.Time // Time first seen locally (spam avoidance) + // caches + hash atomic.Value //nolint:structcheck + size atomic.Value //nolint:structcheck + // SourceHash uniquely identifies the source of the deposit + SourceHash libcommon.Hash + // From is exposed through the types.Signer, not through TxData + From libcommon.Address + // nil means contract creation + To *libcommon.Address `rlp:"nil"` + // Mint is minted on L2, locked on L1, nil if no minting. + Mint *uint256.Int `rlp:"nil"` + // Value is transferred from L2 balance, executed after Mint (if any) + Value *uint256.Int + // gas limit + Gas uint64 + // Field indicating if this transaction is exempt from the L2 gas limit. + IsSystemTransaction bool + // Normal Tx data + Data []byte +} + +var _ Transaction = (*DepositTx)(nil) + +func (tx DepositTx) GetChainID() *uint256.Int { + panic("deposits are not signed and do not have a chain-ID") +} + +func (tx DepositTx) GetNonce() uint64 { + return 0 +} + +func (tx DepositTx) GetTo() *libcommon.Address { + return tx.To +} + +func (tx DepositTx) GetBlobGas() uint64 { + return 0 +} + +func (tx DepositTx) GetBlobHashes() []libcommon.Hash { + return []libcommon.Hash{} +} + +func (tx DepositTx) GetGas() uint64 { + return tx.Gas +} + +func (tx DepositTx) GetValue() *uint256.Int { + return tx.Value +} + +func (tx DepositTx) GetData() []byte { + return tx.Data +} + +func (tx DepositTx) GetSender() (libcommon.Address, bool) { + return tx.From, true +} + +func (tx *DepositTx) SetSender(addr libcommon.Address) { + tx.From = addr +} + +func (tx DepositTx) RawSignatureValues() (*uint256.Int, *uint256.Int, *uint256.Int) { + panic("deposit tx does not have a signature") +} + +func (tx DepositTx) SigningHash(chainID *big.Int) libcommon.Hash { + panic("deposit tx does not have a signing hash") +} + +// NOTE: Need to check this +func (tx *DepositTx) Size() common.StorageSize { + if size := tx.size.Load(); size != nil { + return size.(common.StorageSize) + } + c := tx.EncodingSize() + tx.size.Store(common.StorageSize(c)) + return common.StorageSize(c) +} + +// NOTE: Need to check this +func (tx DepositTx) EncodingSize() int { + payloadSize, _, _, _ := tx.payloadSize() + envelopeSize := payloadSize + // Add envelope size and type size + if payloadSize >= 56 { + envelopeSize += (bits.Len(uint(payloadSize)) + 7) / 8 + } + envelopeSize += 2 + return envelopeSize +} + +// MarshalBinary returns the canonical encoding of the transaction. +// For legacy transactions, it returns the RLP encoding. For EIP-2718 typed +// transactions, it returns the type and payload. +func (tx DepositTx) MarshalBinary(w io.Writer) error { + payloadSize, nonceLen, gasLen, accessListLen := tx.payloadSize() + var b [33]byte + // encode TxType + b[0] = DepositTxType + if _, err := w.Write(b[:1]); err != nil { + return err + } + if err := tx.encodePayload(w, b[:], payloadSize, nonceLen, gasLen, accessListLen); err != nil { + return err + } + return nil +} + +func (tx DepositTx) payloadSize() (payloadSize int, nonceLen, gasLen, accessListLen int) { + // size of SourceHash + payloadSize += 33 + // size of From + payloadSize += 21 + // size of To + payloadSize++ + if tx.To != nil { + payloadSize += 20 + } + // size of Mint + payloadSize++ + payloadSize += rlp.Uint256LenExcludingHead(tx.Mint) + // size of Value + payloadSize++ + payloadSize += rlp.Uint256LenExcludingHead(tx.Value) + // size of Gas + payloadSize++ + gasLen = rlp.IntLenExcludingHead(tx.Gas) + payloadSize += gasLen + // size of IsSystemTransaction + payloadSize++ + // size of Data + payloadSize++ + switch len(tx.Data) { + case 0: + case 1: + if tx.Data[0] >= 128 { + payloadSize++ + } + default: + if len(tx.Data) >= 56 { + payloadSize += (bits.Len(uint(len(tx.Data))) + 7) / 8 + } + payloadSize += len(tx.Data) + } + return payloadSize, 0, gasLen, 0 +} + +func (tx DepositTx) encodePayload(w io.Writer, b []byte, payloadSize, nonceLen, gasLen, accessListLen int) error { + // prefix + if err := EncodeStructSizePrefix(payloadSize, w, b); err != nil { + return err + } + // encode SourceHash + b[0] = 128 + 32 + if _, err := w.Write(b[:1]); err != nil { + return nil + } + if _, err := w.Write(tx.SourceHash.Bytes()); err != nil { + return nil + } + // encode From + b[0] = 128 + 20 + if _, err := w.Write(b[:1]); err != nil { + return nil + } + if _, err := w.Write(tx.From.Bytes()); err != nil { + return nil + } + // encode To + if tx.To == nil { + b[0] = 128 + } else { + b[0] = 128 + 20 + } + if _, err := w.Write(b[:1]); err != nil { + return err + } + if tx.To != nil { + if _, err := w.Write(tx.To.Bytes()); err != nil { + return err + } + } + // encode Mint + if err := tx.Mint.EncodeRLP(w); err != nil { + return err + } + // encode Value + if err := tx.Value.EncodeRLP(w); err != nil { + return err + } + // encode Gas + if err := rlp.EncodeInt(tx.Gas, w, b); err != nil { + return err + } + // encode IsSystemTransaction + if tx.IsSystemTransaction { + b[0] = 0x01 + } else { + b[0] = 0x80 + } + if _, err := w.Write(b[:1]); err != nil { + return nil + } + // encode Data + if err := rlp.EncodeString(tx.Data, w, b); err != nil { + return err + } + return nil +} + +func (tx DepositTx) EncodeRLP(w io.Writer) error { + payloadSize, nonceLen, gasLen, accessListLen := tx.payloadSize() + envelopeSize := payloadSize + if payloadSize >= 56 { + envelopeSize += (bits.Len(uint(payloadSize)) + 7) / 8 + } + // size of struct prefix and TxType + envelopeSize += 2 + var b [33]byte + // envelope + if err := rlp.EncodeStringSizePrefix(envelopeSize, w, b[:]); err != nil { + return err + } + // encode TxType + b[0] = DepositTxType + if _, err := w.Write(b[:1]); err != nil { + return err + } + if err := tx.encodePayload(w, b[:], payloadSize, nonceLen, gasLen, accessListLen); err != nil { + return err + } + return nil +} + +func (tx *DepositTx) DecodeRLP(s *rlp.Stream) error { + _, err := s.List() + if err != nil { + return err + } + var b []byte + // SourceHash + if b, err = s.Bytes(); err != nil { + return err + } + if len(b) != 32 { + return fmt.Errorf("wrong size for Source hash: %d", len(b)) + } + copy(tx.SourceHash[:], b) + // From + if b, err = s.Bytes(); err != nil { + return err + } + if len(b) != 20 { + return fmt.Errorf("wrong size for From hash: %d", len(b)) + } + copy(tx.From[:], b) + // To (optional) + if b, err = s.Bytes(); err != nil { + return err + } + if len(b) > 0 && len(b) != 20 { + return fmt.Errorf("wrong size for To: %d", len(b)) + } + if len(b) > 0 { + tx.To = &libcommon.Address{} + copy((*tx.To)[:], b) + } + // Mint + if b, err = s.Uint256Bytes(); err != nil { + return err + } + tx.Mint = new(uint256.Int).SetBytes(b) + // Value + if b, err = s.Uint256Bytes(); err != nil { + return err + } + tx.Value = new(uint256.Int).SetBytes(b) + // Gas + if tx.Gas, err = s.Uint(); err != nil { + return err + } + if tx.IsSystemTransaction, err = s.Bool(); err != nil { + return err + } + // Data + if tx.Data, err = s.Bytes(); err != nil { + return err + } + return s.ListEnd() +} + +func (tx *DepositTx) FakeSign(address libcommon.Address) (Transaction, error) { + cpy := tx.copy() + cpy.SetSender(address) + return cpy, nil +} + +func (tx *DepositTx) WithSignature(signer Signer, sig []byte) (Transaction, error) { + return tx.copy(), nil +} + +func (tx DepositTx) Time() time.Time { + return tx.time +} + +func (tx DepositTx) Type() byte { return DepositTxType } + +func (tx *DepositTx) Hash() libcommon.Hash { + if hash := tx.hash.Load(); hash != nil { + return *hash.(*libcommon.Hash) + } + hash := prefixedRlpHash(DepositTxType, []interface{}{ + tx.SourceHash, + tx.From, + tx.To, + tx.Mint, + tx.Value, + tx.Gas, + tx.IsSystemTransaction, + tx.Data, + }) + tx.hash.Store(&hash) + return hash +} + +// not sure ab this one lol +func (tx DepositTx) Protected() bool { + return true +} + +func (tx DepositTx) IsContractDeploy() bool { + return false +} + +func (tx DepositTx) IsStarkNet() bool { + return false +} + +// All zero in the prototype +func (tx DepositTx) GetPrice() *uint256.Int { return uint256.NewInt(0) } +func (tx DepositTx) GetTip() *uint256.Int { return uint256.NewInt(0) } +func (tx DepositTx) GetFeeCap() *uint256.Int { return uint256.NewInt(0) } +func (tx DepositTx) GetEffectiveGasTip(baseFee *uint256.Int) *uint256.Int { + return uint256.NewInt(0) +} + +func (tx DepositTx) Cost() *uint256.Int { + return tx.Value.Clone() +} + +func (tx DepositTx) GetAccessList() types2.AccessList { + return nil +} + +// NewDepositTransaction creates a deposit transaction +func NewDepositTransaction( + sourceHash libcommon.Hash, + from libcommon.Address, + to libcommon.Address, + mint *uint256.Int, + value *uint256.Int, + gasLimit uint64, + isSystemTx bool, + data []byte) *DepositTx { + return &DepositTx{ + SourceHash: sourceHash, + From: from, + To: &to, + Mint: mint, + Value: value, + Gas: gasLimit, + IsSystemTransaction: isSystemTx, + Data: data, + } +} + +// copy creates a deep copy of the transaction data and initializes all fields. +func (tx DepositTx) copy() *DepositTx { + cpy := &DepositTx{ + SourceHash: tx.SourceHash, + From: tx.From, + To: tx.To, + Mint: nil, + Value: new(uint256.Int), + Gas: tx.Gas, + IsSystemTransaction: tx.IsSystemTransaction, + Data: libcommon.CopyBytes(tx.Data), + } + if tx.Mint != nil { + cpy.Mint = new(uint256.Int).Set(tx.Mint) + } + if tx.Value != nil { + cpy.Value.Set(tx.Value) + } + return cpy +} + +// AsMessage returns the transaction as a core.Message. +func (tx DepositTx) AsMessage(s Signer, baseFee *big.Int, rules *chain.Rules) (Message, error) { + msg := Message{ + nonce: 0, + gasLimit: tx.Gas, + gasPrice: *uint256.NewInt(0), + tip: *uint256.NewInt(0), + feeCap: *uint256.NewInt(0), + from: tx.From, + to: tx.To, + amount: *tx.Value, + data: tx.Data, + accessList: nil, + checkNonce: true, + isSystemTx: tx.IsSystemTransaction, + isDepositTx: true, + mint: tx.Mint, + } + return msg, nil +} + +func (tx *DepositTx) Sender(signer Signer) (libcommon.Address, error) { + return tx.From, nil +} + +func (tx DepositTx) RollupCostData() types2.RollupCostData { + return types2.RollupCostData{} +} + +func (tx *DepositTx) GetDataHashes() []libcommon.Hash { + // Only blob txs have data hashes + return []libcommon.Hash{} +} + +func (tx *DepositTx) Unwrap() Transaction { + return tx +}

diff --git erigontech/erigon/core/types/transaction_marshalling.go testinprod-io/erigon/core/types/transaction_marshalling.go index bb604a0bc04f18da7783412cbea0e88512bf7651..847375170cc39d0855f5fff6269792c812cb251c 100644 --- erigontech/erigon/core/types/transaction_marshalling.go +++ testinprod-io/erigon/core/types/transaction_marshalling.go @@ -32,6 +32,12 @@ R *hexutil.Big `json:"r"` S *hexutil.Big `json:"s"` To *libcommon.Address `json:"to"`   + // Deposit transaction fields + SourceHash *libcommon.Hash `json:"sourceHash,omitempty"` + From *libcommon.Address `json:"from,omitempty"` + Mint *hexutil.Big `json:"mint,omitempty"` + IsSystemTx *bool `json:"isSystemTx,omitempty"` + // Access list transaction fields: ChainID *hexutil.Big `json:"chainId,omitempty"` AccessList *types2.AccessList `json:"accessList,omitempty"` @@ -107,6 +113,27 @@ enc.S = (*hexutil.Big)(tx.S.ToBig()) return json.Marshal(&enc) }   +func (tx DepositTx) MarshalJSON() ([]byte, error) { + var enc txJSON + + enc.Hash = tx.Hash() + enc.Type = hexutil.Uint64(tx.Type()) + enc.ChainID = (*hexutil.Big)(libcommon.Big0) + enc.Gas = (*hexutil.Uint64)(&tx.Gas) + enc.Value = (*hexutil.Big)(tx.Value.ToBig()) + enc.Data = (*hexutility.Bytes)(&tx.Data) + enc.To = tx.To + // DepositTx fields + enc.SourceHash = &tx.SourceHash + enc.From = &tx.From + if tx.Mint != nil { + enc.Mint = (*hexutil.Big)(tx.Mint.ToBig()) + } + enc.IsSystemTx = &tx.IsSystemTransaction + // other fields will show up as null. + return json.Marshal(&enc) +} + func toBlobTxJSON(tx *BlobTx) *txJSON { var enc txJSON // These are set for all tx types. @@ -172,6 +199,12 @@ } return tx, nil case DynamicFeeTxType: tx := &DynamicFeeTransaction{} + if err = tx.UnmarshalJSON(input); err != nil { + return nil, err + } + return tx, nil + case DepositTxType: + tx := &DepositTx{} if err = tx.UnmarshalJSON(input); err != nil { return nil, err } @@ -411,6 +444,59 @@ if err := sanityCheckSignature(&tx.V, &tx.R, &tx.S, false); err != nil { return err } } + return nil +} + +func (tx *DepositTx) UnmarshalJSON(input []byte) error { + var dec txJSON + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.AccessList != nil || dec.FeeCap != nil || dec.Tip != nil { + return errors.New("unexpected field(s) in deposit transaction") + } + if dec.GasPrice != nil && dec.GasPrice.ToInt().Cmp(libcommon.Big0) != 0 { + return errors.New("deposit transaction GasPrice must be 0") + } + if (dec.V != nil && dec.V.ToInt().Cmp(libcommon.Big0) != 0) || + (dec.R != nil && dec.R.ToInt().Cmp(libcommon.Big0) != 0) || + (dec.S != nil && dec.S.ToInt().Cmp(libcommon.Big0) != 0) { + return errors.New("deposit transaction signature must be 0 or unset") + } + if dec.To != nil { + tx.To = dec.To + } + tx.Gas = uint64(*dec.Gas) + if dec.Value == nil { + return errors.New("missing required field 'value' in transaction") + } + var overflow bool + tx.Value, overflow = uint256.FromBig(dec.Value.ToInt()) + if overflow { + return errors.New("'value' in transaction does not fit in 256 bits") + } + // mint may be omitted or nil if there is nothing to mint. + tx.Mint, overflow = uint256.FromBig(dec.Mint.ToInt()) + if overflow { + return errors.New("'mint' in transaction does not fit in 256 bits") + } + if dec.Data == nil { + return errors.New("missing required field 'input' in transaction") + } + tx.Data = *dec.Data + if dec.From == nil { + return errors.New("missing required field 'from' in transaction") + } + tx.From = *dec.From + if dec.SourceHash == nil { + return errors.New("missing required field 'sourceHash' in transaction") + } + tx.SourceHash = *dec.SourceHash + // IsSystemTx may be omitted. Defaults to false. + if dec.IsSystemTx != nil { + tx.IsSystemTransaction = *dec.IsSystemTx + } + // nonce is not checked becaues depositTx has no nonce field. return nil }

diff --git erigontech/erigon/core/types/transaction_signing.go testinprod-io/erigon/core/types/transaction_signing.go index 19695c6c93dd2c9cca884d81ede5c5c856e2440b..6e82843adab852de5ad4fde354cd1a50658781c7 100644 --- erigontech/erigon/core/types/transaction_signing.go +++ testinprod-io/erigon/core/types/transaction_signing.go @@ -45,7 +45,7 @@ } } signer.unprotected = true switch { - case config.IsCancun(blockTime): + case config.IsCancun(blockTime) && !config.IsOptimism(): // All transaction types are still supported signer.protected = true signer.accessList = true @@ -100,7 +100,7 @@ } signer.chainID.Set(chainId) signer.chainIDMul.Mul(chainId, u256.Num2) if config.ChainID != nil { - if config.CancunTime != nil { + if config.CancunTime != nil && !config.IsOptimism() { signer.blob = true } if config.LondonBlock != nil { @@ -205,6 +205,8 @@ var R, S *uint256.Int signChainID := sg.chainID.ToBig() // This is reset to nil if tx is unprotected // recoverPlain below will subract 27 from V switch t := tx.(type) { + case *DepositTx: + return t.From, nil case *LegacyTx: if !t.Protected() { if !sg.unprotected { @@ -300,6 +302,8 @@ if t.ChainID != nil && !t.ChainID.IsZero() && !t.ChainID.Eq(&sg.chainID) { return nil, nil, nil, ErrInvalidChainId } R, S, V = decodeSignature(sig) + case *DepositTx: + return nil, nil, nil, fmt.Errorf("deposits do not have a signature") case *BlobTx: // Check that chain ID of tx matches the signer. We also accept ID zero here, // because it indicates that the chain ID was not specified in the tx.

diff --git erigontech/erigon/erigon-lib/types/txn.go testinprod-io/erigon/erigon-lib/types/txn.go index ead791092543df5580d57a1370070010e0d149bf..e799fcdb48787767e666c104c0811e0cbc2a1532 100644 --- erigontech/erigon/erigon-lib/types/txn.go +++ testinprod-io/erigon/erigon-lib/types/txn.go @@ -36,6 +36,7 @@ "github.com/ledgerwatch/erigon-lib/common/fixedgas" "github.com/ledgerwatch/erigon-lib/common/length" "github.com/ledgerwatch/erigon-lib/common/u256" "github.com/ledgerwatch/erigon-lib/crypto" + "github.com/ledgerwatch/erigon-lib/fastlz" "github.com/ledgerwatch/erigon-lib/gointerfaces/types" "github.com/ledgerwatch/erigon-lib/rlp" ) @@ -108,6 +109,8 @@ BlobHashes []common.Hash Blobs [][]byte Commitments []gokzg4844.KZGCommitment Proofs []gokzg4844.KZGProof + + RollupCostData RollupCostData }   const ( @@ -115,6 +118,7 @@ LegacyTxType byte = 0 AccessListTxType byte = 1 // EIP-2930 DynamicFeeTxType byte = 2 // EIP-1559 BlobTxType byte = 3 // EIP-4844 + DepositTxType byte = 126 )   var ErrParseTxn = fmt.Errorf("%w transaction", rlp.ErrParse) @@ -122,6 +126,7 @@ var ErrRejected = errors.New("rejected") var ErrAlreadyKnown = errors.New("already known") var ErrRlpTooBig = errors.New("txn rlp too big") +var ErrTxTypeNotSupported = errors.New("transaction type not supported")   // Set the RLP validate function func (ctx *TxParseContext) ValidateRLP(f func(txnRlp []byte) error) { ctx.validateRlp = f } @@ -184,7 +189,7 @@ // If it is non-legacy transaction, the transaction type follows, and then the list if !legacy { slot.Type = payload[p] - if slot.Type > BlobTxType { + if slot.Type > BlobTxType && slot.Type != DepositTxType { return 0, fmt.Errorf("%w: unknown transaction type: %d", ErrParseTxn, slot.Type) } p++ @@ -323,6 +328,81 @@ return p, err } }   + if slot.Type == DepositTxType { + // SourchHash + p, _, err = rlp.SkipString(payload, p) + if err != nil { + return 0, fmt.Errorf("%w: depostTx sourchHash: %s", ErrParseTxn, err) //nolint + } + // From + dataPos, dataLen, err := rlp.String(payload, p) + if err != nil { + return 0, fmt.Errorf("%w: depostTx from: %s", ErrParseTxn, err) //nolint + } + if ctx.withSender { + copy(sender, payload[dataPos:dataPos+dataLen]) + } + p = dataPos + dataLen + // To + p, dataLen, err = rlp.SkipString(payload, p) + if err != nil { + return 0, fmt.Errorf("%w: depostTx to: %s", ErrParseTxn, err) //nolint + } + slot.Creation = dataLen == 0 + // Mint + p, _, err = rlp.SkipString(payload, p) + if err != nil { + return 0, fmt.Errorf("%w: depostTx mint: %s", ErrParseTxn, err) //nolint + } + // Value + p, err = rlp.U256(payload, p, &slot.Value) + if err != nil { + return 0, fmt.Errorf("%w: depostTx value: %s", ErrParseTxn, err) //nolint + } + // Gas + p, slot.Gas, err = rlp.U64(payload, p) + if err != nil { + return 0, fmt.Errorf("%w: depositTx gas: %s", ErrParseTxn, err) //nolint + } + // Data + dataPos, dataLen, err = rlp.String(payload, p) + if err != nil { + return 0, fmt.Errorf("%w: depositTx data len: %s", ErrParseTxn, err) //nolint + } + slot.DataLen = dataLen + + // Zero and non-zero bytes are priced differently + slot.DataNonZeroLen = 0 + for _, byt := range payload[dataPos : dataPos+dataLen] { + if byt != 0 { + slot.DataNonZeroLen++ + } + } + { + // full tx contents count towards rollup data gas, not just tx data + var zeroes, ones, fastLzSize uint64 + for _, byt := range payload { + if byt == 0 { + zeroes++ + } else { + ones++ + } + } + fastLzSize = uint64(fastlz.FlzCompressLen(payload)) + slot.RollupCostData = RollupCostData{Zeroes: zeroes, Ones: ones, FastLzSize: fastLzSize} + } + p = dataPos + dataLen + + // Set IDHash to slot + _, _ = ctx.Keccak1.(io.Reader).Read(slot.IDHash[:32]) + if validateHash != nil { + if err := validateHash(slot.IDHash[:32]); err != nil { + return p, err + } + } + return p, nil + } + // Remember where signing hash data begins (it will need to be wrapped in an RLP list) sigHashPos := p if !legacy { @@ -395,6 +475,19 @@ for _, byt := range payload[dataPos : dataPos+dataLen] { if byt != 0 { slot.DataNonZeroLen++ } + } + { + // full tx contents count towards rollup data gas, not just tx data + var zeroes, ones, fastLzSize uint64 + for _, byt := range payload { + if byt == 0 { + zeroes++ + } else { + ones++ + } + } + fastLzSize = uint64(fastlz.FlzCompressLen(payload)) + slot.RollupCostData = RollupCostData{Zeroes: zeroes, Ones: ones, FastLzSize: fastLzSize} }   p = dataPos + dataLen @@ -984,6 +1077,15 @@ sum += len(tuple.StorageKeys) } return sum } + +// RollupCostData is a transaction structure that caches data for quickly computing the data +// availability costs for the transaction. +type RollupCostData struct { + Zeroes, Ones uint64 + FastLzSize uint64 +} + +type L1CostFn func(tx *TxSlot) *uint256.Int   // Removes everything but the payload body from blob tx and prepends 0x3 at the beginning - no copy // Doesn't change non-blob tx

diff --git erigontech/erigon/eth/ethutils/receipt.go testinprod-io/erigon/eth/ethutils/receipt.go index 2caa571290e29475eb475cd23d7b3eb89d768159..8884b0ed569e0bcb9fc5920518fcd1555c6f57e9 100644 --- erigontech/erigon/eth/ethutils/receipt.go +++ testinprod-io/erigon/eth/ethutils/receipt.go @@ -27,6 +27,8 @@ case *types.LegacyTx: if t.Protected() { chainId = types.DeriveChainId(&t.V).ToBig() } + case *types.DepositTx: + // Deposit TX does not have chain ID default: chainId = txn.GetChainID().ToBig() } @@ -69,6 +71,35 @@ // If the ContractAddress is 20 0x0 bytes, assume it is not a contract creation if receipt.ContractAddress != (common.Address{}) { fields["contractAddress"] = receipt.ContractAddress + } + + if chainConfig.IsOptimism() { + if txn.Type() != types.DepositTxType { + fields["l1GasPrice"] = hexutil.Big(*receipt.L1GasPrice) + fields["l1GasUsed"] = hexutil.Big(*receipt.L1GasUsed) + fields["l1Fee"] = hexutil.Big(*receipt.L1Fee) + // Fields removed in Ecotone + if receipt.FeeScalar != nil { + fields["l1FeeScalar"] = receipt.FeeScalar + } + // Fields added in Ecotone + if receipt.L1BlobBaseFee != nil { + fields["l1BlobBaseFee"] = (*hexutil.Big)(receipt.L1BlobBaseFee) + } + if receipt.L1BaseFeeScalar != nil { + fields["l1BaseFeeScalar"] = hexutil.Uint64(*receipt.L1BaseFeeScalar) + } + if receipt.L1BlobBaseFeeScalar != nil { + fields["l1BlobBaseFeeScalar"] = hexutil.Uint64(*receipt.L1BlobBaseFeeScalar) + } + } else { + if receipt.DepositNonce != nil { + fields["depositNonce"] = hexutil.Uint64(*receipt.DepositNonce) + } + if receipt.DepositReceiptVersion != nil { + fields["depositReceiptVersion"] = hexutil.Uint64(*receipt.DepositReceiptVersion) + } + } }   // Set derived blob related fields

diff --git erigontech/erigon/core/types/access_list_tx.go testinprod-io/erigon/core/types/access_list_tx.go index 8e418e7b9073836bb9a65ceeaa1ee9471d1f0c55..e7b120c7f398591a2e0df7027a80ef346812d59b 100644 --- erigontech/erigon/core/types/access_list_tx.go +++ testinprod-io/erigon/core/types/access_list_tx.go @@ -427,6 +427,7 @@ amount: *tx.Value, data: tx.Data, accessList: tx.AccessList, checkNonce: true, + l1CostGas: tx.RollupCostData(), }   if !rules.IsBerlin { @@ -435,6 +436,9 @@ }   var err error msg.from, err = tx.Sender(s) + if err != nil { + return msg, err + } return msg, err }   @@ -518,3 +522,7 @@ } tx.from.Store(addr) return addr, nil } + +func (tx *AccessListTx) RollupCostData() types2.RollupCostData { + return tx.computeRollupGas(tx) +}

diff --git erigontech/erigon/core/types/dynamic_fee_tx.go testinprod-io/erigon/core/types/dynamic_fee_tx.go index 96c30846b638d0fb3d84b942eb42708506a8234d..2cfe265bcd79be8b1ff2aead529ae80f2f8cbb8e 100644 --- erigontech/erigon/core/types/dynamic_fee_tx.go +++ testinprod-io/erigon/core/types/dynamic_fee_tx.go @@ -358,6 +358,7 @@ amount: *tx.Value, data: tx.Data, accessList: tx.AccessList, checkNonce: true, + l1CostGas: tx.RollupCostData(), } if !rules.IsLondon { return msg, errors.New("eip-1559 transactions require London") @@ -375,6 +376,9 @@ }   var err error msg.from, err = tx.Sender(s) + if err != nil { + return msg, err + } return msg, err }   @@ -456,3 +460,9 @@ Tip: gasTip, FeeCap: gasFeeCap, } } + +func (tx *DynamicFeeTransaction) IsDepositTx() bool { return false } + +func (tx *DynamicFeeTransaction) RollupCostData() types2.RollupCostData { + return tx.computeRollupGas(tx) +}

diff --git erigontech/erigon/core/types/legacy_tx.go testinprod-io/erigon/core/types/legacy_tx.go index 4bf4c3d5f4e1300f9f12167405e93a401c668596..c85ceed1cc29505358891848d721add39aecf5ef 100644 --- erigontech/erigon/core/types/legacy_tx.go +++ testinprod-io/erigon/core/types/legacy_tx.go @@ -352,10 +352,14 @@ amount: *tx.Value, data: tx.Data, accessList: nil, checkNonce: true, + l1CostGas: tx.RollupCostData(), }   var err error msg.from, err = tx.Sender(s) + if err != nil { + return msg, err + } return msg, err }   @@ -444,3 +448,9 @@ } tx.from.Store(addr) return addr, nil } + +func (tx *LegacyTx) IsDepositTx() bool { return false } + +func (tx *LegacyTx) RollupCostData() types2.RollupCostData { + return tx.computeRollupGas(tx) +}

diff --git erigontech/erigon/core/types/transaction.go testinprod-io/erigon/core/types/transaction.go index fb781275283e24067ffc25e6876fd2a464c3d7ea..4a823b0a38ed6790a8f4724826d167a8794c1fd3 100644 --- erigontech/erigon/core/types/transaction.go +++ testinprod-io/erigon/core/types/transaction.go @@ -31,6 +31,7 @@ "github.com/ledgerwatch/erigon-lib/chain" libcommon "github.com/ledgerwatch/erigon-lib/common" "github.com/ledgerwatch/erigon-lib/common/fixedgas" + fastlz "github.com/ledgerwatch/erigon-lib/fastlz" types2 "github.com/ledgerwatch/erigon-lib/types"   "github.com/ledgerwatch/erigon/common/math" @@ -51,6 +52,7 @@ LegacyTxType = iota AccessListTxType DynamicFeeTxType BlobTxType + DepositTxType = 0x7E )   // Transaction is an Ethereum transaction. @@ -90,7 +92,8 @@ Sender(Signer) (libcommon.Address, error) GetSender() (libcommon.Address, bool) SetSender(libcommon.Address) IsContractDeploy() bool - Unwrap() Transaction // If this is a network wrapper, returns the unwrapped tx. Otherwise returns itself. + RollupCostData() types2.RollupCostData + Unwrap() Transaction // If this is a network wrapper, returns the unwrapped tx. Otherwiwes returns itself. }   // TransactionMisc is collection of miscellaneous fields for transaction that is supposed to be embedded into concrete @@ -99,6 +102,53 @@ type TransactionMisc struct { // caches hash atomic.Value //nolint:structcheck from atomic.Value + + // cache how much gas the tx takes on L1 for its share of rollup data + rollupGas atomic.Pointer[types2.RollupCostData] +} + +type rollupGasCounter struct { + zeroes uint64 + ones uint64 + fastLzSize uint64 +} + +func (r *rollupGasCounter) Write(p []byte) (int, error) { + for _, byt := range p { + if byt == 0 { + r.zeroes++ + } else { + r.ones++ + } + } + r.fastLzSize = uint64(fastlz.FlzCompressLen(p)) + return len(p), nil +} + +// computeRollupGas is a helper method to compute and cache the rollup gas cost for any tx type +func (tm *TransactionMisc) computeRollupGas(tx interface { + MarshalBinary(w io.Writer) error + Type() byte +}) types2.RollupCostData { + if tx.Type() == DepositTxType { + return types2.RollupCostData{} + } + if v := tm.rollupGas.Load(); v != nil { + return *v + } + var c rollupGasCounter + var buf bytes.Buffer + err := tx.MarshalBinary(&buf) + 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) + } + _, err = c.Write(buf.Bytes()) + if err != nil { + log.Error("failed to compute rollup cost data", "err", err) + } + total := types2.RollupCostData{Zeroes: c.zeroes, Ones: c.ones, FastLzSize: c.fastLzSize} + tm.rollupGas.Store(&total) + return total }   // RLP-marshalled legacy transactions and binary-marshalled (not wrapped into an RLP string) typed (EIP-2718) transactions @@ -181,6 +231,13 @@ } return t, nil case DynamicFeeTxType: t := &DynamicFeeTransaction{} + if err := t.DecodeRLP(s); err != nil { + return nil, err + } + return t, nil + case DepositTxType: + s := rlp.NewStream(bytes.NewReader(data[1:]), uint64(len(data)-1)) + t := &DepositTx{} if err := t.DecodeRLP(s); err != nil { return nil, err } @@ -406,11 +463,17 @@ accessList types2.AccessList checkNonce bool isFree bool blobHashes []libcommon.Hash + isFake bool + + isSystemTx bool + isDepositTx bool + mint *uint256.Int + l1CostGas types2.RollupCostData }   func NewMessage(from libcommon.Address, to *libcommon.Address, nonce uint64, amount *uint256.Int, gasLimit uint64, gasPrice *uint256.Int, feeCap, tip *uint256.Int, data []byte, accessList types2.AccessList, checkNonce bool, - isFree bool, maxFeePerBlobGas *uint256.Int, + isFree bool, isFake bool, maxFeePerBlobGas *uint256.Int, ) Message { m := Message{ from: from, @@ -422,6 +485,7 @@ data: data, accessList: accessList, checkNonce: checkNonce, isFree: isFree, + isFake: isFake, } if gasPrice != nil { m.gasPrice.Set(gasPrice) @@ -456,6 +520,7 @@ func (m Message) IsFree() bool { return m.isFree } func (m *Message) SetIsFree(isFree bool) { m.isFree = isFree } +func (m Message) IsFake() bool { return m.isFake }   func (m *Message) ChangeGas(globalGasCap, desiredGas uint64) { gas := globalGasCap @@ -472,6 +537,11 @@ }   m.gasLimit = gas } + +func (m Message) IsSystemTx() bool { return m.isSystemTx } +func (m Message) IsDepositTx() bool { return m.isDepositTx } +func (m Message) Mint() *uint256.Int { return m.mint } +func (m Message) RollupCostData() types2.RollupCostData { return m.l1CostGas }   func (m Message) BlobGas() uint64 { return fixedgas.BlobGasPerBlob * uint64(len(m.blobHashes)) }

diff --git erigontech/erigon/core/vm/evmtypes/evmtypes.go testinprod-io/erigon/core/vm/evmtypes/evmtypes.go index 4b919f6b3e369e38f3e891580cee94243e642359..8856e06b368741dac613d3a727ffae8db0772ab4 100644 --- erigontech/erigon/core/vm/evmtypes/evmtypes.go +++ testinprod-io/erigon/core/vm/evmtypes/evmtypes.go @@ -7,6 +7,7 @@ "github.com/holiman/uint256"   "github.com/ledgerwatch/erigon-lib/chain" "github.com/ledgerwatch/erigon-lib/common" + "github.com/ledgerwatch/erigon-lib/opstack" types2 "github.com/ledgerwatch/erigon-lib/types"   "github.com/ledgerwatch/erigon/core/types" @@ -33,6 +34,9 @@ Difficulty *big.Int // Provides information for DIFFICULTY BaseFee *uint256.Int // Provides information for BASEFEE PrevRanDao *common.Hash // Provides information for PREVRANDAO ExcessBlobGas *uint64 // Provides information for handling data blobs + + // L1CostFunc returns the L1 cost of the rollup message, the function may be nil, or return nil + L1CostFunc opstack.L1CostFunc }   // TxContext provides the EVM with information about a transaction.

diff --git erigontech/erigon/erigon-lib/opstack/rollup_cost.go testinprod-io/erigon/erigon-lib/opstack/rollup_cost.go new file mode 100644 index 0000000000000000000000000000000000000000..a82b3e4f00a4a22e9b3c05ac2aa6bc4a8e19f161 --- /dev/null +++ testinprod-io/erigon/erigon-lib/opstack/rollup_cost.go @@ -0,0 +1,444 @@ +// 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/>. + +// This file implements OP stack L1 cost calculation, based on op-geth +// https://github.com/ethereum-optimism/op-geth/commit/a290ca164a36c80a8d106d88bd482b6f82220bef + +package opstack + +import ( + "bytes" + "encoding/binary" + "fmt" + "math/big" + + "github.com/holiman/uint256" + "github.com/ledgerwatch/erigon-lib/chain" + libcommon "github.com/ledgerwatch/erigon-lib/common" + "github.com/ledgerwatch/erigon-lib/common/fixedgas" + "github.com/ledgerwatch/erigon-lib/types" + "github.com/ledgerwatch/log/v3" +) + +const ( + // The two 4-byte Ecotone fee scalar values are packed into the same storage slot as the 8-byte + // sequence number and have the following Solidity offsets within the slot. Note that Solidity + // offsets correspond to the last byte of the value in the slot, counting backwards from the + // end of the slot. For example, The 8-byte sequence number has offset 0, and is therefore + // stored as big-endian format in bytes [24:32) of the slot. + BaseFeeScalarSlotOffset = 12 // bytes [16:20) of the slot + BlobBaseFeeScalarSlotOffset = 8 // bytes [20:24) of the slot + + // scalarSectionStart is the beginning of the scalar values segment in the slot + // array. baseFeeScalar is in the first four bytes of the segment, blobBaseFeeScalar the next + // four. + scalarSectionStart = 32 - BaseFeeScalarSlotOffset - 4 + + PreEcotoneL1InfoBytes = 4 + 32*8 + PostEcotoneL1InfoBytes = 164 +) + +func init() { + if BlobBaseFeeScalarSlotOffset != BaseFeeScalarSlotOffset-4 { + panic("this code assumes the scalars are at adjacent positions in the scalars slot") + } +} + +var ( + // BedrockL1AttributesSelector is the function selector indicating Bedrock style L1 gas + // attributes. + BedrockL1AttributesSelector = []byte{0x01, 0x5d, 0x8e, 0xb9} + // EcotoneL1AttributesSelector is the selector indicating Ecotone style L1 gas attributes. + EcotoneL1AttributesSelector = []byte{0x44, 0x0a, 0x5e, 0x20} + + // L1BlockAddr is the address of the L1Block contract which stores the L1 gas attributes. + L1BlockAddr = libcommon.HexToAddress("0x4200000000000000000000000000000000000015") + + L1BaseFeeSlot = libcommon.BigToHash(big.NewInt(1)) + OverheadSlot = libcommon.BigToHash(big.NewInt(5)) + ScalarSlot = libcommon.BigToHash(big.NewInt(6)) + + // L1BlobBaseFeeSlot was added with the Ecotone upgrade and stores the blobBaseFee L1 gas + // attribute. + L1BlobBaseFeeSlot = libcommon.BigToHash(big.NewInt(7)) + // L1FeeScalarsSlot as of the Ecotone upgrade stores the 32-bit baseFeeScalar and + // blobBaseFeeScalar L1 gas attributes at offsets `BaseFeeScalarSlotOffset` and + // `BlobBaseFeeScalarSlotOffset` respectively. + L1FeeScalarsSlot = libcommon.BigToHash(big.NewInt(3)) + + oneMillion = uint256.NewInt(1_000_000) + ecotoneDivisor = uint256.NewInt(1_000_000 * 16) + fjordDivisor = uint256.NewInt(1_000_000_000_000) + sixteen = uint256.NewInt(16) + + // Do not use L1CostIntercept because it is negative and not fits in uint256 + L1CostInterceptNeg = uint256.NewInt(42_585_600) + L1CostFastlzCoef = uint256.NewInt(836_500) + + MinTransactionSize = uint256.NewInt(100) + MinTransactionSizeScaled = new(uint256.Int).Mul(MinTransactionSize, uint256.NewInt(1e6)) + + emptyScalars = make([]byte, 8) +) + +type StateGetter interface { + GetState(addr libcommon.Address, key *libcommon.Hash, value *uint256.Int) +} + +// L1CostFunc is used in the state transition to determine the data availability fee charged to the +// sender of non-Deposit transactions. It returns nil if no data availability fee is charged. +type L1CostFunc func(rcd types.RollupCostData, blockTime uint64) *uint256.Int + +// l1CostFunc is an internal version of L1CostFunc that also returns the gasUsed for use in +// receipts. +type l1CostFunc func(rcd types.RollupCostData) (fee, gasUsed *uint256.Int) + +// NewL1CostFunc returns a function used for calculating data availability fees, or nil if this is +// not an op-stack chain. +func NewL1CostFunc(config *chain.Config, statedb StateGetter) L1CostFunc { + if config.Optimism == nil { + return nil + } + forBlock := ^uint64(0) + var cachedFunc l1CostFunc + selectFunc := func(blockTime uint64) l1CostFunc { + if !config.IsOptimismEcotone(blockTime) { + return newL1CostFuncPreEcotone(config, statedb, blockTime) + } + + // Note: the various state variables below are not initialized from the DB until this + // point to allow deposit transactions from the block to be processed first by state + // transition. This behavior is consensus critical! + var l1FeeScalarsInt, l1BlobBaseFee, l1BaseFee uint256.Int + statedb.GetState(L1BlockAddr, &L1FeeScalarsSlot, &l1FeeScalarsInt) + l1FeeScalars := l1FeeScalarsInt.Bytes32() + statedb.GetState(L1BlockAddr, &L1BlobBaseFeeSlot, &l1BlobBaseFee) + statedb.GetState(L1BlockAddr, &L1BaseFeeSlot, &l1BaseFee) + + // Edge case: the very first Ecotone block requires we use the Bedrock cost + // function. We detect this scenario by checking if the Ecotone parameters are + // unset. Note here we rely on assumption that the scalar parameters are adjacent + // in the buffer and l1BaseFeeScalar comes first. We need to check this prior to + // other forks, as the first block of Fjord and Ecotone could be the same block. + firstEcotoneBlock := l1BlobBaseFee.BitLen() == 0 && + bytes.Equal(emptyScalars, l1FeeScalars[scalarSectionStart:scalarSectionStart+8]) + if firstEcotoneBlock { + log.Info("using pre-ecotone l1 cost func for first Ecotone block", "time", blockTime) + return newL1CostFuncPreEcotone(config, statedb, blockTime) + } + + l1BaseFeeScalar, l1BlobBaseFeeScalar := extractEcotoneFeeParams(l1FeeScalars[:]) + + if config.IsOptimismFjord(blockTime) { + return NewL1CostFuncFjord( + &l1BaseFee, + &l1BlobBaseFee, + l1BaseFeeScalar, + l1BlobBaseFeeScalar, + ) + } else { + return newL1CostFuncEcotone(&l1BaseFee, &l1BlobBaseFee, l1BaseFeeScalar, l1BlobBaseFeeScalar) + } + } + + return func(rollupCostData types.RollupCostData, blockTime uint64) *uint256.Int { + if rollupCostData == (types.RollupCostData{}) { + return nil // Do not charge if there is no rollup cost-data (e.g. RPC call or deposit). + } + if forBlock != blockTime { + cachedFunc = selectFunc(blockTime) + } + fee, _ := cachedFunc(rollupCostData) + return fee + } +} + +// newL1CostFuncPreEcotone returns an L1 cost function suitable for Bedrock, Regolith, and the first +// block only of the Ecotone upgrade. +func newL1CostFuncPreEcotone(config *chain.Config, statedb StateGetter, blockTime uint64) l1CostFunc { + var l1BaseFee, overhead, scalar uint256.Int + statedb.GetState(L1BlockAddr, &L1BaseFeeSlot, &l1BaseFee) + statedb.GetState(L1BlockAddr, &OverheadSlot, &overhead) + statedb.GetState(L1BlockAddr, &ScalarSlot, &scalar) + isRegolith := config.IsRegolith(blockTime) + return newL1CostFuncPreEcotoneHelper(&l1BaseFee, &overhead, &scalar, isRegolith) +} + +// newL1CostFuncPreEcotoneHelper is lower level version of newL1CostFuncPreEcotone that expects already +// extracted parameters +func newL1CostFuncPreEcotoneHelper(l1BaseFee, overhead, scalar *uint256.Int, isRegolith bool) l1CostFunc { + return func(rollupCostData types.RollupCostData) (fee, gasUsed *uint256.Int) { + if rollupCostData == (types.RollupCostData{}) { + return nil, nil // Do not charge if there is no rollup cost-data (e.g. RPC call or deposit) + } + gas := rollupCostData.Zeroes * fixedgas.TxDataZeroGas + if isRegolith { + gas += rollupCostData.Ones * fixedgas.TxDataNonZeroGasEIP2028 + } else { + gas += (rollupCostData.Ones + 68) * fixedgas.TxDataNonZeroGasEIP2028 + } + gasWithOverhead := uint256.NewInt(gas) + gasWithOverhead.Add(gasWithOverhead, overhead) + l1Cost := l1CostPreEcotoneHelper(gasWithOverhead, l1BaseFee, scalar) + return l1Cost, gasWithOverhead + } +} + +// newL1CostFuncEcotone returns an l1 cost function suitable for the Ecotone upgrade except for the +// very first block of the upgrade. +func newL1CostFuncEcotone(l1BaseFee, l1BlobBaseFee, l1BaseFeeScalar, l1BlobBaseFeeScalar *uint256.Int) l1CostFunc { + return func(costData types.RollupCostData) (fee, calldataGasUsed *uint256.Int) { + calldataGasUsed = bedrockCalldataGasUsed(costData) + + // Ecotone L1 cost function: + // + // (calldataGas/16)*(l1BaseFee*16*l1BaseFeeScalar + l1BlobBaseFee*l1BlobBaseFeeScalar)/1e6 + // + // We divide "calldataGas" by 16 to change from units of calldata gas to "estimated # of bytes when + // compressed". Known as "compressedTxSize" in the spec. + // + // Function is actually computed as follows for better precision under integer arithmetic: + // + // calldataGas*(l1BaseFee*16*l1BaseFeeScalar + l1BlobBaseFee*l1BlobBaseFeeScalar)/16e6 + + calldataCostPerByte := new(uint256.Int).Set(l1BaseFee) + calldataCostPerByte = calldataCostPerByte.Mul(calldataCostPerByte, sixteen) + calldataCostPerByte = calldataCostPerByte.Mul(calldataCostPerByte, l1BaseFeeScalar) + + blobCostPerByte := new(uint256.Int).Set(l1BlobBaseFee) + blobCostPerByte = blobCostPerByte.Mul(blobCostPerByte, l1BlobBaseFeeScalar) + + fee = new(uint256.Int).Add(calldataCostPerByte, blobCostPerByte) + fee = fee.Mul(fee, calldataGasUsed) + fee = fee.Div(fee, ecotoneDivisor) + + return fee, calldataGasUsed + } +} + +// extractL1GasParams extracts the gas parameters necessary to compute gas costs from L1 block info +func ExtractL1GasParams(config *chain.Config, time uint64, data []byte) (gasParams, error) { + // edge case: for the very first Ecotone block we still need to use the Bedrock + // function. We detect this edge case by seeing if the function selector is the old one + // If so, fall through to the pre-ecotone format + // Both Ecotone and Fjord use the same function selector + if config.IsEcotone(time) && len(data) >= 4 && !bytes.Equal(data[0:4], BedrockL1AttributesSelector) { + p, err := extractL1GasParamsPostEcotone(data) + if err != nil { + return gasParams{}, err + } + + if config.IsFjord(time) { + p.CostFunc = NewL1CostFuncFjord( + p.L1BaseFee, + p.L1BlobBaseFee, + new(uint256.Int).SetUint64(uint64(*p.L1BaseFeeScalar)), + new(uint256.Int).SetUint64(uint64(*p.L1BlobBaseFeeScalar)), + ) + } else { + p.CostFunc = newL1CostFuncEcotone( + p.L1BaseFee, + p.L1BlobBaseFee, + new(uint256.Int).SetUint64(uint64(*p.L1BaseFeeScalar)), + new(uint256.Int).SetUint64(uint64(*p.L1BlobBaseFeeScalar)), + ) + } + return p, nil + } + return extractL1GasParamsPreEcotone(config, time, data) +} + +func extractL1InfoPreEcotone(data []byte) (l1BaseFee, overhead, scalar *uint256.Int, feeScalar *big.Float, err error) { + // data consists of func selector followed by 7 ABI-encoded parameters (32 bytes each) + if len(data) < PreEcotoneL1InfoBytes { + return nil, nil, nil, nil, fmt.Errorf("expected at least %d L1 info bytes, got %d", PreEcotoneL1InfoBytes, len(data)) + } + data = data[4:] // trim function selector + l1BaseFee = new(uint256.Int).SetBytes(data[32*2 : 32*3]) // arg index 2 + overhead = new(uint256.Int).SetBytes(data[32*6 : 32*7]) // arg index 6 + scalar = new(uint256.Int).SetBytes(data[32*7 : 32*8]) // arg index 7 + feeScalar = intToScaledFloat(scalar) // legacy: format fee scalar as big Float + return +} + +func extractL1GasParamsPreEcotone(config *chain.Config, time uint64, data []byte) (gasParams, error) { + l1BaseFee, overhead, scalar, feeScalar, err := extractL1InfoPreEcotone(data) + if err != nil { + return gasParams{}, err + } + costFunc := newL1CostFuncPreEcotoneHelper(l1BaseFee, overhead, scalar, config.IsRegolith(time)) + return gasParams{ + L1BaseFee: l1BaseFee, + CostFunc: costFunc, + FeeScalar: feeScalar, + }, nil +} + +func extractL1InfoPostEcotone(data []byte) (l1BaseFee, l1BlobBaseFee *uint256.Int, l1BaseFeeScalar, l1BlobBaseFeeScalar uint32, err error) { + if len(data) != PostEcotoneL1InfoBytes { + return nil, nil, 0, 0, fmt.Errorf("expected 164 L1 info bytes, got %d", len(data)) + } + // data layout assumed for Ecotone: + // offset type varname + // 0 <selector> + // 4 uint32 _baseFeeScalar + // 8 uint32 _blobBaseFeeScalar + // 12 uint64 _sequenceNumber, + // 20 uint64 _timestamp, + // 28 uint64 _l1BlockNumber + // 36 uint256 _baseFee, + // 68 uint256 _blobBaseFee, + // 100 bytes32 _hash, + // 132 bytes32 _batcherHash, + l1BaseFee = new(uint256.Int).SetBytes(data[36:68]) + l1BlobBaseFee = new(uint256.Int).SetBytes(data[68:100]) + l1BaseFeeScalar = binary.BigEndian.Uint32(data[4:8]) + l1BlobBaseFeeScalar = binary.BigEndian.Uint32(data[8:12]) + return +} + +// extractL1GasParamsPostEcotone extracts the gas parameters necessary to compute gas from L1 attribute +// info calldata after the Ecotone upgrade, but not for the very first Ecotone block. +func extractL1GasParamsPostEcotone(data []byte) (gasParams, error) { + l1BaseFee, l1BlobBaseFee, l1BaseFeeScalar, l1BlobBaseFeeScalar, err := extractL1InfoPostEcotone(data) + if err != nil { + return gasParams{}, err + } + return gasParams{ + L1BaseFee: l1BaseFee, + L1BlobBaseFee: l1BlobBaseFee, + L1BaseFeeScalar: &l1BaseFeeScalar, + L1BlobBaseFeeScalar: &l1BlobBaseFeeScalar, + }, nil +} + +type gasParams struct { + L1BaseFee *uint256.Int + L1BlobBaseFee *uint256.Int + CostFunc l1CostFunc + FeeScalar *big.Float // pre-ecotone + L1BaseFeeScalar *uint32 // post-ecotone + L1BlobBaseFeeScalar *uint32 // post-ecotone +} + +// intToScaledFloat returns scalar/10e6 as a float +func intToScaledFloat(scalar *uint256.Int) *big.Float { + fscalar := new(big.Float).SetInt(scalar.ToBig()) + fdivisor := new(big.Float).SetUint64(1_000_000) // 10**6, i.e. 6 decimals + return new(big.Float).Quo(fscalar, fdivisor) +} + +// L1CostPreEcotone computes the the data availability fee for transactions in blocks prior to the Ecotone +// upgrade. It is used by e2e tests so must remain exported. +func L1CostPreEcotone(rollupDataGas uint64, l1BaseFee, overhead, scalar *uint256.Int) *uint256.Int { + l1GasUsed := uint256.NewInt(rollupDataGas) + l1GasUsed.Add(l1GasUsed, overhead) + return l1CostPreEcotoneHelper(l1GasUsed, l1BaseFee, scalar) +} + +func l1CostPreEcotoneHelper(gasWithOverhead, l1BaseFee, scalar *uint256.Int) *uint256.Int { + fee := new(uint256.Int).Set(gasWithOverhead) + fee.Mul(fee, l1BaseFee).Mul(fee, scalar).Div(fee, oneMillion) + return fee +} + +func L1CostFnForTxPool(data []byte, isRegolith, isEcotone, isFjord bool) (types.L1CostFn, error) { + var costFunc l1CostFunc = nil + if isEcotone && len(data) >= 4 && !bytes.Equal(data[0:4], BedrockL1AttributesSelector) { + l1BaseFee, l1BlobBaseFee, l1BaseFeeScalar, l1BlobBaseFeeScalar, err := extractL1InfoPostEcotone(data) + if err != nil { + return nil, fmt.Errorf("L1CostFnForTxPool error: %w", err) + } + if isFjord { + costFunc = NewL1CostFuncFjord( + l1BaseFee, + l1BlobBaseFee, + new(uint256.Int).SetUint64(uint64(l1BaseFeeScalar)), + new(uint256.Int).SetUint64(uint64(l1BlobBaseFeeScalar)), + ) + } else { + costFunc = newL1CostFuncEcotone( + l1BaseFee, + l1BlobBaseFee, + new(uint256.Int).SetUint64(uint64(l1BaseFeeScalar)), + new(uint256.Int).SetUint64(uint64(l1BlobBaseFeeScalar)), + ) + } + } + if costFunc == nil { + l1BaseFee, overhead, scalar, _, err := extractL1InfoPreEcotone(data) + if err != nil { + return nil, fmt.Errorf("L1CostFnForTxPool error: %w", err) + } + costFunc = newL1CostFuncPreEcotoneHelper(l1BaseFee, overhead, scalar, isRegolith) + } + return func(tx *types.TxSlot) *uint256.Int { + fee, _ := costFunc(tx.RollupCostData) + return fee + }, nil +} + +// NewL1CostFuncFjord returns an l1 cost function suitable for the Fjord upgrade +func NewL1CostFuncFjord(l1BaseFee, l1BlobBaseFee, baseFeeScalar, blobFeeScalar *uint256.Int) l1CostFunc { + return func(costData types.RollupCostData) (fee, calldataGasUsed *uint256.Int) { + // Fjord L1 cost function: + //l1FeeScaled = baseFeeScalar*l1BaseFee*16 + blobFeeScalar*l1BlobBaseFee + //estimatedSize = max(minTransactionSize, intercept + fastlzCoef*fastlzSize) + //l1Cost = estimatedSize * l1FeeScaled / 1e12 + + scaledL1BaseFee := new(uint256.Int).Mul(baseFeeScalar, l1BaseFee) + calldataCostPerByte := new(uint256.Int).Mul(scaledL1BaseFee, sixteen) + blobCostPerByte := new(uint256.Int).Mul(blobFeeScalar, l1BlobBaseFee) + l1FeeScaled := new(uint256.Int).Add(calldataCostPerByte, blobCostPerByte) + + fastLzSize := new(uint256.Int).SetUint64(costData.FastLzSize) + + // Check L1CostIntercept + L1CostFastlzCoef * fastLzSize >= 0, or + // L1CostFastlzCoef * fastLzSize >= L1CostInterceptNeg + estimatedSize := new(uint256.Int) + temp := new(uint256.Int).Mul(L1CostFastlzCoef, fastLzSize) + if temp.Cmp(L1CostInterceptNeg) < 0 { + // estimatedSize is negative. fall back to MinTransactionSizeScaled + estimatedSize.Set(MinTransactionSizeScaled) + } else { + // we can safely evaulate avoiding underflow + estimatedSize = new(uint256.Int).Sub(temp, L1CostInterceptNeg) + if estimatedSize.Cmp(MinTransactionSizeScaled) < 0 { + estimatedSize.Set(MinTransactionSizeScaled) + } + } + + l1CostScaled := new(uint256.Int).Mul(estimatedSize, l1FeeScaled) + l1Cost := new(uint256.Int).Div(l1CostScaled, fjordDivisor) + + calldataGasUsed = new(uint256.Int).Mul(estimatedSize, new(uint256.Int).SetUint64(fixedgas.TxDataNonZeroGasEIP2028)) + calldataGasUsed.Div(calldataGasUsed, uint256.NewInt(1e6)) + + return l1Cost, calldataGasUsed + } +} + +func extractEcotoneFeeParams(l1FeeParams []byte) (l1BaseFeeScalar, l1BlobBaseFeeScalar *uint256.Int) { + offset := scalarSectionStart + l1BaseFeeScalar = new(uint256.Int).SetBytes(l1FeeParams[offset : offset+4]) + l1BlobBaseFeeScalar = new(uint256.Int).SetBytes(l1FeeParams[offset+4 : offset+8]) + return +} + +func bedrockCalldataGasUsed(costData types.RollupCostData) (calldataGasUsed *uint256.Int) { + calldataGas := (costData.Zeroes * fixedgas.TxDataZeroGas) + (costData.Ones * fixedgas.TxDataNonZeroGasEIP2028) + return new(uint256.Int).SetUint64(calldataGas) +}

diff --git erigontech/erigon/turbo/jsonrpc/eth_callMany.go testinprod-io/erigon/turbo/jsonrpc/eth_callMany.go index c40f0ca68d64f3839e87738e4f98dbf3ee515196..df5c7f687b0dec1ce2dfc11c51e62d4ee4d6079d 100644 --- erigontech/erigon/turbo/jsonrpc/eth_callMany.go +++ testinprod-io/erigon/turbo/jsonrpc/eth_callMany.go @@ -4,6 +4,7 @@ import ( "context" "encoding/hex" "fmt" + "github.com/ledgerwatch/erigon-lib/opstack" "math/big" "time"   @@ -156,6 +157,7 @@ return hash }   blockCtx = core.NewEVMBlockContext(header, getHash, api.engine(), nil /* author */) + blockCtx.L1CostFunc = opstack.NewL1CostFunc(chainConfig, st)   // Get a new instance of the EVM evm = vm.NewEVM(blockCtx, txCtx, st, chainConfig, vm.Config{Debug: false})

diff --git erigontech/erigon/turbo/jsonrpc/trace_adhoc.go testinprod-io/erigon/turbo/jsonrpc/trace_adhoc.go index 99f7d259932235205e539e59d8d4a9adec441872..f262ac42f12ad9d1f1054116da0858c7e4bc8ca7 100644 --- erigontech/erigon/turbo/jsonrpc/trace_adhoc.go +++ testinprod-io/erigon/turbo/jsonrpc/trace_adhoc.go @@ -15,6 +15,7 @@ libcommon "github.com/ledgerwatch/erigon-lib/common" "github.com/ledgerwatch/erigon-lib/common/hexutil" "github.com/ledgerwatch/erigon-lib/common/hexutility" "github.com/ledgerwatch/erigon-lib/kv" + "github.com/ledgerwatch/erigon-lib/opstack" types2 "github.com/ledgerwatch/erigon-lib/types" math2 "github.com/ledgerwatch/erigon/common/math" "github.com/ledgerwatch/erigon/core" @@ -221,7 +222,7 @@ var accessList types2.AccessList if args.AccessList != nil { accessList = *args.AccessList } - msg := types.NewMessage(addr, args.To, 0, value, gas, gasPrice, gasFeeCap, gasTipCap, data, accessList, false /* checkNonce */, false /* isFree */, maxFeePerBlobGas) + msg := types.NewMessage(addr, args.To, 0, value, gas, gasPrice, gasFeeCap, gasTipCap, data, accessList, false /* checkNonce */, false /* isFree */, true /* isFake */, maxFeePerBlobGas) return msg, nil }   @@ -1004,6 +1005,7 @@ txCtx := core.NewEVMTxContext(msg)   blockCtx.GasLimit = math.MaxUint64 blockCtx.MaxGasLimit = true + blockCtx.L1CostFunc = opstack.NewL1CostFunc(chainConfig, ibs)   evm := vm.NewEVM(blockCtx, txCtx, ibs, chainConfig, vm.Config{Debug: traceTypeTrace, Tracer: &ot})   @@ -1188,6 +1190,7 @@ header = parentHeader useParent = true }   + l1CostFunc := opstack.NewL1CostFunc(chainConfig, ibs) for txIndex, msg := range msgs { if err := libcommon.Stopped(ctx.Done()); err != nil { return nil, nil, err @@ -1234,6 +1237,7 @@ if useParent { blockCtx.GasLimit = math.MaxUint64 blockCtx.MaxGasLimit = true } + blockCtx.L1CostFunc = l1CostFunc   // Clone the state cache before applying the changes for diff after transaction execution, clone is discarded var cloneReader state.StateReader

diff --git erigontech/erigon/turbo/jsonrpc/trace_filtering.go testinprod-io/erigon/turbo/jsonrpc/trace_filtering.go index 29dd9d22852865ddc0a0f8dea3cb581eb625ee32..fb4cb755bce920bcdf5e61c09f35b92a373ff9bc 100644 --- erigontech/erigon/turbo/jsonrpc/trace_filtering.go +++ testinprod-io/erigon/turbo/jsonrpc/trace_filtering.go @@ -4,6 +4,7 @@ import ( "context" "errors" "fmt" + "github.com/ledgerwatch/erigon-lib/opstack"   "github.com/RoaringBitmap/roaring/roaring64" jsoniter "github.com/json-iterator/go" @@ -788,6 +789,7 @@ ibs := state.New(cachedReader)   blockCtx := transactions.NewEVMBlockContext(engine, lastHeader, true /* requireCanonical */, dbtx, api._blockReader) txCtx := core.NewEVMTxContext(msg) + blockCtx.L1CostFunc = opstack.NewL1CostFunc(chainConfig, ibs) evm := vm.NewEVM(blockCtx, txCtx, ibs, chainConfig, vmConfig)   gp := new(core.GasPool).AddGas(msg.Gas()).AddBlobGas(msg.BlobGas())

diff --git erigontech/erigon/turbo/jsonrpc/tracing.go testinprod-io/erigon/turbo/jsonrpc/tracing.go index 5a884a01b20accbcfff9886c06bf4f072628c5df..11b7b80f97c0d19db392391cb503b3c2ebc2ce87 100644 --- erigontech/erigon/turbo/jsonrpc/tracing.go +++ testinprod-io/erigon/turbo/jsonrpc/tracing.go @@ -2,6 +2,8 @@ package jsonrpc   import ( "context" + "encoding/json" + "errors" "fmt" "time"   @@ -11,6 +13,7 @@ "github.com/ledgerwatch/log/v3"   "github.com/ledgerwatch/erigon-lib/common" "github.com/ledgerwatch/erigon-lib/common/hexutil" + "github.com/ledgerwatch/erigon-lib/opstack"   "github.com/ledgerwatch/erigon/common/math" "github.com/ledgerwatch/erigon/core" @@ -58,6 +61,30 @@ } if block == nil { stream.WriteNil() return fmt.Errorf("invalid arguments; block with hash %x not found", hash) + } + + chainConfig, err := api.chainConfig(ctx, tx) + if err != nil { + stream.WriteNil() + return err + } + + if chainConfig.IsOptimismPreBedrock(block.NumberU64()) { + if api.historicalRPCService == nil { + return rpc.ErrNoHistoricalFallback + } + var traceResult interface{} + // relay using block hash + if err := api.relayToHistoricalBackend(ctx, &traceResult, "debug_traceBlockByHash", block.Hash(), config); err != nil { + return fmt.Errorf("historical backend error: %w", err) + } + // stream out relayed response + result, err := json.Marshal(&traceResult) + if err != nil { + return err + } + stream.WriteRaw(string(result)) + return nil }   // if we've pruned this history away for this block then just return early @@ -77,11 +104,6 @@ var disabled bool config.BorTraceEnabled = &disabled }   - chainConfig, err := api.chainConfig(ctx, tx) - if err != nil { - stream.WriteNil() - return err - } engine := api.engine()   _, blockCtx, _, ibs, _, err := transactions.ComputeTxEnv(ctx, engine, block, chainConfig, api._blockReader, tx, 0, api.historyV3(tx)) @@ -237,6 +259,22 @@ }   isBorStateSyncTxn = true } + if chainConfig.IsOptimismPreBedrock(blockNum) { + if api.historicalRPCService == nil { + return rpc.ErrNoHistoricalFallback + } + var traceResult interface{} + if err := api.relayToHistoricalBackend(ctx, &traceResult, "debug_traceTransaction", hash, config); err != nil { + return fmt.Errorf("historical backend error: %w", err) + } + // stream out relayed response + result, err := json.Marshal(traceResult) + if err != nil { + return err + } + stream.WriteRaw(string(result)) + return nil + }   // check pruning to ensure we have history at this block level err = api.BaseAPI.checkPruneHistory(tx, blockNum) @@ -319,6 +357,10 @@ if err != nil { return fmt.Errorf("get block number: %v", err) }   + if chainConfig.IsOptimismPreBedrock(blockNumber) { + return errors.New("l2geth does not have a debug_traceCall method") + } + err = api.BaseAPI.checkPruneHistory(dbtx, blockNumber) if err != nil { return err @@ -363,6 +405,7 @@ }   blockCtx := transactions.NewEVMBlockContext(engine, header, blockNrOrHash.RequireCanonical, dbtx, api._blockReader) txCtx := core.NewEVMTxContext(msg) + blockCtx.L1CostFunc = opstack.NewL1CostFunc(chainConfig, ibs) // Trace the transaction and return return transactions.TraceTx(ctx, msg, blockCtx, txCtx, ibs, config, chainConfig, stream, api.evmCallTimeout) } @@ -473,6 +516,7 @@ return hash }   blockCtx = core.NewEVMBlockContext(header, getHash, api.engine(), nil /* author */) + blockCtx.L1CostFunc = opstack.NewL1CostFunc(chainConfig, st) // Get a new instance of the EVM evm = vm.NewEVM(blockCtx, txCtx, st, chainConfig, vm.Config{Debug: false}) signer := types.MakeSigner(chainConfig, blockNum, block.Time())

diff --git erigontech/erigon/turbo/transactions/call.go testinprod-io/erigon/turbo/transactions/call.go index 822f7505e4b65e3d41c9cf9d9f2978801369bbff..a447a98457d54e14cefca26cc57332e4a06ec6d4 100644 --- erigontech/erigon/turbo/transactions/call.go +++ testinprod-io/erigon/turbo/transactions/call.go @@ -11,6 +11,7 @@ "github.com/ledgerwatch/erigon-lib/chain" libcommon "github.com/ledgerwatch/erigon-lib/common" "github.com/ledgerwatch/erigon-lib/kv" + "github.com/ledgerwatch/erigon-lib/opstack"   "github.com/ledgerwatch/erigon/consensus" "github.com/ledgerwatch/erigon/core" @@ -82,6 +83,7 @@ return nil, err } blockCtx := NewEVMBlockContext(engine, header, blockNrOrHash.RequireCanonical, tx, headerReader) txCtx := core.NewEVMTxContext(msg) + blockCtx.L1CostFunc = opstack.NewL1CostFunc(chainConfig, state)   evm := vm.NewEVM(blockCtx, txCtx, state, chainConfig, vm.Config{NoBaseFee: true})   @@ -213,6 +215,7 @@ return nil, err }   blockCtx := NewEVMBlockContext(engine, header, blockNrOrHash.RequireCanonical, tx, headerReader) + blockCtx.L1CostFunc = opstack.NewL1CostFunc(chainConfig, ibs) txCtx := core.NewEVMTxContext(msg)   evm := vm.NewEVM(blockCtx, txCtx, ibs, chainConfig, vm.Config{NoBaseFee: true})

diff --git erigontech/erigon/turbo/transactions/tracing.go testinprod-io/erigon/turbo/transactions/tracing.go index b532b118335b05f8e96965830525c3ae2fd3e2b8..9f298b7aadbd0d5faa1e5eb6d10fb82f11cc7748 100644 --- erigontech/erigon/turbo/transactions/tracing.go +++ testinprod-io/erigon/turbo/transactions/tracing.go @@ -14,6 +14,8 @@ "github.com/ledgerwatch/erigon-lib/chain" libcommon "github.com/ledgerwatch/erigon-lib/common" "github.com/ledgerwatch/erigon-lib/kv" + "github.com/ledgerwatch/erigon-lib/opstack" + "github.com/ledgerwatch/erigon/consensus" "github.com/ledgerwatch/erigon/core" "github.com/ledgerwatch/erigon/core/state" @@ -55,6 +57,7 @@ } header := block.HeaderNoCopy()   blockContext := core.NewEVMBlockContext(header, core.GetHashFn(header, getHeader), engine, nil) + blockContext.L1CostFunc = opstack.NewL1CostFunc(cfg, statedb)   // Recompute transactions up to the target index. signer := types.MakeSigner(cfg, block.NumberU64(), block.Time())

diff --git erigontech/erigon/core/state_transition.go testinprod-io/erigon/core/state_transition.go index 1dd73ed42ba775a2acea1881c7cddd5350346455..9fc772db42f591ae361a7da2202a3cbbafeb9285 100644 --- erigontech/erigon/core/state_transition.go +++ testinprod-io/erigon/core/state_transition.go @@ -87,6 +87,12 @@ BlobGas() uint64 MaxFeePerBlobGas() *uint256.Int Value() *uint256.Int   + // Mint is nil if there is no minting + Mint() *uint256.Int + IsSystemTx() bool + IsDepositTx() bool + RollupCostData() types2.RollupCostData + Nonce() uint64 CheckNonce() bool Data() []byte @@ -94,6 +100,7 @@ AccessList() types2.AccessList BlobHashes() []libcommon.Hash   IsFree() bool + IsFake() bool }   // ExecutionResult includes all output after executing given evm @@ -199,6 +206,13 @@ gasVal, overflow := gasVal.MulOverflow(gasVal, st.gasPrice) if overflow { return fmt.Errorf("%w: address %v", ErrInsufficientFunds, st.msg.From().Hex()) } + var l1Cost *uint256.Int + if fn := st.evm.Context.L1CostFunc; fn != nil && !st.msg.IsFake() { + l1Cost = fn(st.msg.RollupCostData(), st.evm.Context.Time) + } + if l1Cost != nil { + gasVal = gasVal.Add(gasVal, l1Cost) + }   // compute blob fee for eip-4844 data blobs if any blobGasVal := new(uint256.Int) @@ -230,6 +244,9 @@ balanceCheck, overflow = balanceCheck.AddOverflow(balanceCheck, st.value) if overflow { return fmt.Errorf("%w: address %v", ErrInsufficientFunds, st.msg.From().Hex()) } + if l1Cost != nil { + balanceCheck.Add(balanceCheck, l1Cost) + } if st.evm.ChainRules().IsCancun { maxBlobFee, overflow := new(uint256.Int).MulOverflow(st.msg.MaxFeePerBlobGas(), new(uint256.Int).SetUint64(st.msg.BlobGas())) if overflow { @@ -278,8 +295,38 @@ }   // DESCRIBED: docs/programmers_guide/guide.md#nonce func (st *StateTransition) preCheck(gasBailout bool) error { + if st.msg.IsDepositTx() { + // Check clause 6: caller has enough balance to cover asset transfer for **topmost** call + // buyGas method originally handled balance check, but deposit tx does not use it + // Therefore explicit check required for separating consensus error and evm internal error. + // If not check it here, it will trigger evm internal error and break consensus. + if have, want := st.state.GetBalance(st.msg.From()), st.msg.Value(); have.Cmp(want) < 0 { + if !gasBailout { + return fmt.Errorf("%w: address %v have %v want %v", ErrInsufficientFunds, st.msg.From().Hex(), have, want) + } + } + // 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.Gas() + st.gasRemaining += st.msg.Gas() // 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 + } + // gas used by deposits may not be used by other txs + if err := st.gp.SubGas(st.msg.Gas()); err != nil { + if !gasBailout { + return err + } + } + return nil + } // Make sure this transaction's nonce is correct. - if st.msg.CheckNonce() { + if st.msg.CheckNonce() && !st.msg.IsFake() { stNonce := st.state.GetNonce(st.msg.From()) if msgNonce := st.msg.Nonce(); stNonce < msgNonce { return fmt.Errorf("%w: address %v, tx: %d state: %d", ErrNonceTooHigh, @@ -345,15 +392,45 @@ // // However if any consensus issue encountered, return the error directly with // nil evm execution result. func (st *StateTransition) TransitionDb(refunds bool, gasBailout bool) (*ExecutionResult, error) { - coinbase := st.evm.Context.Coinbase + if mint := st.msg.Mint(); mint != nil { + st.state.AddBalance(st.msg.From(), mint) + } + snap := st.state.Snapshot()   + result, err := st.innerTransitionDb(refunds, gasBailout) + // 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) + gasUsed := st.msg.Gas() + // 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. + 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(refunds bool, gasBailout bool) (*ExecutionResult, error) { + coinbase := st.evm.Context.Coinbase var input1 *uint256.Int var input2 *uint256.Int if st.isBor { input1 = st.state.GetBalance(st.msg.From()).Clone() input2 = st.state.GetBalance(coinbase).Clone() } - // First check this message satisfies all consensus rules before // applying the message. The rules include these clauses // @@ -425,6 +502,24 @@ // Increment the nonce for the next transaction st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1) ret, st.gasRemaining, vmerr = st.evm.Call(sender, st.to(), st.data, st.gasRemaining, st.value, bailout) } + // 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.Gas() + 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 refunds { if rules.IsLondon { // After EIP-3529: refunds are capped to gasUsed / 5 @@ -434,6 +529,14 @@ // Before EIP-3529: refunds were capped to gasUsed / 2 st.refundGas(params.RefundQuotient) } } + 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 := st.gasPrice if rules.IsLondon { if st.gasFeeCap.Gt(st.evm.Context.BaseFee) { @@ -469,6 +572,15 @@ input2, output1.Sub(output1, amount), output2.Add(output2, amount), ) + } + if optimismConfig := st.evm.ChainConfig().Optimism; optimismConfig != nil { + st.state.AddBalance(params.OptimismBaseFeeRecipient, new(uint256.Int).Mul(uint256.NewInt(st.gasUsed()), st.evm.Context.BaseFee)) + if st.evm.Context.L1CostFunc == nil { // Erigon EVM context is used in many unexpected/hacky ways, let's panic if it's misconfigured + panic("missing L1 cost func in block context, please configure l1 cost when using optimism config to run EVM") + } + if cost := st.evm.Context.L1CostFunc(st.msg.RollupCostData(), st.evm.Context.Time); cost != nil { + st.state.AddBalance(params.OptimismL1FeeRecipient, cost) + } }   return &ExecutionResult{

diff --git erigontech/erigon/consensus/misc/eip1559.go testinprod-io/erigon/consensus/misc/eip1559.go index f07e80f62363546d85ba9de561d8977d202bb46a..9d8c522f8af21caebcfa11775961be03e4fb85b8 100644 --- erigontech/erigon/consensus/misc/eip1559.go +++ testinprod-io/erigon/consensus/misc/eip1559.go @@ -40,10 +40,12 @@ if !skipGasLimit { // Verify that the gas limit remains within allowed bounds parentGasLimit := parent.GasLimit if !config.IsLondon(parent.Number.Uint64()) { - parentGasLimit = parent.GasLimit * params.ElasticityMultiplier + parentGasLimit = parent.GasLimit * config.ElasticityMultiplier(params.ElasticityMultiplier) } - if err := VerifyGaslimit(parentGasLimit, header.GasLimit); err != nil { - return err + if config.Optimism == nil { // gasLimit can adjust instantly in optimism + if err := VerifyGaslimit(parentGasLimit, header.GasLimit); err != nil { + return err + } } } // Verify the header is not malformed @@ -51,7 +53,7 @@ if header.BaseFee == nil { return fmt.Errorf("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) @@ -80,7 +82,9 @@ }   if chainConfig != nil { if currentHeader.BaseFee != nil { - baseFee = CalcBaseFee(chainConfig, currentHeader).Uint64() + // Block time of every OP superchains is 2sec for now. + // Add 2 for next block. TODO: support custom block time for OP chain + baseFee = CalcBaseFee(chainConfig, currentHeader, currentHeader.Time+2).Uint64() }   if currentHeader.ExcessBlobGas != nil { @@ -98,16 +102,16 @@ return baseFee, blobFee, minBlobGasPrice, currentHeader.GasLimit, nil }   // CalcBaseFee calculates the basefee of the header. -func CalcBaseFee(config *chain.Config, parent *types.Header) *big.Int { +func CalcBaseFee(config *chain.Config, 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.Uint64()) { return new(big.Int).SetUint64(params.InitialBaseFee) }   var ( - parentGasTarget = parent.GasLimit / params.ElasticityMultiplier + parentGasTarget = parent.GasLimit / config.ElasticityMultiplier(params.ElasticityMultiplier) parentGasTargetBig = new(big.Int).SetUint64(parentGasTarget) - baseFeeChangeDenominator = new(big.Int).SetUint64(getBaseFeeChangeDenominator(config.Bor, parent.Number.Uint64())) + baseFeeChangeDenominator = new(big.Int).SetUint64(getBaseFeeChangeDenominator(config, parent.Number.Uint64(), time)) ) // If the parent gasUsed is the same as the target, the baseFee remains unchanged. if parent.GasUsed == parentGasTarget { @@ -138,12 +142,12 @@ ) } }   -func getBaseFeeChangeDenominator(borConfig chain.BorConfig, number uint64) uint64 { +func getBaseFeeChangeDenominator(config *chain.Config, number, time uint64) uint64 { // If we're running bor based chain post delhi hardfork, return the new value - if borConfig, ok := borConfig.(*borcfg.BorConfig); ok && borConfig.IsDelhi(number) { + if borConfig, ok := config.Bor.(*borcfg.BorConfig); ok && borConfig.IsDelhi(number) { return params.BaseFeeChangeDenominatorPostDelhi }   // Return the original once for other chains and pre-fork cases - return params.BaseFeeChangeDenominator + return config.BaseFeeChangeDenominator(params.BaseFeeChangeDenominator, time) }

diff --git erigontech/erigon/core/state_processor.go testinprod-io/erigon/core/state_processor.go index c5b81a4978603bae8e9db6eb3b101b5f297167db..17ae22783a32b2c8c4fd2e5cd85328839d5dd5f2 100644 --- erigontech/erigon/core/state_processor.go +++ testinprod-io/erigon/core/state_processor.go @@ -19,6 +19,7 @@ import ( "github.com/ledgerwatch/erigon-lib/chain" libcommon "github.com/ledgerwatch/erigon-lib/common" + "github.com/ledgerwatch/erigon-lib/opstack"   "github.com/ledgerwatch/erigon/consensus" "github.com/ledgerwatch/erigon/core/state" @@ -58,6 +59,11 @@ // Update the evm with the new transaction context. evm.Reset(txContext, ibs)   + nonce := tx.GetNonce() + if msg.IsDepositTx() && config.IsOptimismRegolith(evm.Context.Time) { + nonce = ibs.GetNonce(msg.From()) + } + result, err := ApplyMessage(evm, msg, gp, true /* refunds */, false /* gasBailout */) if err != nil { return nil, nil, err @@ -84,9 +90,21 @@ receipt.Status = types.ReceiptStatusSuccessful } 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 + + if config.IsOptimismCanyon(evm.Context.Time) { + receipt.DepositReceiptVersion = new(uint64) + *receipt.DepositReceiptVersion = types.CanyonDepositReceiptVersion + } + } + // if the transaction created a contract, store the creation address in the receipt. if msg.To() == nil { - receipt.ContractAddress = crypto.CreateAddress(evm.Origin, tx.GetNonce()) + receipt.ContractAddress = crypto.CreateAddress(evm.Origin, nonce) } // Set the receipt logs and create a bloom for filtering receipt.Logs = ibs.GetLogs(tx.Hash()) @@ -113,6 +131,7 @@ // about the transaction and calling mechanisms. cfg.SkipAnalysis = SkipAnalysis(config, header.Number.Uint64())   blockContext := NewEVMBlockContext(header, blockHashFunc, engine, author) + blockContext.L1CostFunc = opstack.NewL1CostFunc(config, ibs) vmenv := vm.NewEVM(blockContext, evmtypes.TxContext{}, ibs, config, cfg)   return applyTransaction(config, engine, gp, ibs, stateWriter, header, tx, usedGas, usedBlobGas, vmenv, cfg)

diff --git erigontech/erigon/core/vm/contracts.go testinprod-io/erigon/core/vm/contracts.go index 0542a10952b912c3520d7ba9544e95343a9f9973..6ae99544348c140fa73ffef9facec8bfece10f63 100644 --- erigontech/erigon/core/vm/contracts.go +++ testinprod-io/erigon/core/vm/contracts.go @@ -115,6 +115,38 @@ libcommon.BytesToAddress([]byte{0x09}): &blake2F{}, libcommon.BytesToAddress([]byte{0x0a}): &pointEvaluation{}, }   +// PrecompiledContractsFjord contains the default set of pre-compiled Ethereum +// contracts used in the Fjord release. +var PrecompiledContractsFjord = map[libcommon.Address]PrecompiledContract{ + libcommon.BytesToAddress([]byte{1}): &ecrecover{}, + libcommon.BytesToAddress([]byte{2}): &sha256hash{}, + libcommon.BytesToAddress([]byte{3}): &ripemd160hash{}, + libcommon.BytesToAddress([]byte{4}): &dataCopy{}, + libcommon.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, + libcommon.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, + libcommon.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, + libcommon.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, + libcommon.BytesToAddress([]byte{9}): &blake2F{}, + libcommon.BytesToAddress([]byte{0x0a}): &pointEvaluation{}, + libcommon.BytesToAddress([]byte{0x01, 0x00}): &p256Verify{}, +} + +// PrecompiledContractsGranite contains the default set of pre-compiled Ethereum +// contracts used in the Granite release. +var PrecompiledContractsGranite = map[libcommon.Address]PrecompiledContract{ + libcommon.BytesToAddress([]byte{1}): &ecrecover{}, + libcommon.BytesToAddress([]byte{2}): &sha256hash{}, + libcommon.BytesToAddress([]byte{3}): &ripemd160hash{}, + libcommon.BytesToAddress([]byte{4}): &dataCopy{}, + libcommon.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, + libcommon.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, + libcommon.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, + libcommon.BytesToAddress([]byte{8}): &bn256PairingGranite{}, + libcommon.BytesToAddress([]byte{9}): &blake2F{}, + libcommon.BytesToAddress([]byte{0x0a}): &pointEvaluation{}, + libcommon.BytesToAddress([]byte{0x01, 0x00}): &p256Verify{}, +} + var PrecompiledContractsNapoli = map[libcommon.Address]PrecompiledContract{ libcommon.BytesToAddress([]byte{0x01}): &ecrecover{}, libcommon.BytesToAddress([]byte{0x02}): &sha256hash{}, @@ -151,6 +183,8 @@ libcommon.BytesToAddress([]byte{0x13}): &bls12381MapFp2ToG2{}, }   var ( + PrecompiledAddressesGranite []libcommon.Address + PrecompiledAddressesFjord []libcommon.Address PrecompiledAddressesPrague []libcommon.Address PrecompiledAddressesNapoli []libcommon.Address PrecompiledAddressesCancun []libcommon.Address @@ -176,6 +210,12 @@ } for k := range PrecompiledContractsCancun { PrecompiledAddressesCancun = append(PrecompiledAddressesCancun, k) } + for k := range PrecompiledContractsFjord { + PrecompiledAddressesFjord = append(PrecompiledAddressesFjord, k) + } + for k := range PrecompiledContractsGranite { + PrecompiledAddressesGranite = append(PrecompiledAddressesGranite, k) + } for k := range PrecompiledContractsNapoli { PrecompiledAddressesNapoli = append(PrecompiledAddressesNapoli, k) } @@ -187,6 +227,10 @@ // ActivePrecompiles returns the precompiles enabled with the current configuration. func ActivePrecompiles(rules *chain.Rules) []libcommon.Address { switch { + case rules.IsOptimismGranite: + return PrecompiledAddressesGranite + case rules.IsOptimismFjord: + return PrecompiledAddressesFjord case rules.IsPrague: return PrecompiledAddressesPrague case rules.IsNapoli: @@ -573,6 +617,9 @@ false32Byte = make([]byte, 32)   // errBadPairingInput is returned if the bn256 pairing input is invalid. errBadPairingInput = errors.New("bad elliptic curve pairing size") + + // errBadPairingInputSize is returned if the bn256 pairing input size is invalid. + errBadPairingInputSize = errors.New("bad elliptic curve pairing input size") )   // runBn256Pairing implements the Bn256Pairing precompile, referenced by both @@ -604,6 +651,22 @@ if bn256.PairingCheck(cs, ts) { return true32Byte, nil } return false32Byte, nil +} + +// bn256PairingGranite implements a pairing pre-compile for the bn256 curve +// conforming to Granite consensus rules. +type bn256PairingGranite struct{} + +// RequiredGas returns the gas required to execute the pre-compiled contract. +func (c *bn256PairingGranite) RequiredGas(input []byte) uint64 { + return new(bn256PairingIstanbul).RequiredGas(input) +} + +func (c *bn256PairingGranite) Run(input []byte) ([]byte, error) { + if len(input) > int(params.Bn256PairingMaxInputSizeGranite) { + return nil, errBadPairingInputSize + } + return runBn256Pairing(input) }   // bn256PairingIstanbul implements a pairing pre-compile for the bn256 curve

diff --git erigontech/erigon/core/vm/evm.go testinprod-io/erigon/core/vm/evm.go index 2ce7ee887fa3b4b3e787aa7cdb292fa5686c7e8f..14e54cd8af2a238f229b4ef37eabd2b077214397 100644 --- erigontech/erigon/core/vm/evm.go +++ testinprod-io/erigon/core/vm/evm.go @@ -37,6 +37,10 @@ func (evm *EVM) precompile(addr libcommon.Address) (PrecompiledContract, bool) { var precompiles map[libcommon.Address]PrecompiledContract switch { + case evm.chainRules.IsOptimismGranite: + precompiles = PrecompiledContractsGranite + case evm.chainRules.IsOptimismFjord: + precompiles = PrecompiledContractsFjord case evm.chainRules.IsPrague: precompiles = PrecompiledContractsPrague case evm.chainRules.IsNapoli: @@ -54,6 +58,10 @@ precompiles = PrecompiledContractsHomestead } p, ok := precompiles[addr] return p, ok +} + +func (evm *EVM) Precompile(addr libcommon.Address) (PrecompiledContract, bool) { + return evm.precompile(addr) }   // run runs the given contract and takes care of running precompiles with a fallback to the byte code interpreter.

diff --git erigontech/erigon/erigon-lib/fastlz/fastlz.go testinprod-io/erigon/erigon-lib/fastlz/fastlz.go new file mode 100644 index 0000000000000000000000000000000000000000..70dedce7dbd7a0f7ea7b1ccf36dd7b238dc38876 --- /dev/null +++ testinprod-io/erigon/erigon-lib/fastlz/fastlz.go @@ -0,0 +1,79 @@ +package fastlz + +// FlzCompressLen returns the length of the data after compression through FastLZ, based on +// https://github.com/Vectorized/solady/blob/5315d937d79b335c668896d7533ac603adac5315/js/solady.js +func FlzCompressLen(ib []byte) uint32 { + n := uint32(0) + ht := make([]uint32, 8192) + u24 := func(i uint32) uint32 { + return uint32(ib[i]) | (uint32(ib[i+1]) << 8) | (uint32(ib[i+2]) << 16) + } + cmp := func(p uint32, q uint32, e uint32) uint32 { + l := uint32(0) + for e -= q; l < e; l++ { + if ib[p+l] != ib[q+l] { + e = 0 + } + } + return l + } + literals := func(r uint32) { + n += 0x21 * (r / 0x20) + r %= 0x20 + if r != 0 { + n += r + 1 + } + } + match := func(l uint32) { + l-- + n += 3 * (l / 262) + if l%262 >= 6 { + n += 3 + } else { + n += 2 + } + } + hash := func(v uint32) uint32 { + return ((2654435769 * v) >> 19) & 0x1fff + } + setNextHash := func(ip uint32) uint32 { + ht[hash(u24(ip))] = ip + return ip + 1 + } + a := uint32(0) + ipLimit := uint32(len(ib)) - 13 + if len(ib) < 13 { + ipLimit = 0 + } + for ip := a + 2; ip < ipLimit; { + r := uint32(0) //nolint:all + d := uint32(0) //nolint:all + for { + s := u24(ip) + h := hash(s) + r = ht[h] + ht[h] = ip + d = ip - r + if ip >= ipLimit { + break + } + ip++ + if d <= 0x1fff && s == u24(r) { + break + } + } + if ip >= ipLimit { + break + } + ip-- + if ip > a { + literals(ip - a) + } + l := cmp(r+3, ip+3, ipLimit+9) + match(l) + ip = setNextHash(setNextHash(ip + l)) + a = ip + } + literals(uint32(len(ib)) - a) + return n +}

diff --git erigontech/erigon/cmd/utils/flags.go testinprod-io/erigon/cmd/utils/flags.go index 7cf4b19a16f12e871d71e34fe6c819dc4c29175b..d4d65bf3cc41274316684043da5295bd5d41fd16 100644 --- erigontech/erigon/cmd/utils/flags.go +++ testinprod-io/erigon/cmd/utils/flags.go @@ -19,13 +19,17 @@ package utils   import ( "crypto/ecdsa" + "encoding/json" "fmt" "math/big" + "os" "path/filepath" "runtime" "strconv" "strings" "time" + + "golang.org/x/exp/slices"   "github.com/c2h5oh/datasize" "github.com/ledgerwatch/log/v3" @@ -51,6 +55,7 @@ common2 "github.com/ledgerwatch/erigon/common" "github.com/ledgerwatch/erigon/common/paths" "github.com/ledgerwatch/erigon/consensus/ethash/ethashcfg" "github.com/ledgerwatch/erigon/core" + "github.com/ledgerwatch/erigon/core/types" "github.com/ledgerwatch/erigon/crypto" "github.com/ledgerwatch/erigon/eth/ethconfig" "github.com/ledgerwatch/erigon/eth/gasprice/gaspricecfg" @@ -110,6 +115,14 @@ WhitelistFlag = cli.StringFlag{ Name: "whitelist", Usage: "Comma separated block number-to-hash mappings to enforce (<number>=<hash>)", } + OverrideShanghaiTime = flags.BigFlag{ + Name: "override.shanghai", + Usage: "Manually specify the Shanghai fork time, overriding the bundled setting", + } + OverrideCancunFlag = flags.BigFlag{ + Name: "override.cancun", + Usage: "Manually specify the Cancun fork time, overriding the bundled setting", + } OverridePragueFlag = flags.BigFlag{ Name: "override.prague", Usage: "Manually specify the Prague fork time, overriding the bundled setting", @@ -117,6 +130,22 @@ } TrustedSetupFile = cli.StringFlag{ Name: "trusted-setup-file", Usage: "Absolute path to trusted_setup.json file", + } + OverrideOptimismCanyonFlag = flags.BigFlag{ + Name: "override.canyon", + Usage: "Manually specify the Optimism Canyon fork time, overriding the bundled setting", + } + OverrideOptimismEcotoneFlag = flags.BigFlag{ + Name: "override.ecotone", + Usage: "Manually specify the Optimism Ecotone fork time, overriding the bundled setting", + } + OverrideOptimismFjordFlag = flags.BigFlag{ + Name: "override.fjord", + Usage: "Manually specify the Optimism Fjord fork time, overriding the bundled setting", + } + OverrideOptimismGraniteFlag = flags.BigFlag{ + Name: "override.granite", + Usage: "Manually specify the Optimism Granite fork time, overriding the bundled setting", } // Ethash settings EthashCachesInMemoryFlag = cli.IntFlag{ @@ -603,11 +632,12 @@ Value: "", } NoDiscoverFlag = cli.BoolFlag{ Name: "nodiscover", - Usage: "Disables the peer discovery mechanism (manual peer addition)", + Usage: "Disables the v4 peer discovery mechanism (manual peer addition). Refer to --v5disc to configure v5 discovery protocol", } DiscoveryV5Flag = cli.BoolFlag{ Name: "v5disc", - Usage: "Enables the experimental RLPx V5 (Topic Discovery) mechanism", + Usage: "Enables the experimental RLPx V5 (Topic Discovery) mechanism (enabled by default). Use --v5disc=false to disable it", + Value: true, } NetrestrictFlag = cli.StringFlag{ Name: "netrestrict", @@ -641,6 +671,39 @@ Name: "gpo.maxprice", Usage: "Maximum gas price will be recommended by gpo", Value: ethconfig.Defaults.GPO.MaxPrice.Int64(), } + GpoIgnoreGasPriceFlag = cli.Int64Flag{ + Name: "gpo.ignoreprice", + Usage: "Gas price below which gpo will ignore transactions", + Value: ethconfig.Defaults.GPO.IgnorePrice.Int64(), + } + 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(), + } + + // Rollup Flags + RollupSequencerHTTPFlag = cli.StringFlag{ + Name: "rollup.sequencerhttp", + Usage: "HTTP endpoint for the sequencer mempool", + } + RollupHistoricalRPCFlag = cli.StringFlag{ + Name: "rollup.historicalrpc", + Usage: "RPC endpoint for historical data.", + } + RollupHistoricalRPCTimeoutFlag = cli.StringFlag{ + Name: "rollup.historicalrpctimeout", + Usage: "Timeout for historical RPC requests.", + Value: "5s", + } + RollupDisableTxPoolGossipFlag = cli.StringFlag{ + Name: "rollup.disabletxpoolgossip", + Usage: "Disables transaction pool gossip.", + } + 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", + }   // Metrics flags MetricsEnabledFlag = cli.BoolFlag{ @@ -690,6 +753,7 @@ Usage: "Keep ancient blocks in db (useful for debug)", } SnapStopFlag = cli.BoolFlag{ Name: ethconfig.FlagSnapStop, + Value: true, Usage: "Workaround to stop producing new snapshots, if you meet some snapshots-related critical bug. It will stop move historical data from DB to new immutable snapshots. DB will grow and may slightly slow-down - and removing this flag in future will not fix this effect (db size will not greatly reduce).", } TorrentVerbosityFlag = cli.IntFlag{ @@ -849,6 +913,11 @@ Name: "sentinel.port", Usage: "Port for sentinel", Value: 7777, } + GenesisPathFlag = cli.StringFlag{ + Name: "genesis.path", + Usage: "Genesis JSON file path", + Value: "/genesis.json", + }   OtsSearchMaxCapFlag = cli.Uint64Flag{ Name: "ots.search.max.pagesize", @@ -1024,6 +1093,10 @@ var MetricFlags = []cli.Flag{&MetricsEnabledFlag, &MetricsHTTPFlag, &MetricsPortFlag, &DiagDisabledFlag, &DiagEndpointAddrFlag, &DiagEndpointPortFlag, &DiagSpeedTestFlag}   var DiagnosticsFlags = []cli.Flag{&DiagnosticsURLFlag, &DiagnosticsURLFlag, &DiagnosticsSessionsFlag}   +func GetChainNameFromFlag(ctx *cli.Context) string { + return networkname.HandleLegacyName(ctx.String(ChainFlag.Name)) +} + // setNodeKey loads a node key from command line flags if provided, // otherwise it tries to load it from datadir, // otherwise it generates a new key in datadir. @@ -1057,7 +1130,7 @@ if cfg.BootstrapNodes != nil { return }   - nodes, err := GetBootnodesFromFlags(ctx.String(BootnodesFlag.Name), ctx.String(ChainFlag.Name)) + nodes, err := GetBootnodesFromFlags(ctx.String(BootnodesFlag.Name), GetChainNameFromFlag(ctx)) if err != nil { Fatalf("Option %s: %v", BootnodesFlag.Name, err) } @@ -1071,7 +1144,7 @@ if cfg.BootstrapNodesV5 != nil { return }   - nodes, err := GetBootnodesFromFlags(ctx.String(BootnodesFlag.Name), ctx.String(ChainFlag.Name)) + nodes, err := GetBootnodesFromFlags(ctx.String(BootnodesFlag.Name), GetChainNameFromFlag(ctx)) if err != nil { Fatalf("Option %s: %v", BootnodesFlag.Name, err) } @@ -1097,7 +1170,7 @@ var urls []string if ctx.IsSet(StaticPeersFlag.Name) { urls = libcommon.CliString2Array(ctx.String(StaticPeersFlag.Name)) } else { - chain := ctx.String(ChainFlag.Name) + chain := GetChainNameFromFlag(ctx) urls = params.StaticPeerURLsOfChain(chain) }   @@ -1289,7 +1362,7 @@ cfg.Miner.SigKey = key } }   - if chainName := ctx.String(ChainFlag.Name); chainName == networkname.DevChainName || chainName == networkname.BorDevnetChainName { + if slices.Contains([]string{networkname.DevChainName, networkname.BorDevnetChainName, networkname.OPDevnetChainName}, GetChainNameFromFlag(ctx)) { if etherbase == "" { cfg.Miner.Etherbase = core.DevnetEtherbase } @@ -1300,7 +1373,7 @@ setSigKey(ctx, cfg) }   chainsWithValidatorMode := map[string]bool{} - if _, ok := chainsWithValidatorMode[ctx.String(ChainFlag.Name)]; ok || ctx.IsSet(MinerSigningKeyFileFlag.Name) { + if _, ok := chainsWithValidatorMode[GetChainNameFromFlag(ctx)]; ok || ctx.IsSet(MinerSigningKeyFileFlag.Name) { if ctx.IsSet(MiningEnabledFlag.Name) && !ctx.IsSet(MinerSigningKeyFileFlag.Name) { panic(fmt.Sprintf("Flag --%s is required in %s chain with --%s flag", MinerSigningKeyFileFlag.Name, ChainFlag.Name, MiningEnabledFlag.Name)) } @@ -1332,9 +1405,7 @@ if ctx.IsSet(NoDiscoverFlag.Name) { cfg.NoDiscovery = true }   - if ctx.IsSet(DiscoveryV5Flag.Name) { - cfg.DiscoveryV5 = ctx.Bool(DiscoveryV5Flag.Name) - } + cfg.DiscoveryV5 = ctx.Bool(DiscoveryV5Flag.Name)   if ctx.IsSet(MetricsEnabledFlag.Name) { cfg.MetricsEnabled = ctx.Bool(MetricsEnabledFlag.Name) @@ -1351,7 +1422,7 @@ } cfg.NetRestrict = list }   - if ctx.String(ChainFlag.Name) == networkname.DevChainName { + if GetChainNameFromFlag(ctx) == networkname.DevChainName { // --dev mode can't use p2p networking. //cfg.MaxPeers = 0 // It can have peers otherwise local sync is not possible if !ctx.IsSet(ListenPortFlag.Name) { @@ -1383,7 +1454,7 @@ func setDataDir(ctx *cli.Context, cfg *nodecfg.Config) { if ctx.IsSet(DataDirFlag.Name) { cfg.Dirs = datadir.New(ctx.String(DataDirFlag.Name)) } else { - cfg.Dirs = datadir.New(paths.DataDirForNetwork(paths.DefaultDataDir(), ctx.String(ChainFlag.Name))) + cfg.Dirs = datadir.New(paths.DataDirForNetwork(paths.DefaultDataDir(), GetChainNameFromFlag(ctx))) } cfg.MdbxPageSize = flags.DBPageSizeFlagUnmarshal(ctx, DbPageSizeFlag.Name, DbPageSizeFlag.Usage) if err := cfg.MdbxDBSizeLimit.UnmarshalText([]byte(ctx.String(DbSizeLimitFlag.Name))); err != nil { @@ -1404,6 +1475,7 @@ chain, err := f.GetString(ChainFlag.Name) if err != nil { panic(err) } + chain = networkname.HandleLegacyName(chain) if dirname != "" { cfg.Dirs = datadir.New(dirname) } else { @@ -1420,6 +1492,12 @@ cfg.Percentile = ctx.Int(GpoPercentileFlag.Name) } if ctx.IsSet(GpoMaxGasPriceFlag.Name) { cfg.MaxPrice = big.NewInt(ctx.Int64(GpoMaxGasPriceFlag.Name)) + } + 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)) } }   @@ -1725,6 +1803,31 @@ Fatalf("Flags %v can't be used at the same time", strings.Join(set, ", ")) } }   +// readGenesis will read the given JSON format genesis file and return +// the initialized Genesis structure +func readGenesis(genesisPath string) *types.Genesis { + // Make sure we have a valid genesis JSON + if len(genesisPath) == 0 { + Fatalf("Must supply path to genesis JSON file") + } + file, err := os.Open(genesisPath) + if err != nil { + Fatalf("Failed to read genesis file: %v", err) + } + defer func(file *os.File) { + closeErr := file.Close() + if closeErr != nil { + log.Warn("Failed to close file", "err", closeErr) + } + }(file) + + genesis := new(types.Genesis) + if err := json.NewDecoder(file).Decode(genesis); err != nil { + Fatalf("invalid genesis file: %v", err) + } + return genesis +} + // SetEthConfig applies eth-related command line flags to the config. func SetEthConfig(ctx *cli.Context, nodeConfig *nodecfg.Config, cfg *ethconfig.Config, logger log.Logger) { cfg.LightClientDiscoveryAddr = ctx.String(LightClientDiscoveryAddrFlag.Name) @@ -1734,7 +1837,7 @@ cfg.SentinelAddr = ctx.String(SentinelAddrFlag.Name) cfg.SentinelPort = ctx.Uint64(SentinelPortFlag.Name) cfg.ForcePartialCommit = ctx.Bool(ForcePartialCommitFlag.Name)   - chain := ctx.String(ChainFlag.Name) // mainnet by default + chain := GetChainNameFromFlag(ctx) // mainnet by default if ctx.IsSet(NetworkIdFlag.Name) { cfg.NetworkID = ctx.Uint64(NetworkIdFlag.Name) if cfg.NetworkID != 1 && !ctx.IsSet(ChainFlag.Name) { @@ -1744,7 +1847,7 @@ } else { cfg.NetworkID = params.NetworkIDByChainName(chain) }   - cfg.Sync.UseSnapshots = ethconfig.UseSnapshotsByChainName(chain) + cfg.Sync.UseSnapshots = ethconfig.UseSnapshotsByChainName(GetChainNameFromFlag(ctx)) if ctx.IsSet(SnapshotFlag.Name) { //force override default by cli cfg.Sync.UseSnapshots = ctx.Bool(SnapshotFlag.Name) } @@ -1830,6 +1933,16 @@ } else { cfg.EthDiscoveryURLs = libcommon.CliString2Array(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) + }   // Override any default configs for hard coded networks. switch chain { @@ -1860,12 +1973,60 @@ logger.Info("Using custom developer period", "seconds", cfg.Genesis.Config.Clique.Period) if !ctx.IsSet(MinerGasPriceFlag.Name) { cfg.Miner.GasPrice = big.NewInt(1) } + case networkname.OPDevnetChainName: + // Create new developer account or reuse existing one + developer := cfg.Miner.Etherbase + if developer == (libcommon.Address{}) { + Fatalf("Please specify developer account address using --miner.etherbase") + } + logger.Info("Using developer account", "address", developer) + + // Create a new developer genesis block or reuse existing one + cfg.Genesis = readGenesis(ctx.String(GenesisPathFlag.Name)) + //log.Info("Using custom developer period", "seconds", cfg.Genesis.Config.Clique.Period) }   if ctx.IsSet(OverridePragueFlag.Name) { cfg.OverridePragueTime = flags.GlobalBig(ctx, OverridePragueFlag.Name) } - + if ctx.IsSet(OverrideShanghaiTime.Name) { + cfg.OverrideShanghaiTime = flags.GlobalBig(ctx, OverrideShanghaiTime.Name) + cfg.TxPool.OverrideShanghaiTime = cfg.OverrideShanghaiTime + } + if ctx.IsSet(OverrideOptimismCanyonFlag.Name) { + cfg.OverrideOptimismCanyonTime = flags.GlobalBig(ctx, OverrideOptimismCanyonFlag.Name) + cfg.TxPool.OverrideOptimismCanyonTime = cfg.OverrideOptimismCanyonTime + // Shanghai hardfork is included in canyon hardfork + cfg.OverrideShanghaiTime = flags.GlobalBig(ctx, OverrideOptimismCanyonFlag.Name) + cfg.TxPool.OverrideShanghaiTime = cfg.OverrideOptimismCanyonTime + } + if ctx.IsSet(OverrideShanghaiTime.Name) && ctx.IsSet(OverrideOptimismCanyonFlag.Name) { + overrideShanghaiTime := flags.GlobalBig(ctx, OverrideShanghaiTime.Name) + overrideOptimismCanyonTime := flags.GlobalBig(ctx, OverrideOptimismCanyonFlag.Name) + if overrideShanghaiTime.Cmp(overrideOptimismCanyonTime) != 0 { + logger.Warn("Shanghai hardfork time is overridden by optimism canyon hardfork time", + "shanghai", overrideShanghaiTime.String(), "canyon", overrideOptimismCanyonTime.String()) + } + } + if ctx.IsSet(OverrideOptimismEcotoneFlag.Name) { + cfg.OverrideOptimismEcotoneTime = flags.GlobalBig(ctx, OverrideOptimismEcotoneFlag.Name) + // Cancun hardfork is included in Ecotone hardfork + cfg.OverrideCancunTime = flags.GlobalBig(ctx, OverrideOptimismEcotoneFlag.Name) + } + if ctx.IsSet(OverrideCancunFlag.Name) && ctx.IsSet(OverrideOptimismEcotoneFlag.Name) { + overrideCancunTime := flags.GlobalBig(ctx, OverrideCancunFlag.Name) + overrideOptimismEcotoneTime := flags.GlobalBig(ctx, OverrideOptimismEcotoneFlag.Name) + if overrideCancunTime.Cmp(overrideOptimismEcotoneTime) != 0 { + logger.Warn("Cancun hardfork time is overridden by optimism Ecotone hardfork time", + "cancun", overrideCancunTime.String(), "ecotone", overrideOptimismEcotoneTime.String()) + } + } + if ctx.IsSet(OverrideOptimismFjordFlag.Name) { + cfg.OverrideOptimismFjordTime = flags.GlobalBig(ctx, OverrideOptimismFjordFlag.Name) + } + if ctx.IsSet(OverrideOptimismGraniteFlag.Name) { + cfg.OverrideOptimismGraniteTime = flags.GlobalBig(ctx, OverrideOptimismGraniteFlag.Name) + } if ctx.IsSet(InternalConsensusFlag.Name) && clparams.EmbeddedSupported(cfg.NetworkID) { cfg.InternalCL = ctx.Bool(InternalConsensusFlag.Name) } @@ -1876,6 +2037,22 @@ }   if ctx.IsSet(TxPoolGossipDisableFlag.Name) { cfg.DisableTxPoolGossip = ctx.Bool(TxPoolGossipDisableFlag.Name) + } + if ctx.IsSet(RollupDisableTxPoolGossipFlag.Name) { + logger.Warn("--rollup.disabletxpoolgossip flag is deprecated. use --txpool.gossip.disable") + if !ctx.IsSet(TxPoolGossipDisableFlag.Name) { + cfg.DisableTxPoolGossip = ctx.Bool(RollupDisableTxPoolGossipFlag.Name) + } + } + + if ctx.IsSet(RollupHaltOnIncompatibleProtocolVersionFlag.Name) { + flag := ctx.String(RollupHaltOnIncompatibleProtocolVersionFlag.Name) + switch flag { + case "major", "minor", "patch", "none": + cfg.RollupHaltOnIncompatibleProtocolVersion = flag + default: + logger.Warn("Ignoring incorrect value for --rollup.halt. Please specify a level from major/minor/patch/none.") + } } }

diff --git erigontech/erigon/turbo/cli/default_flags.go testinprod-io/erigon/turbo/cli/default_flags.go index 251094811bf35d7997947602cd728ab172cbdadc..dd10732b204b5eecd9d4cd6aae9a95d2e0d59edd 100644 --- erigontech/erigon/turbo/cli/default_flags.go +++ testinprod-io/erigon/turbo/cli/default_flags.go @@ -1,9 +1,8 @@ package cli   import ( + "github.com/ledgerwatch/erigon/cmd/utils" "github.com/urfave/cli/v2" - - "github.com/ledgerwatch/erigon/cmd/utils" )   // DefaultFlags contains all flags that are used and supported by Erigon binary. @@ -127,6 +126,8 @@ &utils.NetworkIdFlag, &utils.FakePoWFlag, &utils.GpoBlocksFlag, &utils.GpoPercentileFlag, + &utils.GpoIgnoreGasPriceFlag, + &utils.GpoMinSuggestedPriorityFeeFlag, &utils.InsecureUnlockAllowedFlag, &utils.IdentityFlag, &utils.CliqueSnapshotCheckpointIntervalFlag, @@ -159,6 +160,17 @@ &utils.WithHeimdallMilestones, &utils.WithHeimdallWaypoints, &utils.PolygonSyncFlag, &utils.EthStatsURLFlag, + &utils.OverrideCancunFlag, + &utils.OverrideShanghaiTime, + &utils.OverrideOptimismCanyonFlag, + &utils.OverrideOptimismEcotoneFlag, + &utils.OverrideOptimismFjordFlag, + &utils.OverrideOptimismGraniteFlag, + &utils.RollupSequencerHTTPFlag, + &utils.RollupHistoricalRPCFlag, + &utils.RollupHistoricalRPCTimeoutFlag, + &utils.RollupDisableTxPoolGossipFlag, + &utils.RollupHaltOnIncompatibleProtocolVersionFlag, &utils.OverridePragueFlag,   &utils.LightClientDiscoveryAddrFlag, @@ -167,6 +179,7 @@ &utils.LightClientDiscoveryTCPPortFlag, &utils.SentinelAddrFlag, &utils.SentinelPortFlag,   + &utils.GenesisPathFlag, &utils.OtsSearchMaxCapFlag,   &utils.SilkwormExecutionFlag,

diff --git erigontech/erigon/turbo/cli/flags.go testinprod-io/erigon/turbo/cli/flags.go index 41bd8d703f1b1daece3a366cdd6d5a572fddac7e..003c067571cedffb2088d3d3bee832f49e330fd4 100644 --- erigontech/erigon/turbo/cli/flags.go +++ testinprod-io/erigon/turbo/cli/flags.go @@ -500,6 +500,10 @@ OtsMaxPageSize: ctx.Uint64(utils.OtsSearchMaxCapFlag.Name),   TxPoolApiAddr: ctx.String(utils.TxpoolApiAddrFlag.Name),   + RollupSequencerHTTP: ctx.String(utils.RollupSequencerHTTPFlag.Name), + RollupHistoricalRPC: ctx.String(utils.RollupHistoricalRPCFlag.Name), + RollupHistoricalRPCTimeout: ctx.Duration(utils.RollupHistoricalRPCTimeoutFlag.Name), + StateCache: kvcache.DefaultCoherentConfig, RPCSlowLogThreshold: ctx.Duration(utils.RPCSlowFlag.Name), }

diff --git erigontech/erigon/params/version.go testinprod-io/erigon/params/version.go index 84287fbbf53f0008655b68653c80b31a639066da..eba39713933a260339fc7d8a8ad029e3e753cfae 100644 --- erigontech/erigon/params/version.go +++ testinprod-io/erigon/params/version.go @@ -29,6 +29,7 @@ GitBranch string GitTag string )   +// Version is the version of upstream erigon // see https://calver.org const ( VersionMajor = 2 // Major version component of the current release @@ -39,14 +40,36 @@ VersionKeyCreated = "ErigonVersionCreated" VersionKeyFinished = "ErigonVersionFinished" )   +// OPVersion is the version of op-erigon +const ( + OPVersionMajor = 0 // Major version component of the current release + OPVersionMinor = 7 // Minor version component of the current release + OPVersionMicro = 0 // Patch version component of the current release + OPVersionModifier = "unstable" // Version metadata to append to the version string +) + // Version holds the textual version string. var Version = func() string { - return fmt.Sprintf("%d.%02d.%d", VersionMajor, VersionMinor, VersionMicro) + return fmt.Sprintf("%d.%02d.%d", OPVersionMajor, OPVersionMinor, OPVersionMicro) }()   // VersionWithMeta holds the textual version string including the metadata. var VersionWithMeta = func() string { v := Version + if OPVersionModifier != "" { + v += "-" + OPVersionModifier + } + return v +}() + +// ErigonVersion holds the textual erigon version string. +var ErigonVersion = func() string { + return fmt.Sprintf("%d.%d.%d", VersionMajor, VersionMinor, VersionMicro) +}() + +// ErigonVersionWithMeta holds the textual erigon version string including the metadata. +var ErigonVersionWithMeta = func() string { + v := ErigonVersion if VersionModifier != "" { v += "-" + VersionModifier }