From 1fbb6ef4441cc9408b5422140844690fb428f6d0 Mon Sep 17 00:00:00 2001 From: Ian Norden Date: Mon, 6 Jul 2020 01:00:50 -0500 Subject: [PATCH] unit tests for new basefee and gas target methods --- cmd/geth/retesteth.go | 5 +- consensus/misc/basefee.go | 4 +- consensus/misc/basefee_test.go | 324 +++++++++++++++++++++++++++++++++ core/chain_makers.go | 2 +- core/chain_makers_test.go | 12 +- core/state_prefetcher.go | 8 +- core/state_processor.go | 5 +- core/tx_list.go | 1 - core/tx_pool_test.go | 24 ++- light/txpool.go | 3 +- miner/worker.go | 2 +- params/config.go | 16 +- params/protocol_params.go | 12 +- tests/state_test_util.go | 5 +- 14 files changed, 372 insertions(+), 51 deletions(-) create mode 100644 consensus/misc/basefee_test.go diff --git a/cmd/geth/retesteth.go b/cmd/geth/retesteth.go index 8443abfab..a3e6aa194 100644 --- a/cmd/geth/retesteth.go +++ b/cmd/geth/retesteth.go @@ -502,9 +502,8 @@ func (api *RetestethAPI) mineBlock() error { } var gp1559 *core.GasPool - var gasPool *core.GasPool - // See core/gaspool.go for detials on how these gas limit values are calculated - gasPool = core.NewLegacyGasPool(api.chainConfig, header.Number, new(big.Int).SetUint64(header.GasLimit)) + // See core/gaspool.go for details on how these gas limit values are calculated + gasPool := core.NewLegacyGasPool(api.chainConfig, header.Number, new(big.Int).SetUint64(header.GasLimit)) if api.chainConfig.IsEIP1559(header.Number) { gp1559 = core.NewEIP1559GasPool(api.chainConfig, header.Number, new(big.Int).SetUint64(header.GasLimit)) } diff --git a/consensus/misc/basefee.go b/consensus/misc/basefee.go index 89f3f5bcf..f6d33be93 100644 --- a/consensus/misc/basefee.go +++ b/consensus/misc/basefee.go @@ -72,8 +72,8 @@ func CalcBaseFee(config *params.ChainConfig, parent *types.Header) *big.Int { } // Otherwise, - // BASEFEE = PARENT_BASEFEE + PARENT_BASEFEE * delta // EIP1559_GAS_TARGET // BASEFEE_MAX_CHANGE_DENOMINATOR - // Where delta = block.gas_used - EIP1559_GAS_TARGET + // BASEFEE = PARENT_BASEFEE + PARENT_BASEFEE * delta // PARENT_EIP1559_GAS_TARGET // BASEFEE_MAX_CHANGE_DENOMINATOR + // Where delta = parent.GasUsed - PARENT_EIP1559_GAS_TARGET parentGasTarget := CalcEIP1559GasTarget(config, parent.Number, new(big.Int).SetUint64(parent.GasLimit)) delta := new(big.Int).Sub(new(big.Int).SetUint64(parent.GasUsed), parentGasTarget) mul := new(big.Int).Mul(parent.BaseFee, delta) diff --git a/consensus/misc/basefee_test.go b/consensus/misc/basefee_test.go new file mode 100644 index 000000000..7ce2d30b1 --- /dev/null +++ b/consensus/misc/basefee_test.go @@ -0,0 +1,324 @@ +// Copyright 2017 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 . + +package misc + +import ( + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/params" +) + +// TestCalcEIP1559GasTarget tests that CalEIP1559GasTarget()returns the correct value +func TestCalcEIP1559GasTarget(t *testing.T) { + testConditions := []struct { + // Test inputs + config *params.ChainConfig + eip1559activation *big.Int + transitionDuration uint64 + height *big.Int + gasLimit *big.Int + // Expected result + eip1559GasTarget *big.Int + }{ + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(1), + big.NewInt(100000), + big.NewInt(0), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(999), + big.NewInt(100000), + big.NewInt(0), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(1000), + big.NewInt(100000), + big.NewInt(50000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(1001), + big.NewInt(100000), + big.NewInt(50050), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(1500), + big.NewInt(100000), + big.NewInt(75000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(1999), + big.NewInt(100000), + big.NewInt(99950), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(100000), + big.NewInt(100000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2001), + big.NewInt(100000), + big.NewInt(100000), + }, + } + for i, test := range testConditions { + config := *test.config + config.EIP1559Block = test.eip1559activation + config.EIP1559.MigrationBlockDuration = test.transitionDuration + config.EIP1559FinalizedBlock = new(big.Int).Add(config.EIP1559Block, new(big.Int).SetUint64(config.EIP1559.MigrationBlockDuration)) + gasTarget := CalcEIP1559GasTarget(&config, test.height, test.gasLimit) + if gasTarget.Cmp(test.eip1559GasTarget) != 0 { + t.Errorf("test %d expected EIP1559GasTarget %d got %d", i+1, test.eip1559GasTarget.Uint64(), gasTarget.Uint64()) + } + } +} + +// TestCalcBaseFee tests that CalcBaseFee()returns the correct value +func TestCalcBaseFee(t *testing.T) { + testConditions := []struct { + // Test inputs + config *params.ChainConfig + eip1559activation *big.Int + transitionDuration uint64 + parentHeight *big.Int + parentBaseFee *big.Int + parentGasLimit uint64 + parentGasUsed uint64 + // Expected result + baseFee *big.Int + }{ + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(1), + big.NewInt(1000000000), + 1000000, + 10000000, + nil, + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(999), + big.NewInt(1000000000), + 1000000, + 10000000, + new(big.Int).SetUint64(params.EIP1559ChainConfig.EIP1559.InitialBaseFee), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(1000), + big.NewInt(1000000000), + 1000000, + 10000000, + big.NewInt(1125000000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), // past finalization parentGasLimit is the EIP1559GasTarget + big.NewInt(1000000000), + 500000, + 10000000, + big.NewInt(1125000000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(1000000000), + 1000000, + 10000000, + big.NewInt(1125000000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(1000000000), + 6000000, + 10000000, + big.NewInt(1083333333), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(1000000000), + 7000000, + 10000000, + big.NewInt(1053571428), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(1000000000), + 8000000, + 10000000, + big.NewInt(1031250000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(1000000000), + 9000000, + 10000000, + big.NewInt(1013888888), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(1000000000), + 10000000, + 10000000, + big.NewInt(1000000000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(1000000000), + 11000000, + 10000000, + big.NewInt(988636363), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(900000000), + 1000000, + 10000000, + big.NewInt(1012500000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(1100000000), + 1000000, + 10000000, + big.NewInt(1237500000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(1200000000), + 1000000, + 10000000, + big.NewInt(1350000000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(1000000000), + 10000000, + 9000000, + big.NewInt(987500000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(1000000000), + 10000000, + 11000000, + big.NewInt(1012500000), + }, + { + params.EIP1559ChainConfig, + big.NewInt(1000), + 1000, + big.NewInt(2000), + big.NewInt(1000000000), + 10000000, + 12000000, + big.NewInt(1025000000), + }, + } + for i, test := range testConditions { + config := *test.config + config.EIP1559Block = test.eip1559activation + config.EIP1559.MigrationBlockDuration = test.transitionDuration + config.EIP1559FinalizedBlock = new(big.Int).Add(config.EIP1559Block, new(big.Int).SetUint64(config.EIP1559.MigrationBlockDuration)) + parent := &types.Header{ + GasLimit: test.parentGasLimit, + GasUsed: test.parentGasUsed, + Number: test.parentHeight, + BaseFee: test.parentBaseFee, + } + gasTarget := CalcBaseFee(&config, parent) + if gasTarget != nil { + if test.baseFee != nil && gasTarget.Cmp(test.baseFee) != 0 { + t.Errorf("test %d expected BaseFee %d got %d", i+1, test.baseFee.Uint64(), gasTarget.Uint64()) + } + if test.baseFee == nil { + t.Errorf("test %d expected nil BaseFee got %d", i+1, gasTarget.Uint64()) + } + } else if test.baseFee != nil { + t.Errorf("test %d expected BaseFee %d got nil", i+1, test.baseFee.Uint64()) + } + } +} diff --git a/core/chain_makers.go b/core/chain_makers.go index 50155f8bf..63acc8a1b 100644 --- a/core/chain_makers.go +++ b/core/chain_makers.go @@ -59,7 +59,7 @@ func (b *BlockGen) SetCoinbase(addr common.Address) { panic("coinbase can only be set once") } b.header.Coinbase = addr - // See core/gaspool.go for detials on how these gas limit values are calculated + // See core/gaspool.go for details on how these gas limit values are calculated b.gasPool = NewLegacyGasPool(b.config, b.header.Number, new(big.Int).SetUint64(b.header.GasLimit)) if b.config.IsEIP1559(b.header.Number) { b.gasPool1559 = NewEIP1559GasPool(b.config, b.header.Number, new(big.Int).SetUint64(b.header.GasLimit)) diff --git a/core/chain_makers_test.go b/core/chain_makers_test.go index b03712953..475404bf0 100644 --- a/core/chain_makers_test.go +++ b/core/chain_makers_test.go @@ -245,8 +245,8 @@ func generateChainDuringTransition(t *testing.T) { if state.GetBalance(addr1).Uint64() != 989000 { t.Fatalf("expected balance of addr1 to equal %d got %d", 989000, state.GetBalance(addr1).Uint64()) } - if state.GetBalance(addr2).Uint64() != 4917051584000 { - t.Fatalf("expected balance of addr2 to equal %d got %d", 10000, state.GetBalance(addr2).Uint64()) + if state.GetBalance(addr2).Uint64() != 4901403728000 { + t.Fatalf("expected balance of addr2 to equal %d got %d", 4901403728000, state.GetBalance(addr2).Uint64()) } // This value is different because the test config we use has Constantinople active (uses ConstantinopleBlockReward) bal, _ := new(big.Int).SetString("7875000000000001000", 10) @@ -389,11 +389,11 @@ func generateChainAfterFinalization2(t *testing.T) { if blockchain.CurrentBlock().Number().Uint64() != 5 { t.Fatalf("expected last block to equal %d got %d", 5, blockchain.CurrentBlock().Number().Uint64()) } - if state.GetBalance(addr1).Uint64() != 7542051573000 { - t.Fatalf("expected balance of addr1 to equal %d got %d", 7542051573000, state.GetBalance(addr1).Uint64()) + if state.GetBalance(addr1).Uint64() != 7536639348000 { + t.Fatalf("expected balance of addr1 to equal %d got %d", 7536639348000, state.GetBalance(addr1).Uint64()) } - if state.GetBalance(addr2).Uint64() != 4917051584000 { - t.Fatalf("expected balance of addr2 to equal %d got %d", 4917051584000, state.GetBalance(addr2).Uint64()) + if state.GetBalance(addr2).Uint64() != 4911639359000 { + t.Fatalf("expected balance of addr2 to equal %d got %d", 4911639359000, state.GetBalance(addr2).Uint64()) } // This value is different than in TestGenerateChain because the test config we use has Constantinople active (uses ConstantinopleBlockReward) bal, _ := new(big.Int).SetString("7875000000000001000", 10) diff --git a/core/state_prefetcher.go b/core/state_prefetcher.go index ba07ded05..180fcbb22 100644 --- a/core/state_prefetcher.go +++ b/core/state_prefetcher.go @@ -51,11 +51,11 @@ func newStatePrefetcher(config *params.ChainConfig, bc *BlockChain, engine conse // only goal is to pre-cache transaction signatures and state trie nodes. func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, cfg vm.Config, interrupt *uint32) { var ( - header = block.Header() - gp *GasPool - gp1559 *GasPool + header = block.Header() + gp *GasPool + gp1559 *GasPool ) - // See core/gaspool.go for detials on how these gas limit values are calculated + // See core/gaspool.go for details on how these gas limit values are calculated gp = NewLegacyGasPool(p.config, block.Number(), new(big.Int).SetUint64(block.GasLimit())) if p.config.IsEIP1559(block.Number()) { gp1559 = NewEIP1559GasPool(p.config, block.Number(), new(big.Int).SetUint64(block.GasLimit())) diff --git a/core/state_processor.go b/core/state_processor.go index 05901be95..9c676aa5e 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -17,6 +17,8 @@ package core import ( + "math/big" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus/misc" @@ -25,7 +27,6 @@ import ( "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/params" - "math/big" ) // StateProcessor is a basic Processor, which takes care of transitioning @@ -63,7 +64,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg gp *GasPool gp1559 *GasPool ) - // See core/gaspool.go for detials on how these gas limit values are calculated + // See core/gaspool.go for details on how these gas limit values are calculated gp = NewLegacyGasPool(p.config, block.Number(), new(big.Int).SetUint64(block.GasLimit())) if p.config.IsEIP1559(block.Number()) { gp1559 = NewEIP1559GasPool(p.config, block.Number(), new(big.Int).SetUint64(block.GasLimit())) diff --git a/core/tx_list.go b/core/tx_list.go index e7518401d..99af5f6bd 100644 --- a/core/tx_list.go +++ b/core/tx_list.go @@ -333,7 +333,6 @@ func (l *txList) Filter(costLimit *big.Int, legacyGasLimit, eip1559GasLimit uint l.costcap = new(big.Int).Set(costLimit) // Lower the caps to the thresholds l.legacyGasCap = legacyGasLimit l.eip1559GasCap = eip1559GasLimit - // Filter out all the transactions above the account's funds removed := l.txs.Filter(func(tx *types.Transaction) bool { return tx.Cost(baseFee).Cmp(costLimit) > 0 || (tx.GasPrice() != nil && tx.Gas() > legacyGasLimit) || (tx.GasPremium()) != nil && tx.Gas() > eip1559GasLimit diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go index 2069ac5fe..746488b62 100644 --- a/core/tx_pool_test.go +++ b/core/tx_pool_test.go @@ -920,11 +920,11 @@ func TestTransactionDoubleNonceEIP1559(t *testing.T) { resetState() signer := types.HomesteadSigner{} - tx1, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 100000, big.NewInt(5), nil, nil, nil), signer, key) + tx1, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 500000, big.NewInt(5), nil, nil, nil), signer, key) tx2, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 1000000, nil, nil, big.NewInt(2), big.NewInt(10)), signer, key) tx3, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 1000000, nil, nil, big.NewInt(1), big.NewInt(10)), signer, key) - tx4, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 1000000, big.NewInt(6), nil, nil, nil), signer, key) - tx5, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 1000000, big.NewInt(8), nil, nil, nil), signer, key) + tx4, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 100000, big.NewInt(6), nil, nil, nil), signer, key) + tx5, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 500000, big.NewInt(100), nil, nil, nil), signer, key) // Add the first two transaction, ensure higher priced stays only if replace, err := pool.add(tx1, false); err != nil || replace { @@ -975,7 +975,7 @@ func TestTransactionDoubleNonceEIP1559(t *testing.T) { t.Error("expected 1 pending transactions, got", pool.pending[addr].Len()) } if tx := pool.pending[addr].txs.items[0]; tx.Hash() != tx5.Hash() { - t.Errorf("transaction mismatch: have %x, want %x", tx.Hash(), tx2.Hash()) + t.Errorf("transaction mismatch: have %x, want %x", tx.Hash(), tx5.Hash()) } // Ensure the total transaction count is correct if pool.all.Count() != 1 { @@ -1298,7 +1298,7 @@ func TestTransactionDropping(t *testing.T) { } } -func TestTransactionDroppingEIP1559(t *testing.T) { +func TestTransactionDroppingEIP15591(t *testing.T) { t.Parallel() // Create a test account and fund it @@ -1370,22 +1370,20 @@ func TestTransactionDroppingEIP1559(t *testing.T) { t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), 4) } // Reduce the block gas limit, check that invalidated transactions are dropped - // After EIP1559 initialization, the legacy gas limit is `params.MaxGasEIP1559 - gasLimit` and the EIP1559 gas limit is `gasLimit` - // As such by reducing the `gasLimit` we increase the legacy gas limit, this must be accounted for in these tests (tx1 is not over-gased) - pool.chain.(*testBlockChain).gasLimit = 100 + pool.chain.(*testBlockChain).gasLimit = 200 <-pool.requestReset(nil, nil) if _, ok := pool.pending[account].txs.items[tx0.Nonce()]; !ok { t.Errorf("funded pending transaction missing: %v", tx0) } - if _, ok := pool.pending[account].txs.items[tx1.Nonce()]; !ok { - t.Errorf("funded pending transaction missing: %v", tx1) + if _, ok := pool.pending[account].txs.items[tx1.Nonce()]; ok { + t.Errorf("over-gased queued transaction present: %v", tx1) } if _, ok := pool.queue[account].txs.items[tx10.Nonce()]; !ok { t.Errorf("funded queued transaction missing: %v", tx10) } - if _, ok := pool.queue[account].txs.items[tx11.Nonce()]; ok { - t.Errorf("over-gased queued transaction present: %v", tx11) + if _, ok := pool.queue[account].txs.items[tx11.Nonce()]; !ok { + t.Errorf("funded queued transaction missing: %v", tx11) } if pool.all.Count() != 3 { t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), 3) @@ -1464,7 +1462,7 @@ func TestTransactionDroppingEIP1559Finalized(t *testing.T) { t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), 4) } // Reduce the block gas limit, check that invalidated transactions are dropped - pool.chain.(*testBlockChain).gasLimit = 100 + pool.chain.(*testBlockChain).gasLimit = 50 <-pool.requestReset(nil, nil) if _, ok := pool.pending[account].txs.items[tx0.Nonce()]; !ok { diff --git a/light/txpool.go b/light/txpool.go index c1905ef76..0826649b5 100644 --- a/light/txpool.go +++ b/light/txpool.go @@ -19,11 +19,12 @@ package light import ( "context" "fmt" - "github.com/ethereum/go-ethereum/consensus/misc" "math/big" "sync" "time" + "github.com/ethereum/go-ethereum/consensus/misc" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/rawdb" diff --git a/miner/worker.go b/miner/worker.go index 9d115f26b..93ac83d15 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -749,7 +749,7 @@ func (w *worker) commitTransactions(txs *types.TransactionsByPriceAndNonce, coin return true } - // See core/gaspool.go for detials on how these gas limit values are calculated + // See core/gaspool.go for details on how these gas limit values are calculated var eip1559GasLimit uint64 var legacyGasLimit uint64 diff --git a/params/config.go b/params/config.go index 601256cb8..b11b1ed69 100644 --- a/params/config.go +++ b/params/config.go @@ -358,19 +358,19 @@ type ChainConfig struct { } type EIP1559Config struct { - InitialBaseFee uint64 - ForkBlockNumber uint64 - ForkFinalizedBlockNumber uint64 - MigrationBlockDuration uint64 + InitialBaseFee uint64 + ForkBlockNumber uint64 + ForkFinalizedBlockNumber uint64 + MigrationBlockDuration uint64 EIP1559BaseFeeMaxChangeDenominator uint64 EIP1559SlackCoefficient uint64 } var DefaultEIP1559Config = &EIP1559Config{ - InitialBaseFee: EIP1559InitialBaseFee, - ForkBlockNumber: EIP1559ForkBlockNumber, - ForkFinalizedBlockNumber: EIP1559ForkFinalizedBlockNumber, - MigrationBlockDuration: EIP1559MigrationBlockDuration, + InitialBaseFee: EIP1559InitialBaseFee, + ForkBlockNumber: EIP1559ForkBlockNumber, + ForkFinalizedBlockNumber: EIP1559ForkFinalizedBlockNumber, + MigrationBlockDuration: EIP1559MigrationBlockDuration, EIP1559BaseFeeMaxChangeDenominator: EIP1559BaseFeeMaxChangeDenominator, EIP1559SlackCoefficient: EIP1559SlackCoefficient, } diff --git a/params/protocol_params.go b/params/protocol_params.go index ae8385fd7..b66df95d0 100644 --- a/params/protocol_params.go +++ b/params/protocol_params.go @@ -140,12 +140,12 @@ const ( Bls12381MapG1Gas uint64 = 5500 // Gas price for BLS12-381 mapping field element to G1 operation Bls12381MapG2Gas uint64 = 110000 // Gas price for BLS12-381 mapping field element to G2 operation - EIP1559InitialBaseFee uint64 = 1000000000 // Wei used as the initial BaseFee - EIP1559ForkBlockNumber uint64 = 110000000 // TBD - EIP1559MigrationBlockDuration uint64 = 800000 - EIP1559ForkFinalizedBlockNumber = EIP1559ForkBlockNumber + EIP1559MigrationBlockDuration - EIP1559BaseFeeMaxChangeDenominator uint64 = 8 - EIP1559SlackCoefficient uint64 = 2 + EIP1559InitialBaseFee uint64 = 1000000000 // Wei used as the initial BaseFee + EIP1559ForkBlockNumber uint64 = 110000000 // TBD + EIP1559MigrationBlockDuration uint64 = 800000 + EIP1559ForkFinalizedBlockNumber = EIP1559ForkBlockNumber + EIP1559MigrationBlockDuration + EIP1559BaseFeeMaxChangeDenominator uint64 = 8 + EIP1559SlackCoefficient uint64 = 2 ) // Gas discount table for BLS12-381 G1 and G2 multi exponentiation operations diff --git a/tests/state_test_util.go b/tests/state_test_util.go index 884e00eb0..fa5dcb03c 100644 --- a/tests/state_test_util.go +++ b/tests/state_test_util.go @@ -184,9 +184,8 @@ func (t *StateTest) RunNoVerify(subtest StateSubtest, vmconfig vm.Config, snapsh evm := vm.NewEVM(context, statedb, config, vmconfig) var gp1559 *core.GasPool - var gaspool *core.GasPool - // See core/gaspool.go for detials on how these gas limit values are calculated - gaspool = core.NewLegacyGasPool(config, block.Number(), new(big.Int).SetUint64(block.GasLimit())) + // See core/gaspool.go for details on how these gas limit values are calculated + gaspool := core.NewLegacyGasPool(config, block.Number(), new(big.Int).SetUint64(block.GasLimit())) if config.IsEIP1559(block.Number()) { gp1559 = core.NewEIP1559GasPool(config, block.Number(), new(big.Int).SetUint64(block.GasLimit())) }