diff --git a/core/blockchain_test.go b/core/blockchain_test.go index e73e08e9d..766058487 100644 --- a/core/blockchain_test.go +++ b/core/blockchain_test.go @@ -3520,7 +3520,7 @@ func TestCurieTransition(t *testing.T) { b, _ := json.Marshal(params.AllEthashProtocolChanges) json.Unmarshal(b, &config) config.CurieBlock = big.NewInt(2) - config.DarwinTime = nil + config.Morph203Time = nil var ( db = rawdb.NewMemoryDatabase() diff --git a/core/state_processor_test.go b/core/state_processor_test.go index db5cdcfbe..f9bda74d4 100644 --- a/core/state_processor_test.go +++ b/core/state_processor_test.go @@ -58,7 +58,7 @@ func TestStateProcessorErrors(t *testing.T) { ShanghaiBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), - DarwinTime: new(uint64), + Morph203Time: new(uint64), Ethash: new(params.EthashConfig), } signer = types.LatestSigner(config) diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 34b4b16ee..d90b8b3a3 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -35,8 +35,7 @@ import ( ) var ( - errPrecompileDisabled = errors.New("sha256, ripemd160, blake2f precompiles temporarily disabled") - errModexpUnsupportedInput = errors.New("modexp temporarily only accepts inputs of 32 bytes (256 bits) or less") + errPrecompileDisabled = errors.New("sha256, ripemd160, blake2f precompiles temporarily disabled") ) // PrecompiledContract is the basic interface for native Go contracts. The implementation @@ -125,6 +124,20 @@ var PrecompiledContractsBernoulli = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{9}): &blake2FDisabled{}, } +// PrecompiledContractsMorph203 contains the default set of pre-compiled Ethereum +// contracts used in the Morph203 release. +var PrecompiledContractsMorph203 = map[common.Address]PrecompiledContract{ + common.BytesToAddress([]byte{1}): &ecrecover{}, + common.BytesToAddress([]byte{2}): &sha256hash{}, + common.BytesToAddress([]byte{3}): &ripemd160hash{}, + common.BytesToAddress([]byte{4}): &dataCopy{}, + common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, + common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, + common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, + common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, + common.BytesToAddress([]byte{9}): &blake2F{}, +} + // PrecompiledContractsBLS contains the set of pre-compiled Ethereum // contracts specified in EIP-2537. These are exported for testing purposes. var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{ @@ -140,6 +153,7 @@ var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{ } var ( + PrecompiledAddressesMorph203 []common.Address PrecompiledAddressesBernoulli []common.Address PrecompiledAddressesArchimedes []common.Address PrecompiledAddressesBerlin []common.Address @@ -167,11 +181,16 @@ func init() { for k := range PrecompiledContractsBernoulli { PrecompiledAddressesBernoulli = append(PrecompiledAddressesBernoulli, k) } + for k := range PrecompiledContractsMorph203 { + PrecompiledAddressesMorph203 = append(PrecompiledAddressesMorph203, k) + } } // ActivePrecompiles returns the precompiles enabled with the current configuration. func ActivePrecompiles(rules params.Rules) []common.Address { switch { + case rules.IsMorph203: + return PrecompiledAddressesMorph203 case rules.IsBernoulli: return PrecompiledAddressesBernoulli case rules.IsArchimedes: @@ -437,11 +456,6 @@ func (c *bigModExp) Run(input []byte) ([]byte, error) { expLen = expLenBigInt.Uint64() modLen = modLenBigInt.Uint64() ) - // Check that all inputs are `u256` (32 - bytes) or less, revert otherwise - var lenLimit = new(big.Int).SetInt64(32) - if baseLenBigInt.Cmp(lenLimit) > 0 || expLenBigInt.Cmp(lenLimit) > 0 || modLenBigInt.Cmp(lenLimit) > 0 { - return nil, errModexpUnsupportedInput - } if len(input) > 96 { input = input[96:] } else { @@ -578,10 +592,6 @@ var ( // runBn256Pairing implements the Bn256Pairing precompile, referenced by both // Byzantium and Istanbul operations. func runBn256Pairing(input []byte) ([]byte, error) { - // Allow at most 4 inputs - if len(input) > 4*192 { - return nil, errBadPairingInput - } // Handle some corner cases cheaply if len(input)%192 > 0 { return nil, errBadPairingInput diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index c4eb04832..11d5252a0 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -74,8 +74,6 @@ func NewEVMInterpreter(evm *EVM, cfg Config) *EVMInterpreter { if cfg.JumpTable[STOP] == nil { var jt JumpTable switch { - case evm.chainRules.IsDarwin: - jt = darwinInstructionSet case evm.chainRules.IsCurie: jt = curieInstructionSet case evm.chainRules.IsShanghai: diff --git a/core/vm/jump_table.go b/core/vm/jump_table.go index ddefbfc74..dc1bed741 100644 --- a/core/vm/jump_table.go +++ b/core/vm/jump_table.go @@ -60,19 +60,11 @@ var ( londonInstructionSet = newLondonInstructionSet() shanghaiInstructionSet = newShanghaiInstructionSet() curieInstructionSet = newCurieInstructionSet() - darwinInstructionSet = newDarwinInstructionSet() ) // JumpTable contains the EVM opcodes supported at a given fork. type JumpTable [256]*operation -// newDarwinInstructionSet returns the frontier, homestead, byzantium, -// contantinople, istanbul, petersburg, berlin, london, shanghai, curie, and darwin instructions. -func newDarwinInstructionSet() JumpTable { - instructionSet := newCurieInstructionSet() - return instructionSet -} - // newCurieInstructionSet returns the frontier, homestead, byzantium, // contantinople, istanbul, petersburg, berlin, london, shanghai, and curie instructions. func newCurieInstructionSet() JumpTable { diff --git a/core/vm/runtime/runtime.go b/core/vm/runtime/runtime.go index c15d68868..0be0c6558 100644 --- a/core/vm/runtime/runtime.go +++ b/core/vm/runtime/runtime.go @@ -72,7 +72,7 @@ func setDefaults(cfg *Config) { ShanghaiBlock: new(big.Int), BernoulliBlock: new(big.Int), CurieBlock: new(big.Int), - DarwinTime: new(uint64), + Morph203Time: new(uint64), } } diff --git a/eth/gasprice/gasprice_test.go b/eth/gasprice/gasprice_test.go index c250ad662..552b43572 100644 --- a/eth/gasprice/gasprice_test.go +++ b/eth/gasprice/gasprice_test.go @@ -114,7 +114,7 @@ func newTestBackend(t *testing.T, londonBlock *big.Int, pending bool) *testBacke config.ShanghaiBlock = londonBlock config.BernoulliBlock = londonBlock config.CurieBlock = londonBlock - config.DarwinTime = nil + config.Morph203Time = nil engine := ethash.NewFaker() db := rawdb.NewMemoryDatabase() genesis, err := gspec.Commit(db) diff --git a/params/config.go b/params/config.go index 48c6755f8..93a939f58 100644 --- a/params/config.go +++ b/params/config.go @@ -281,7 +281,7 @@ var ( ShanghaiBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(6330180), - DarwinTime: nil, + Morph203Time: nil, TerminalTotalDifficulty: big.NewInt(0), Morph: MorphConfig{ UseZktrie: true, @@ -311,7 +311,7 @@ var ( ShanghaiBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), - DarwinTime: nil, + Morph203Time: nil, TerminalTotalDifficulty: big.NewInt(0), Morph: MorphConfig{ UseZktrie: true, @@ -347,7 +347,7 @@ var ( ShanghaiBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), - DarwinTime: new(uint64), + Morph203Time: new(uint64), TerminalTotalDifficulty: nil, Ethash: new(EthashConfig), Clique: nil, @@ -383,7 +383,7 @@ var ( ShanghaiBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), - DarwinTime: new(uint64), + Morph203Time: new(uint64), TerminalTotalDifficulty: nil, Ethash: nil, Clique: &CliqueConfig{Period: 0, Epoch: 30000}, @@ -414,7 +414,7 @@ var ( ShanghaiBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), - DarwinTime: new(uint64), + Morph203Time: new(uint64), TerminalTotalDifficulty: nil, Ethash: new(EthashConfig), Clique: nil, @@ -446,7 +446,7 @@ var ( ShanghaiBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), - DarwinTime: new(uint64), + Morph203Time: new(uint64), TerminalTotalDifficulty: nil, Ethash: new(EthashConfig), Clique: nil, @@ -537,7 +537,7 @@ type ChainConfig struct { ShanghaiBlock *big.Int `json:"shanghaiBlock,omitempty"` // Shanghai switch block (nil = no fork, 0 = already on shanghai) BernoulliBlock *big.Int `json:"bernoulliBlock,omitempty"` // Bernoulli switch block (nil = no fork, 0 = already on bernoulli) CurieBlock *big.Int `json:"curieBlock,omitempty"` // Curie switch block (nil = no fork, 0 = already on curie) - DarwinTime *uint64 `json:"darwinTime,omitempty"` // Darwin switch time (nil = no fork, 0 = already on darwin) + Morph203Time *uint64 `json:"morph203Time,omitempty"` // Morph203Time switch time (nil = no fork, 0 = already on morph203) // TerminalTotalDifficulty is the amount of total difficulty reached by // the network that triggers the consensus upgrade. @@ -630,7 +630,7 @@ func (c *ChainConfig) String() string { default: engine = "unknown" } - return fmt.Sprintf("{ChainID: %v Homestead: %v DAO: %v DAOSupport: %v EIP150: %v EIP155: %v EIP158: %v Byzantium: %v Constantinople: %v Petersburg: %v Istanbul: %v, Muir Glacier: %v, Berlin: %v, London: %v, Arrow Glacier: %v, Archimedes: %v, Shanghai: %v, Bernoulli: %v, Curie: %v, Darwin: %v, Engine: %v, Morph config: %v}", + return fmt.Sprintf("{ChainID: %v Homestead: %v DAO: %v DAOSupport: %v EIP150: %v EIP155: %v EIP158: %v Byzantium: %v Constantinople: %v Petersburg: %v Istanbul: %v, Muir Glacier: %v, Berlin: %v, London: %v, Arrow Glacier: %v, Archimedes: %v, Shanghai: %v, Bernoulli: %v, Curie: %v, Morph203: %v, Engine: %v, Morph config: %v}", c.ChainID, c.HomesteadBlock, c.DAOForkBlock, @@ -650,7 +650,7 @@ func (c *ChainConfig) String() string { c.ShanghaiBlock, c.BernoulliBlock, c.CurieBlock, - c.DarwinTime, + c.Morph203Time, engine, c.Morph, ) @@ -743,9 +743,9 @@ func (c *ChainConfig) IsCurie(num *big.Int) bool { return isForked(c.CurieBlock, num) } -// IsDarwin returns whether num is either equal to the Darwin fork block or greater. -func (c *ChainConfig) IsDarwin(now uint64) bool { - return isForkedTime(now, c.DarwinTime) +// IsMorph203 returns whether num is either equal to the Morph203 fork block or greater. +func (c *ChainConfig) IsMorph203(now uint64) bool { + return isForkedTime(now, c.Morph203Time) } // IsTerminalPoWBlock returns whether the given block is the last block of PoW stage. @@ -778,9 +778,10 @@ func (c *ChainConfig) CheckCompatible(newcfg *ChainConfig, height uint64) *Confi // to guarantee that forks can be implemented in a different order than on official networks func (c *ChainConfig) CheckConfigForkOrder() error { type fork struct { - name string - block *big.Int - optional bool // if true, the fork may be nil and next fork is still allowed + name string + block *big.Int + timestamp *uint64 // forks after the merge are scheduled using timestamps + optional bool // if true, the fork may be nil and next fork is still allowed } var lastFork fork for _, cur := range []fork{ @@ -801,22 +802,39 @@ func (c *ChainConfig) CheckConfigForkOrder() error { {name: "shanghaiBlock", block: c.ShanghaiBlock, optional: true}, {name: "bernoulliBlock", block: c.BernoulliBlock, optional: true}, {name: "curieBlock", block: c.CurieBlock, optional: true}, + {name: "morph203Time", timestamp: c.Morph203Time, optional: true}, } { if lastFork.name != "" { - // Next one must be higher number - if lastFork.block == nil && cur.block != nil { - return fmt.Errorf("unsupported fork ordering: %v not enabled, but %v enabled at %v", - lastFork.name, cur.name, cur.block) - } - if lastFork.block != nil && cur.block != nil { - if lastFork.block.Cmp(cur.block) > 0 { - return fmt.Errorf("unsupported fork ordering: %v enabled at %v, but %v enabled at %v", + switch { + // Non-optional forks must all be present in the chain config up to the last defined fork + case lastFork.block == nil && lastFork.timestamp == nil && (cur.block != nil || cur.timestamp != nil): + if cur.block != nil { + return fmt.Errorf("unsupported fork ordering: %v not enabled, but %v enabled at block %v", + lastFork.name, cur.name, cur.block) + } else { + return fmt.Errorf("unsupported fork ordering: %v not enabled, but %v enabled at timestamp %v", + lastFork.name, cur.name, *cur.timestamp) + } + + // Fork (whether defined by block or timestamp) must follow the fork definition sequence + case (lastFork.block != nil && cur.block != nil) || (lastFork.timestamp != nil && cur.timestamp != nil): + if lastFork.block != nil && lastFork.block.Cmp(cur.block) > 0 { + return fmt.Errorf("unsupported fork ordering: %v enabled at block %v, but %v enabled at block %v", lastFork.name, lastFork.block, cur.name, cur.block) + } else if lastFork.timestamp != nil && *lastFork.timestamp > *cur.timestamp { + return fmt.Errorf("unsupported fork ordering: %v enabled at timestamp %v, but %v enabled at timestamp %v", + lastFork.name, *lastFork.timestamp, cur.name, *cur.timestamp) + } + + // Timestamp based forks can follow block based ones, but not the other way around + if lastFork.timestamp != nil && cur.block != nil { + return fmt.Errorf("unsupported fork ordering: %v used timestamp ordering, but %v reverted to block ordering", + lastFork.name, cur.name) } } } // If it was optional and not set, then ignore it - if !cur.optional || cur.block != nil { + if !cur.optional || (cur.block != nil || cur.timestamp != nil) { lastFork = cur } } @@ -960,7 +978,7 @@ type Rules struct { IsHomestead, IsEIP150, IsEIP155, IsEIP158 bool IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul bool IsBerlin, IsLondon, IsArchimedes, IsShanghai bool - IsBernoulli, IsCurie, IsDarwin bool + IsBernoulli, IsCurie, IsMorph203 bool } // Rules ensures c's ChainID is not nil. @@ -985,6 +1003,6 @@ func (c *ChainConfig) Rules(num *big.Int, time uint64) Rules { IsShanghai: c.IsShanghai(num), IsBernoulli: c.IsBernoulli(num), IsCurie: c.IsCurie(num), - IsDarwin: c.IsDarwin(time), + IsMorph203: c.IsMorph203(time), } } diff --git a/params/version.go b/params/version.go index 100539112..b161be4fb 100644 --- a/params/version.go +++ b/params/version.go @@ -22,9 +22,9 @@ import ( ) const ( - VersionMajor = 5 // Major version component of the current release - VersionMinor = 5 // Minor version component of the current release - VersionPatch = 1 // Patch version component of the current release + VersionMajor = 2 // Major version component of the current release + VersionMinor = 0 // Minor version component of the current release + VersionPatch = 3 // Patch version component of the current release VersionMeta = "mainnet" // Version metadata to append to the version string )