feat: add preDeployedContract hardfork (bnb-chain#5)

* feat: add preDeployedContract hardfork to modify WBNB contract name/symbol and remove GovernanceToken

* fix: remove useless IsPreContractBlock

cmd/evm/internal/t8ntool/execution.go

@@ -162,6 +162,10 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
  misc.ApplyDAOHardFork(statedb)
  }
 
+ if chainConfig.PreContractForkBlock != nil && chainConfig.PreContractForkBlock.Cmp(new(big.Int).SetUint64(pre.Env.Number)) == 0 {
+ misc.ApplyPreContractHardFork(statedb)
+ }
+
  for i, tx := range txs {
  msg, err := core.TransactionToMessage(tx, signer, pre.Env.BaseFee)
  if err != nil {

consensus/misc/precontract.go

@@ -0,0 +1,42 @@
+// Copyright 2016 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 misc
+
+import (
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/state"
+)
+
+var (
+ // WBNBContract WBNB preDeploy contract address
+ WBNBContract = common.HexToAddress("0x4200000000000000000000000000000000000006")
+ // GovernanceToken contract address
+ governanceToken = common.HexToAddress("4200000000000000000000000000000000000042")
+ nameSlot = common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000")
+ symbolSlot = common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001")
+ // Wrapped BNB
+ nameValue = common.HexToHash("0x5772617070656420424e42000000000000000000000000000000000000000016")
+ // WBNB
+ symbolValue = common.HexToHash("0x57424e4200000000000000000000000000000000000000000000000000000008")
+)
+
+// ApplyPreContractHardFork modifies the state database according to the hard-fork rules
+func ApplyPreContractHardFork(statedb *state.StateDB) {
+ statedb.SetState(WBNBContract, nameSlot, nameValue)
+ statedb.SetState(WBNBContract, symbolSlot, symbolValue)
+ statedb.Suicide(governanceToken)
+}

core/chain_makers.go

@@ -310,6 +310,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.PreContractForkBlock != nil && config.PreContractForkBlock.Cmp(b.header.Number) == 0 {
+ misc.ApplyPreContractHardFork(statedb)
+ }
  // Execute any user modifications to the block
  if gen != nil {
  gen(i, b)

core/state_processor.go

@@ -70,6 +70,9 @@ 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)
  }
+ if p.config.PreContractForkBlock != nil && p.config.PreContractForkBlock.Cmp(block.Number()) == 0 {
+ misc.ApplyPreContractHardFork(statedb)
+ }
  blockContext := NewEVMBlockContext(header, p.bc, nil, p.config, statedb)
  vmenv := vm.NewEVM(blockContext, vm.TxContext{}, statedb, p.config, cfg)
  // Iterate over and process the individual transactions

miner/worker.go

@@ -1176,6 +1176,10 @@ func (w *worker) generateWork(genParams *generateParams) (*types.Block, *big.Int
  return nil, nil, nil, err
  }
  defer work.discard()
+
+ if w.chainConfig.PreContractForkBlock != nil && work.header.Number.Cmp(w.chainConfig.PreContractForkBlock) == 0 {
+ misc.ApplyPreContractHardFork(work.state)
+ }
  if work.gasPool == nil {
  work.gasPool = new(core.GasPool).AddGas(work.header.GasLimit)
  }

params/config.go

@@ -476,6 +476,8 @@ type ChainConfig struct {
 
  // Optimism config, nil if not active
  Optimism *OptimismConfig `json:"optimism,omitempty"`
+ // PreContractForkBlock hard-fork switch block (nil = no fork, 0 = already on preContractForkBlock)
+ PreContractForkBlock *big.Int `json:"preContractForkBlock,omitempty"`
 }
 
 // EthashConfig is the consensus engine configs for proof-of-work based sealing.
@@ -599,6 +601,9 @@ func (c *ChainConfig) Description() string {
  if c.RegolithTime != nil {
  banner += fmt.Sprintf(" - Regolith: @%-10v\n", *c.RegolithTime)
  }
+ if c.PreContractForkBlock != nil {
+ banner += fmt.Sprintf(" - PreContractForkBlock: @%-10v\n", *c.PreContractForkBlock)
+ }
  return banner
 }