feat: update L1 data fee in Curie hard fork

Makefile

@@ -40,7 +40,7 @@ test: all
  # genesis test
  cd ${PWD}/cmd/geth; go test -test.run TestCustomGenesis
  # module test
- $(GORUN) build/ci.go test ./consensus ./core ./eth ./miner ./node ./trie
+ $(GORUN) build/ci.go test ./consensus ./core ./eth ./miner ./node ./trie ./rollup/fees
 
 lint: ## Run linters.
  $(GORUN) build/ci.go lint

accounts/abi/bind/backends/simulated.go

@@ -640,7 +640,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
  vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{NoBaseFee: true})
  gasPool := new(core.GasPool).AddGas(math.MaxUint64)
  signer := types.MakeSigner(b.blockchain.Config(), head.Number)
- l1DataFee, err := fees.EstimateL1DataFeeForMessage(msg, head.BaseFee, b.blockchain.Config().ChainID, signer, stateDB)
+ l1DataFee, err := fees.EstimateL1DataFeeForMessage(msg, head.BaseFee, b.blockchain.Config(), signer, stateDB, head.Number)
  if err != nil {
  return nil, err
  }

cmd/evm/internal/t8ntool/execution.go

@@ -148,6 +148,10 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
  chainConfig.DAOForkBlock.Cmp(new(big.Int).SetUint64(pre.Env.Number)) == 0 {
  misc.ApplyDAOHardFork(statedb)
  }
+ // Apply Curie hard fork
+ if chainConfig.CurieBlock != nil && chainConfig.CurieBlock.Cmp(new(big.Int).SetUint64(pre.Env.Number)) == 0 {
+ misc.ApplyCurieHardFork(statedb)
+ }
 
  for i, tx := range txs {
  msg, err := tx.AsMessage(signer, pre.Env.BaseFee)
@@ -167,7 +171,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
  snapshot := statedb.Snapshot()
  evm := vm.NewEVM(vmContext, txContext, statedb, chainConfig, vmConfig)
 
- l1DataFee, err := fees.CalculateL1DataFee(tx, statedb)
+ l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, chainConfig, new(big.Int).SetUint64(pre.Env.Number))
  if err != nil {
  log.Info("rejected tx due to fees.CalculateL1DataFee", "index", i, "hash", tx.Hash(), "from", msg.From(), "error", err)
  rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()})

consensus/misc/curie.go

@@ -0,0 +1,23 @@
+package misc
+
+import (
+ "github.com/scroll-tech/go-ethereum/common"
+ "github.com/scroll-tech/go-ethereum/core/state"
+ "github.com/scroll-tech/go-ethereum/log"
+ "github.com/scroll-tech/go-ethereum/rollup/rcfg"
+)
+
+// ApplyCurieHardFork modifies the state database according to the Curie hard-fork rules,
+// updating the bytecode and storage of the L1GasPriceOracle contract.
+func ApplyCurieHardFork(statedb *state.StateDB) {
+ log.Info("Applying Curie hard fork")
+
+ // update contract byte code
+ statedb.SetCode(rcfg.L1GasPriceOracleAddress, rcfg.CurieL1GasPriceOracleBytecode)
+
+ // initialize new storage slots
+ statedb.SetState(rcfg.L1GasPriceOracleAddress, rcfg.IsCurieSlot, common.BytesToHash([]byte{1}))
+ statedb.SetState(rcfg.L1GasPriceOracleAddress, rcfg.L1BlobBaseFeeSlot, common.BytesToHash([]byte{1}))
+ statedb.SetState(rcfg.L1GasPriceOracleAddress, rcfg.CommitScalarSlot, common.BigToHash(rcfg.InitialCommitScalar))
+ statedb.SetState(rcfg.L1GasPriceOracleAddress, rcfg.BlobScalarSlot, common.BigToHash(rcfg.InitialBlobScalar))
+}

core/blockchain_test.go

@@ -17,6 +17,7 @@
 package core
 
 import (
+ "encoding/json"
  "errors"
  "fmt"
  "io/ioutil"
@@ -39,6 +40,7 @@ import (
  "github.com/scroll-tech/go-ethereum/crypto"
  "github.com/scroll-tech/go-ethereum/ethdb"
  "github.com/scroll-tech/go-ethereum/params"
+ "github.com/scroll-tech/go-ethereum/rollup/rcfg"
  "github.com/scroll-tech/go-ethereum/trie"
 )
 
@@ -3712,3 +3714,78 @@ func TestTransientStorageReset(t *testing.T) {
  t.Fatalf("Unexpected dirty storage slot")
  }
 }
+
+func TestCurieTransition(t *testing.T) {
+ // Set fork blocks in config
+ // (we make a deep copy to avoid interference with other tests)
+ var config *params.ChainConfig
+ b, _ := json.Marshal(params.AllEthashProtocolChanges)
+ json.Unmarshal(b, &config)
+ config.CurieBlock = big.NewInt(2)
+ config.DescartesBlock = nil
+
+ var (
+ db = rawdb.NewMemoryDatabase()
+ gspec = &Genesis{Config: config}
+ genesis = gspec.MustCommit(db)
+ )
+
+ blockchain, _ := NewBlockChain(db, nil, gspec.Config, ethash.NewFaker(), vm.Config{}, nil, nil)
+ defer blockchain.Stop()
+ blocks, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 4, nil)
+
+ if _, err := blockchain.InsertChain(blocks); err != nil {
+ t.Fatal(err)
+ }
+
+ latestBlock := uint64(4)
+ assert.Equal(t, latestBlock, blockchain.CurrentHeader().Number.Uint64())
+
+ for ii := uint64(0); ii <= latestBlock; ii++ {
+ block := blockchain.GetBlockByNumber(ii)
+
+ number := block.Number().Uint64()
+ baseFee := block.BaseFee()
+
+ statedb, _ := state.New(block.Root(), state.NewDatabase(db), nil)
+
+ code := statedb.GetCode(rcfg.L1GasPriceOracleAddress)
+ codeSize := statedb.GetCodeSize(rcfg.L1GasPriceOracleAddress)
+ keccakCodeHash := statedb.GetKeccakCodeHash(rcfg.L1GasPriceOracleAddress)
+ poseidonCodeHash := statedb.GetPoseidonCodeHash(rcfg.L1GasPriceOracleAddress)
+
+ l1BlobBaseFee := statedb.GetState(rcfg.L1GasPriceOracleAddress, rcfg.L1BlobBaseFeeSlot)
+ commitScalar := statedb.GetState(rcfg.L1GasPriceOracleAddress, rcfg.CommitScalarSlot)
+ blobScalar := statedb.GetState(rcfg.L1GasPriceOracleAddress, rcfg.BlobScalarSlot)
+ isCurie := statedb.GetState(rcfg.L1GasPriceOracleAddress, rcfg.IsCurieSlot)
+
+ if number < config.CurieBlock.Uint64() {
+ assert.Nil(t, baseFee, "Expected zero base fee before Curie")
+
+ // we don't have predeploys configured in this test,
+ // so there is no gas oracle deployed before Curie
+ assert.Nil(t, code)
+ assert.Equal(t, uint64(0), codeSize)
+ assert.Equal(t, common.Hash{}, keccakCodeHash)
+ assert.Equal(t, common.Hash{}, poseidonCodeHash)
+
+ assert.Equal(t, common.Hash{}, l1BlobBaseFee)
+ assert.Equal(t, common.Hash{}, commitScalar)
+ assert.Equal(t, common.Hash{}, blobScalar)
+ assert.Equal(t, common.Hash{}, isCurie)
+ } else {
+ assert.NotNil(t, baseFee, "Expected nonzero base fee after Curie")
+
+ // all gas oracle entries updated
+ assert.NotNil(t, code)
+ assert.NotEqual(t, uint64(0), codeSize)
+ assert.NotEqual(t, common.Hash{}, keccakCodeHash)
+ assert.NotEqual(t, common.Hash{}, poseidonCodeHash)
+
+ assert.NotEqual(t, common.Hash{}, l1BlobBaseFee)
+ assert.NotEqual(t, common.Hash{}, commitScalar)
+ assert.NotEqual(t, common.Hash{}, blobScalar)
+ assert.NotEqual(t, common.Hash{}, isCurie)
+ }
+ }
+}

core/chain_makers.go

@@ -240,6 +240,9 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
  if config.DAOForkSupport && config.DAOForkBlock != nil && config.DAOForkBlock.Cmp(b.header.Number) == 0 {
  misc.ApplyDAOHardFork(statedb)
  }
+ if config.CurieBlock != nil && config.CurieBlock.Cmp(b.header.Number) == 0 {
+ misc.ApplyCurieHardFork(statedb)
+ }
  // Execute any user modifications to the block
  if gen != nil {
  gen(i, b)

core/state_prefetcher.go

@@ -71,7 +71,7 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, c
  }
  statedb.SetTxContext(tx.Hash(), i)
 
- l1DataFee, err := fees.CalculateL1DataFee(tx, statedb)
+ l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, p.config, block.Number())
  if err != nil {
  return
  }

core/state_processor.go

@@ -86,6 +86,10 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
  if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 {
  misc.ApplyDAOHardFork(statedb)
  }
+ // Apply Curie hard fork
+ if p.config.CurieBlock != nil && p.config.CurieBlock.Cmp(block.Number()) == 0 {
+ misc.ApplyCurieHardFork(statedb)
+ }
  blockContext := NewEVMBlockContext(header, p.bc, p.config, nil)
  vmenv := vm.NewEVM(blockContext, vm.TxContext{}, statedb, p.config, cfg)
  processorBlockTransactionGauge.Update(int64(block.Transactions().Len()))
@@ -120,7 +124,7 @@ func applyTransaction(msg types.Message, config *params.ChainConfig, bc ChainCon
  txContext := NewEVMTxContext(msg)
  evm.Reset(txContext, statedb)
 
- l1DataFee, err := fees.CalculateL1DataFee(tx, statedb)
+ l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, config, blockNumber)
  if err != nil {
  return nil, err
  }

core/tx_list.go

@@ -29,6 +29,7 @@ import (
  "github.com/scroll-tech/go-ethereum/core/state"
  "github.com/scroll-tech/go-ethereum/core/types"
  "github.com/scroll-tech/go-ethereum/log"
+ "github.com/scroll-tech/go-ethereum/params"
  "github.com/scroll-tech/go-ethereum/rollup/fees"
 )
 
@@ -281,7 +282,7 @@ func (l *txList) Overlaps(tx *types.Transaction) bool {
 //
 // If the new transaction is accepted into the list, the lists' cost and gas
 // thresholds are also potentially updated.
-func (l *txList) Add(tx *types.Transaction, state *state.StateDB, priceBump uint64) (bool, *types.Transaction) {
+func (l *txList) Add(tx *types.Transaction, state *state.StateDB, priceBump uint64, chainconfig *params.ChainConfig, blockNumber *big.Int) (bool, *types.Transaction) {
  // If there's an older better transaction, abort
  old := l.txs.Get(tx.Nonce())
  if old != nil {
@@ -307,9 +308,9 @@ func (l *txList) Add(tx *types.Transaction, state *state.StateDB, priceBump uint
  }
  // Otherwise overwrite the old transaction with the current one
  l1DataFee := big.NewInt(0)
- if state != nil {
+ if state != nil && chainconfig != nil {
  var err error
- l1DataFee, err = fees.CalculateL1DataFee(tx, state)
+ l1DataFee, err = fees.CalculateL1DataFee(tx, state, chainconfig, blockNumber)
  if err != nil {
  log.Error("Failed to calculate L1 data fee", "err", err, "tx", tx)
  return false, nil

core/tx_list_test.go

@@ -38,7 +38,7 @@ func TestStrictTxListAdd(t *testing.T) {
  // Insert the transactions in a random order
  list := newTxList(true)
  for _, v := range rand.Perm(len(txs)) {
- list.Add(txs[v], nil, DefaultTxPoolConfig.PriceBump)
+ list.Add(txs[v], nil, DefaultTxPoolConfig.PriceBump, nil, nil)
  }
  // Verify internal state
  if len(list.txs.items) != len(txs) {
@@ -65,7 +65,7 @@ func BenchmarkTxListAdd(b *testing.B) {
  for i := 0; i < b.N; i++ {
  list := newTxList(true)
  for _, v := range rand.Perm(len(txs)) {
- list.Add(txs[v], nil, DefaultTxPoolConfig.PriceBump)
+ list.Add(txs[v], nil, DefaultTxPoolConfig.PriceBump, nil, nil)
  list.Filter(priceLimit, DefaultTxPoolConfig.PriceBump)
  }
  }

core/tx_pool.go

@@ -248,6 +248,7 @@ type TxPool struct {
  shanghai bool // Fork indicator whether we are in the Shanghai stage.
 
  currentState *state.StateDB // Current state in the blockchain head
+ currentHead *big.Int // Current blockchain head
  pendingNonces *txNoncer // Pending state tracking virtual nonces
  currentMaxGas uint64 // Current gas limit for transaction caps
 
@@ -664,7 +665,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
  // 2. If FeeVault is enabled, perform an additional check for L1 data fees.
  if pool.chainconfig.Scroll.FeeVaultEnabled() {
  // Get L1 data fee in current state
- l1DataFee, err := fees.CalculateL1DataFee(tx, pool.currentState)
+ l1DataFee, err := fees.CalculateL1DataFee(tx, pool.currentState, pool.chainconfig, pool.currentHead)
  if err != nil {
  return fmt.Errorf("failed to calculate L1 data fee, err: %w", err)
  }
@@ -751,7 +752,7 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (replaced bool, err e
  from, _ := types.Sender(pool.signer, tx) // already validated
  if list := pool.pending[from]; list != nil && list.Overlaps(tx) {
  // Nonce already pending, check if required price bump is met
- inserted, old := list.Add(tx, pool.currentState, pool.config.PriceBump)
+ inserted, old := list.Add(tx, pool.currentState, pool.config.PriceBump, pool.chainconfig, pool.currentHead)
  if !inserted {
  pendingDiscardMeter.Mark(1)
  return false, ErrReplaceUnderpriced
@@ -802,7 +803,7 @@ func (pool *TxPool) enqueueTx(hash common.Hash, tx *types.Transaction, local boo
  pool.queue[from] = newTxList(false)
  }
 
- inserted, old := pool.queue[from].Add(tx, pool.currentState, pool.config.PriceBump)
+ inserted, old := pool.queue[from].Add(tx, pool.currentState, pool.config.PriceBump, pool.chainconfig, pool.currentHead)
  if !inserted {
  // An older transaction was better, discard this
  queuedDiscardMeter.Mark(1)
@@ -856,7 +857,7 @@ func (pool *TxPool) promoteTx(addr common.Address, hash common.Hash, tx *types.T
  }
  list := pool.pending[addr]
 
- inserted, old := list.Add(tx, pool.currentState, pool.config.PriceBump)
+ inserted, old := list.Add(tx, pool.currentState, pool.config.PriceBump, pool.chainconfig, pool.currentHead)
  if !inserted {
  // An older transaction was better, discard this
  pool.all.Remove(hash)
@@ -1357,6 +1358,9 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
  pool.eip2718 = pool.chainconfig.IsCurie(next)
  pool.eip1559 = pool.chainconfig.IsCurie(next)
  pool.shanghai = pool.chainconfig.IsShanghai(next)
+
+ // Update current head
+ pool.currentHead = next
 }
 
 // promoteExecutables moves transactions that have become processable from the
@@ -1435,7 +1439,7 @@ func (pool *TxPool) executableTxFilter(costLimit *big.Int) func(tx *types.Transa
 
  if pool.chainconfig.Scroll.FeeVaultEnabled() {
  // recheck L1 data fee, as the oracle price may have changed
- l1DataFee, err := fees.CalculateL1DataFee(tx, pool.currentState)
+ l1DataFee, err := fees.CalculateL1DataFee(tx, pool.currentState, pool.chainconfig, pool.currentHead)
  if err != nil {
  log.Error("Failed to calculate L1 data fee", "err", err, "tx", tx)
  return false

eth/state_accessor.go

@@ -192,7 +192,7 @@ func (eth *Ethereum) stateAtTransaction(block *types.Block, txIndex int, reexec
  // Not yet the searched for transaction, execute on top of the current state
  vmenv := vm.NewEVM(context, txContext, statedb, eth.blockchain.Config(), vm.Config{})
  statedb.SetTxContext(tx.Hash(), idx)
- l1DataFee, err := fees.CalculateL1DataFee(tx, statedb)
+ l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, eth.blockchain.Config(), block.Number())
  if err != nil {
  return nil, vm.BlockContext{}, nil, err
  }

eth/tracers/api.go

@@ -285,7 +285,7 @@ func (api *API) traceChain(ctx context.Context, start, end *types.Block, config
  TxHash: tx.Hash(),
  }
 
- l1DataFee, err := fees.CalculateL1DataFee(tx, task.statedb)
+ l1DataFee, err := fees.CalculateL1DataFee(tx, task.statedb, api.backend.ChainConfig(), task.block.Number())
  if err != nil {
  // though it's not a "tracing error", we still need to put it here
  task.results[i] = &txTraceResult{Error: err.Error()}
@@ -545,7 +545,7 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config
  )
  statedb.SetTxContext(tx.Hash(), i)
 
- l1DataFee, err := fees.CalculateL1DataFee(tx, statedb)
+ l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, api.backend.ChainConfig(), block.Number())
  if err != nil {
  log.Warn("Tracing intermediate roots did not complete due to fees.CalculateL1DataFee", "txindex", i, "txhash", tx.Hash(), "err", err)
  return nil, err
@@ -626,7 +626,7 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
  TxHash: txs[task.index].Hash(),
  }
 
- l1DataFee, err := fees.CalculateL1DataFee(txs[task.index], task.statedb)
+ l1DataFee, err := fees.CalculateL1DataFee(txs[task.index], task.statedb, api.backend.ChainConfig(), block.Number())
  if err != nil {
  // though it's not a "tracing error", we still need to put it here
  results[task.index] = &txTraceResult{Error: err.Error()}
@@ -651,7 +651,7 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
  msg, _ := tx.AsMessage(signer, block.BaseFee())
  statedb.SetTxContext(tx.Hash(), i)
  vmenv := vm.NewEVM(blockCtx, core.NewEVMTxContext(msg), statedb, api.backend.ChainConfig(), vm.Config{})
- l1DataFee, err := fees.CalculateL1DataFee(tx, statedb)
+ l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, api.backend.ChainConfig(), block.Number())
  if err != nil {
  failed = err
  break
@@ -769,7 +769,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block
  // Execute the transaction and flush any traces to disk
  vmenv := vm.NewEVM(vmctx, txContext, statedb, chainConfig, vmConf)
  statedb.SetTxContext(tx.Hash(), i)
- l1DataFee, err := fees.CalculateL1DataFee(tx, statedb)
+ l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, api.backend.ChainConfig(), block.Number())
  if err == nil {
  _, err = core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.Gas()), l1DataFee)
  }
@@ -834,7 +834,7 @@ func (api *API) TraceTransaction(ctx context.Context, hash common.Hash, config *
  TxIndex: int(index),
  TxHash: hash,
  }
- l1DataFee, err := fees.CalculateL1DataFee(tx, statedb)
+ l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, api.backend.ChainConfig(), block.Number())
  if err != nil {
  return nil, err
  }
@@ -894,7 +894,7 @@ func (api *API) TraceCall(ctx context.Context, args ethapi.TransactionArgs, bloc
  }
 
  signer := types.MakeSigner(api.backend.ChainConfig(), block.Number())
- l1DataFee, err := fees.EstimateL1DataFeeForMessage(msg, block.BaseFee(), api.backend.ChainConfig().ChainID, signer, statedb)
+ l1DataFee, err := fees.EstimateL1DataFeeForMessage(msg, block.BaseFee(), api.backend.ChainConfig(), signer, statedb, block.Number())
  if err != nil {
  return nil, err
  }

eth/tracers/api_test.go

@@ -173,7 +173,7 @@ func (b *testBackend) StateAtTransaction(ctx context.Context, block *types.Block
  return msg, context, statedb, nil
  }
  vmenv := vm.NewEVM(context, txContext, statedb, b.chainConfig, vm.Config{})
- l1DataFee, err := fees.CalculateL1DataFee(tx, statedb)
+ l1DataFee, err := fees.CalculateL1DataFee(tx, statedb, b.chainConfig, block.Number())
  if err != nil {
  return nil, vm.BlockContext{}, nil, err
  }