london fork

Makefile

@@ -47,8 +47,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())

eth/filters/filter_system_test.go

@@ -174,7 +174,7 @@ func TestBlockSubscription(t *testing.T) {
  var (
  db = rawdb.NewMemoryDatabase()
  backend = &testBackend{db: db}
- api = NewPublicFilterAPI(backend, false, deadline)
+ api = NewPublicFilterAPI(backend, false, deadline, false)
  genesis = (&core.Genesis{BaseFee: big.NewInt(params.InitialBaseFee)}).MustCommit(db)
  chain, _ = core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, 10, func(i int, gen *core.BlockGen) {})
  chainEvents = []core.ChainEvent{}
@@ -226,7 +226,7 @@ func TestPendingTxFilter(t *testing.T) {
  var (
  db = rawdb.NewMemoryDatabase()
  backend = &testBackend{db: db}
- api = NewPublicFilterAPI(backend, false, deadline)
+ api = NewPublicFilterAPI(backend, false, deadline, false)
 
  transactions = []*types.Transaction{
  types.NewTransaction(0, common.HexToAddress("0xb794f5ea0ba39494ce83a213fffba74279579268"), new(big.Int), 0, new(big.Int), nil),
@@ -281,7 +281,7 @@ func TestLogFilterCreation(t *testing.T) {
  var (
  db = rawdb.NewMemoryDatabase()
  backend = &testBackend{db: db}
- api = NewPublicFilterAPI(backend, false, deadline)
+ api = NewPublicFilterAPI(backend, false, deadline, false)
 
  testCases = []struct {
  crit FilterCriteria
@@ -325,7 +325,7 @@ func TestInvalidLogFilterCreation(t *testing.T) {
  var (
  db = rawdb.NewMemoryDatabase()
  backend = &testBackend{db: db}
- api = NewPublicFilterAPI(backend, false, deadline)
+ api = NewPublicFilterAPI(backend, false, deadline, false)
  )
 
  // different situations where log filter creation should fail.
@@ -347,7 +347,7 @@ func TestInvalidGetLogsRequest(t *testing.T) {
  var (
  db = rawdb.NewMemoryDatabase()
  backend = &testBackend{db: db}
- api = NewPublicFilterAPI(backend, false, deadline)
+ api = NewPublicFilterAPI(backend, false, deadline, false)
  blockHash = common.HexToHash("0x1111111111111111111111111111111111111111111111111111111111111111")
  )
 
@@ -372,7 +372,7 @@ func TestLogFilter(t *testing.T) {
  var (
  db = rawdb.NewMemoryDatabase()
  backend = &testBackend{db: db}
- api = NewPublicFilterAPI(backend, false, deadline)
+ api = NewPublicFilterAPI(backend, false, deadline, false)
 
  firstAddr = common.HexToAddress("0x1111111111111111111111111111111111111111")
  secondAddr = common.HexToAddress("0x2222222222222222222222222222222222222222")
@@ -486,7 +486,7 @@ func TestPendingLogsSubscription(t *testing.T) {
  var (
  db = rawdb.NewMemoryDatabase()
  backend = &testBackend{db: db}
- api = NewPublicFilterAPI(backend, false, deadline)
+ api = NewPublicFilterAPI(backend, false, deadline, false)
 
  firstAddr = common.HexToAddress("0x1111111111111111111111111111111111111111")
  secondAddr = common.HexToAddress("0x2222222222222222222222222222222222222222")
@@ -670,7 +670,7 @@ func TestPendingTxFilterDeadlock(t *testing.T) {
  var (
  db = rawdb.NewMemoryDatabase()
  backend = &testBackend{db: db}
- api = NewPublicFilterAPI(backend, false, timeout)
+ api = NewPublicFilterAPI(backend, false, timeout, false)
  done = make(chan struct{})
  )
 

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.