london fork (ethereum#260)

* london fork changes

* Update version.go

* burn contract address

Makefile

@@ -50,8 +50,8 @@ ios:
 
 test: all
 	# $(GORUN) build/ci.go test
-	go test github.com/ethereum/go-ethereum/consensus/bor
-	go test github.com/ethereum/go-ethereum/tests/bor
+	go test github.com/ethereum/go-ethereum/consensus/bor -v
+	go test github.com/ethereum/go-ethereum/tests/bor -v
 
 lint: ## Run linters.
 	$(GORUN) build/ci.go lint

consensus/bor/bor.go

@@ -182,12 +182,12 @@ func encodeSigHeader(w io.Writer, header *types.Header) {
 func CalcProducerDelay(number uint64, succession int, c *params.BorConfig) uint64 {
 	// When the block is the first block of the sprint, it is expected to be delayed by `producerDelay`.
 	// That is to allow time for block propagation in the last sprint
-	delay := c.Period
+	delay := c.CalculatePeriod(number)
 	if number%c.Sprint == 0 {
 		delay = c.ProducerDelay
 	}
 	if succession > 0 {
-		delay += uint64(succession) * c.BackupMultiplier
+		delay += uint64(succession) * c.CalculateBackupMultiplier(number)
 	}
 	return delay
 }
@@ -353,6 +353,11 @@ func (c *Bor) verifyHeader(chain consensus.ChainHeaderReader, header *types.Head
 			return errInvalidDifficulty
 		}
 	}
+	// Verify that the gas limit is <= 2^63-1
+	cap := uint64(0x7fffffffffffffff)
+	if header.GasLimit > cap {
+		return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, cap)
+	}
 	// If all checks passed, validate any special fields for hard forks
 	if err := misc.VerifyForkHashes(chain.Config(), header, false); err != nil {
 		return err
@@ -396,7 +401,24 @@ func (c *Bor) verifyCascadingFields(chain consensus.ChainHeaderReader, header *t
 		return consensus.ErrUnknownAncestor
 	}
 
-	if parent.Time+c.config.Period > header.Time {
+	// Verify that the gasUsed is <= gasLimit
+	if header.GasUsed > header.GasLimit {
+		return fmt.Errorf("invalid gasUsed: have %d, gasLimit %d", header.GasUsed, header.GasLimit)
+	}
+	if !chain.Config().IsLondon(header.Number) {
+		// Verify BaseFee not present before EIP-1559 fork.
+		if header.BaseFee != nil {
+			return fmt.Errorf("invalid baseFee before fork: have %d, want <nil>", header.BaseFee)
+		}
+		if err := misc.VerifyGaslimit(parent.GasLimit, header.GasLimit); err != nil {
+			return err
+		}
+	} else if err := misc.VerifyEip1559Header(chain.Config(), parent, header); err != nil {
+		// Verify the header's EIP-1559 attributes.
+		return err
+	}
+
+	if parent.Time+c.config.CalculatePeriod(number) > header.Time {
 		return ErrInvalidTimestamp
 	}
 
@@ -791,7 +813,7 @@ func (c *Bor) Seal(chain consensus.ChainHeaderReader, block *types.Block, result
 		return errUnknownBlock
 	}
 	// For 0-period chains, refuse to seal empty blocks (no reward but would spin sealing)
-	if c.config.Period == 0 && len(block.Transactions()) == 0 {
+	if c.config.CalculatePeriod(number) == 0 && len(block.Transactions()) == 0 {
 		log.Info("Sealing paused, waiting for transactions")
 		return nil
 	}
@@ -819,7 +841,7 @@ func (c *Bor) Seal(chain consensus.ChainHeaderReader, block *types.Block, result
 	// Sweet, the protocol permits us to sign the block, wait for our time
 	delay := time.Unix(int64(header.Time), 0).Sub(time.Now()) // nolint: gosimple
 	// wiggle was already accounted for in header.Time, this is just for logging
-	wiggle := time.Duration(successionNumber) * time.Duration(c.config.BackupMultiplier) * time.Second
+	wiggle := time.Duration(successionNumber) * time.Duration(c.config.CalculateBackupMultiplier(number)) * time.Second
 
 	// Sign all the things!
 	sighash, err := signFn(accounts.Account{Address: signer}, accounts.MimetypeBor, BorRLP(header))

core/state_transition.go

@@ -337,6 +337,11 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 		effectiveTip = cmath.BigMin(st.gasTipCap, new(big.Int).Sub(st.gasFeeCap, st.evm.Context.BaseFee))
 	}
 	amount := new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), effectiveTip)
+	if london {
+		burntContractAddress := common.HexToAddress(st.evm.ChainConfig().Bor.CalculateBurntContract(st.evm.Context.BlockNumber.Uint64()))
+		burnAmount := new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.evm.Context.BaseFee)
+		st.state.AddBalance(burntContractAddress, burnAmount)
+	}
 	st.state.AddBalance(st.evm.Context.Coinbase, amount)
 	output1 := new(big.Int).SetBytes(input1.Bytes())
 	output2 := new(big.Int).SetBytes(input2.Bytes())

internal/ethapi/bor_api.go

@@ -31,7 +31,7 @@ func (s *PublicBlockChainAPI) appendRPCMarshalBorTransaction(ctx context.Context
 		if borTx != nil {
 			formattedTxs := fields["transactions"].([]interface{})
 			if fullTx {
-				marshalledTx := newRPCTransaction(borTx, blockHash, blockNumber, txIndex, nil, s.b.ChainConfig())
+				marshalledTx := newRPCTransaction(borTx, blockHash, blockNumber, txIndex, block.BaseFee(), s.b.ChainConfig())
 				// newRPCTransaction calculates hash based on RLP of the transaction data.
 				// In case of bor block tx, we need simple derived tx hash (same as function argument) instead of RLP hash
 				marshalledTx.Hash = txHash

params/config.go

@@ -20,6 +20,8 @@ import (
 	"encoding/binary"
 	"fmt"
 	"math/big"
+	"sort"
+	"strconv"
 
 	"github.com/ethereum/go-ethereum/common"
 	"golang.org/x/crypto/sha3"
@@ -222,6 +224,40 @@ var (
 		Threshold: 2,
 	}
 
+	// BorTestChainConfig contains the chain parameters to run a node on the Test network.
+	BorTestChainConfig = &ChainConfig{
+		ChainID:             big.NewInt(80001),
+		HomesteadBlock:      big.NewInt(0),
+		DAOForkBlock:        nil,
+		DAOForkSupport:      true,
+		EIP150Hash:          common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
+		EIP150Block:         big.NewInt(0),
+		EIP155Block:         big.NewInt(0),
+		EIP158Block:         big.NewInt(0),
+		ByzantiumBlock:      big.NewInt(0),
+		ConstantinopleBlock: big.NewInt(0),
+		PetersburgBlock:     big.NewInt(0),
+		IstanbulBlock:       big.NewInt(0),
+		MuirGlacierBlock:    big.NewInt(0),
+		BerlinBlock:         big.NewInt(0),
+		LondonBlock:         big.NewInt(0),
+		Bor: &BorConfig{
+			Period: map[string]uint64{
+				"0": 2,
+			},
+			ProducerDelay: 6,
+			Sprint:        64,
+			BackupMultiplier: map[string]uint64{
+				"0": 2,
+			},
+			ValidatorContract:     "0x0000000000000000000000000000000000001000",
+			StateReceiverContract: "0x0000000000000000000000000000000000001001",
+			BurntContract: map[string]string{
+				"0": "0x00000000000000000000000000000000000000000",
+			},
+		},
+	}
+
 	// MumbaiChainConfig contains the chain parameters to run a node on the Mumbai test network.
 	MumbaiChainConfig = &ChainConfig{
 		ChainID:             big.NewInt(80001),
@@ -238,13 +274,21 @@ var (
 		IstanbulBlock:       big.NewInt(2722000),
 		MuirGlacierBlock:    big.NewInt(2722000),
 		BerlinBlock:         big.NewInt(13996000),
+		LondonBlock:         big.NewInt(22640000),
 		Bor: &BorConfig{
-			Period:                2,
-			ProducerDelay:         6,
-			Sprint:                64,
-			BackupMultiplier:      2,
+			Period: map[string]uint64{
+				"0": 2,
+			},
+			ProducerDelay: 6,
+			Sprint:        64,
+			BackupMultiplier: map[string]uint64{
+				"0": 2,
+			},
 			ValidatorContract:     "0x0000000000000000000000000000000000001000",
 			StateReceiverContract: "0x0000000000000000000000000000000000001001",
+			BurntContract: map[string]string{
+				"22640000": "0x70bcA57F4579f58670aB2d18Ef16e02C17553C38",
+			},
 			BlockAlloc: map[string]interface{}{
 				// write as interface since that is how it is decoded in genesis
 				"22244000": map[string]interface{}{
@@ -272,11 +316,16 @@ var (
 		IstanbulBlock:       big.NewInt(3395000),
 		MuirGlacierBlock:    big.NewInt(3395000),
 		BerlinBlock:         big.NewInt(14750000),
+		LondonBlock:         big.NewInt(0), // TODO - Add london fork block
 		Bor: &BorConfig{
-			Period:                2,
-			ProducerDelay:         6,
-			Sprint:                64,
-			BackupMultiplier:      2,
+			Period: map[string]uint64{
+				"0": 2,
+			},
+			ProducerDelay: 6,
+			Sprint:        64,
+			BackupMultiplier: map[string]uint64{
+				"0": 2,
+			},
 			ValidatorContract:     "0x0000000000000000000000000000000000001000",
 			StateReceiverContract: "0x0000000000000000000000000000000000001001",
 			OverrideStateSyncRecords: map[string]int{
@@ -290,6 +339,9 @@ var (
 				"14953792": 0,
 				"14953856": 0,
 			},
+			BurntContract: map[string]string{
+				"0": "0x0000000000000000000000000000000000000000",
+			}, // TODO add london fork contract and block
 			BlockAlloc: map[string]interface{}{
 				// write as interface since that is how it is decoded in genesis
 				"22156660": map[string]interface{}{
@@ -426,22 +478,62 @@ func (c *CliqueConfig) String() string {
 
 // BorConfig is the consensus engine configs for Matic bor based sealing.
 type BorConfig struct {
-	Period                uint64 `json:"period"`                // Number of seconds between blocks to enforce
-	ProducerDelay         uint64 `json:"producerDelay"`         // Number of seconds delay between two producer interval
-	Sprint                uint64 `json:"sprint"`                // Epoch length to proposer
-	BackupMultiplier      uint64 `json:"backupMultiplier"`      // Backup multiplier to determine the wiggle time
-	ValidatorContract     string `json:"validatorContract"`     // Validator set contract
-	StateReceiverContract string `json:"stateReceiverContract"` // State receiver contract
-
+	Period                   map[string]uint64      `json:"period"`                   // Number of seconds between blocks to enforce
+	ProducerDelay            uint64                 `json:"producerDelay"`            // Number of seconds delay between two producer interval
+	Sprint                   uint64                 `json:"sprint"`                   // Epoch length to proposer
+	BackupMultiplier         map[string]uint64      `json:"backupMultiplier"`         // Backup multiplier to determine the wiggle time
+	ValidatorContract        string                 `json:"validatorContract"`        // Validator set contract
+	StateReceiverContract    string                 `json:"stateReceiverContract"`    // State receiver contract
 	OverrideStateSyncRecords map[string]int         `json:"overrideStateSyncRecords"` // override state records count
 	BlockAlloc               map[string]interface{} `json:"blockAlloc"`
+	BurntContract            map[string]string      `json:"burntContract"` // governance contract where the token will be sent to and burnt in london fork
 }
 
 // String implements the stringer interface, returning the consensus engine details.
 func (b *BorConfig) String() string {
 	return "bor"
 }
 
+func (c *BorConfig) CalculateBackupMultiplier(number uint64) uint64 {
+	return c.calculateBorConfigHelper(c.BackupMultiplier, number)
+}
+
+func (c *BorConfig) CalculatePeriod(number uint64) uint64 {
+	return c.calculateBorConfigHelper(c.Period, number)
+}
+
+func (c *BorConfig) calculateBorConfigHelper(field map[string]uint64, number uint64) uint64 {
+	keys := make([]string, 0, len(field))
+	for k := range field {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for i := 0; i < len(keys)-1; i++ {
+		valUint, _ := strconv.ParseUint(keys[i], 10, 64)
+		valUintNext, _ := strconv.ParseUint(keys[i+1], 10, 64)
+		if number > valUint && number < valUintNext {
+			return field[keys[i]]
+		}
+	}
+	return field[keys[len(keys)-1]]
+}
+
+func (c *BorConfig) CalculateBurntContract(number uint64) string {
+	keys := make([]string, 0, len(c.BurntContract))
+	for k := range c.BurntContract {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for i := 0; i < len(keys)-1; i++ {
+		valUint, _ := strconv.ParseUint(keys[i], 10, 64)
+		valUintNext, _ := strconv.ParseUint(keys[i+1], 10, 64)
+		if number > valUint && number < valUintNext {
+			return c.BurntContract[keys[i]]
+		}
+	}
+	return c.BurntContract[keys[len(keys)-1]]
+}
+
 // String implements the fmt.Stringer interface.
 func (c *ChainConfig) String() string {
 	var engine interface{}

params/version.go

@@ -23,8 +23,8 @@ import (
 const (
 	VersionMajor = 0        // Major version component of the current release
 	VersionMinor = 2        // Minor version component of the current release
-	VersionPatch = 12       // Patch version component of the current release
-	VersionMeta  = "stable" // Version metadata to append to the version string
+	VersionPatch = 13       // Patch version component of the current release
+	VersionMeta  = "beta"   // Version metadata to append to the version string
 )
 
 // Version holds the textual version string.