jaipur fork (ethereum#269)

* jaipur fork

* add check

* review comments

* test case

* fix few changes

* Change condition

* review comments

* type conversion

* Update mumbai.go

* Update config.go

* Update config.go

Co-authored-by: Ferran Borreguero <ferranbt@protonmail.com>

command/server/chains/mainnet.go

@@ -28,10 +28,14 @@ var mainnetBor = &Chain{
 			MuirGlacierBlock:    big.NewInt(3395000),
 			BerlinBlock:         big.NewInt(14750000),
 			Bor: &params.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{

consensus/bor/bor.go

@@ -123,7 +123,7 @@ var (
 type SignerFn func(accounts.Account, string, []byte) ([]byte, error)
 
 // ecrecover extracts the Ethereum account address from a signed header.
-func ecrecover(header *types.Header, sigcache *lru.ARCCache) (common.Address, error) {
+func ecrecover(header *types.Header, sigcache *lru.ARCCache, c *params.BorConfig) (common.Address, error) {
 	// If the signature's already cached, return that
 	hash := header.Hash()
 	if address, known := sigcache.Get(hash); known {
@@ -136,7 +136,7 @@ func ecrecover(header *types.Header, sigcache *lru.ARCCache) (common.Address, er
 	signature := header.Extra[len(header.Extra)-extraSeal:]
 
 	// Recover the public key and the Ethereum address
-	pubkey, err := crypto.Ecrecover(SealHash(header).Bytes(), signature)
+	pubkey, err := crypto.Ecrecover(SealHash(header, c).Bytes(), signature)
 	if err != nil {
 		return common.Address{}, err
 	}
@@ -148,15 +148,15 @@ func ecrecover(header *types.Header, sigcache *lru.ARCCache) (common.Address, er
 }
 
 // SealHash returns the hash of a block prior to it being sealed.
-func SealHash(header *types.Header) (hash common.Hash) {
+func SealHash(header *types.Header, c *params.BorConfig) (hash common.Hash) {
 	hasher := sha3.NewLegacyKeccak256()
-	encodeSigHeader(hasher, header)
+	encodeSigHeader(hasher, header, c)
 	hasher.Sum(hash[:0])
 	return hash
 }
 
-func encodeSigHeader(w io.Writer, header *types.Header) {
-	err := rlp.Encode(w, []interface{}{
+func encodeSigHeader(w io.Writer, header *types.Header, c *params.BorConfig) {
+	enc := []interface{}{
 		header.ParentHash,
 		header.UncleHash,
 		header.Coinbase,
@@ -172,8 +172,13 @@ func encodeSigHeader(w io.Writer, header *types.Header) {
 		header.Extra[:len(header.Extra)-65], // Yes, this will panic if extra is too short
 		header.MixDigest,
 		header.Nonce,
-	})
-	if err != nil {
+	}
+	if c.IsJaipur(header.Number.Uint64()) {
+		if header.BaseFee != nil {
+			enc = append(enc, header.BaseFee)
+		}
+	}
+	if err := rlp.Encode(w, enc); err != nil {
 		panic("can't encode: " + err.Error())
 	}
 }
@@ -199,9 +204,9 @@ func CalcProducerDelay(number uint64, succession int, c *params.BorConfig) uint6
 // Note, the method requires the extra data to be at least 65 bytes, otherwise it
 // panics. This is done to avoid accidentally using both forms (signature present
 // or not), which could be abused to produce different hashes for the same header.
-func BorRLP(header *types.Header) []byte {
+func BorRLP(header *types.Header, c *params.BorConfig) []byte {
 	b := new(bytes.Buffer)
-	encodeSigHeader(b, header)
+	encodeSigHeader(b, header, c)
 	return b.Bytes()
 }
 
@@ -280,7 +285,7 @@ func New(
 // Author implements consensus.Engine, returning the Ethereum address recovered
 // from the signature in the header's extra-data section.
 func (c *Bor) Author(header *types.Header) (common.Address, error) {
-	return ecrecover(header, c.signatures)
+	return ecrecover(header, c.signatures, c.config)
 }
 
 // VerifyHeader checks whether a header conforms to the consensus rules.
@@ -578,7 +583,7 @@ func (c *Bor) verifySeal(chain consensus.ChainHeaderReader, header *types.Header
 	}
 
 	// Resolve the authorization key and check against signers
-	signer, err := ecrecover(header, c.signatures)
+	signer, err := ecrecover(header, c.signatures, c.config)
 	if err != nil {
 		return err
 	}
@@ -844,7 +849,7 @@ func (c *Bor) Seal(chain consensus.ChainHeaderReader, block *types.Block, result
 	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))
+	sighash, err := signFn(accounts.Account{Address: signer}, accounts.MimetypeBor, BorRLP(header, c.config))
 	if err != nil {
 		return err
 	}
@@ -876,7 +881,7 @@ func (c *Bor) Seal(chain consensus.ChainHeaderReader, block *types.Block, result
 		select {
 		case results <- block.WithSeal(header):
 		default:
-			log.Warn("Sealing result was not read by miner", "number", number, "sealhash", SealHash(header))
+			log.Warn("Sealing result was not read by miner", "number", number, "sealhash", SealHash(header, c.config))
 		}
 	}()
 	return nil
@@ -895,7 +900,7 @@ func (c *Bor) CalcDifficulty(chain consensus.ChainHeaderReader, time uint64, par
 
 // SealHash returns the hash of a block prior to it being sealed.
 func (c *Bor) SealHash(header *types.Header) common.Hash {
-	return SealHash(header)
+	return SealHash(header, c.config)
 }
 
 // APIs implements consensus.Engine, returning the user facing RPC API to allow

consensus/bor/bor_test.go

@@ -99,3 +99,39 @@ func TestGenesisContractChange(t *testing.T) {
 	// make sure balance change DOES NOT take effect
 	assert.Equal(t, statedb.GetBalance(addr0), big.NewInt(0))
 }
+
+func TestEncodeSigHeaderJaipur(t *testing.T) {
+	// As part of the EIP-1559 fork in mumbai, an incorrect seal hash
+	// was used for Bor that did not included the BaseFee. The Jaipur
+	// block is a hard fork to fix that.
+	h := &types.Header{
+		Difficulty: new(big.Int),
+		Number:     big.NewInt(1),
+		Extra:      make([]byte, 32+65),
+	}
+
+	var (
+		// hash for the block without the BaseFee
+		hashWithoutBaseFee = common.HexToHash("0x1be13e83939b3c4701ee57a34e10c9290ce07b0e53af0fe90b812c6881826e36")
+		// hash for the block with the baseFee
+		hashWithBaseFee = common.HexToHash("0xc55b0cac99161f71bde1423a091426b1b5b4d7598e5981ad802cce712771965b")
+	)
+
+	// Jaipur NOT enabled and BaseFee not set
+	hash := SealHash(h, &params.BorConfig{JaipurBlock: 10})
+	assert.Equal(t, hash, hashWithoutBaseFee)
+
+	// Jaipur enabled (Jaipur=0) and BaseFee not set
+	hash = SealHash(h, &params.BorConfig{JaipurBlock: 0})
+	assert.Equal(t, hash, hashWithoutBaseFee)
+
+	h.BaseFee = big.NewInt(2)
+
+	// Jaipur enabled (Jaipur=Header block) and BaseFee set
+	hash = SealHash(h, &params.BorConfig{JaipurBlock: 1})
+	assert.Equal(t, hash, hashWithBaseFee)
+
+	// Jaipur NOT enabled and BaseFee set
+	hash = SealHash(h, &params.BorConfig{JaipurBlock: 10})
+	assert.Equal(t, hash, hashWithoutBaseFee)
+}

consensus/bor/snapshot.go

@@ -131,7 +131,7 @@ func (s *Snapshot) apply(headers []*types.Header) (*Snapshot, error) {
 		}
 
 		// Resolve the authorization key and check against signers
-		signer, err := ecrecover(header, s.sigcache)
+		signer, err := ecrecover(header, s.sigcache, s.config)
 		if err != nil {
 			return nil, err
 		}

params/config.go

@@ -276,6 +276,7 @@ var (
 		BerlinBlock:         big.NewInt(13996000),
 		LondonBlock:         big.NewInt(22640000),
 		Bor: &BorConfig{
+			JaipurBlock: 22770000,
 			Period: map[string]uint64{
 				"0": 2,
 			},
@@ -486,7 +487,8 @@ type BorConfig struct {
 	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
+	BurntContract            map[string]string      `json:"burntContract"`         // governance contract where the token will be sent to and burnt in london fork
+	JaipurBlock              uint64                 `json:"jaipurBlock"` // Jaipur switch block (nil = no fork, 0 = already on jaipur)
 }
 
 // String implements the stringer interface, returning the consensus engine details.
@@ -502,6 +504,10 @@ func (c *BorConfig) CalculatePeriod(number uint64) uint64 {
 	return c.calculateBorConfigHelper(c.Period, number)
 }
 
+func (c *BorConfig) IsJaipur(number uint64) bool {
+	return number >= c.JaipurBlock
+}
+
 func (c *BorConfig) calculateBorConfigHelper(field map[string]uint64, number uint64) uint64 {
 	keys := make([]string, 0, len(field))
 	for k := range field {

tests/bor/bor_test.go

@@ -3,6 +3,7 @@ package bor
 import (
 	"encoding/hex"
 	"encoding/json"
+	"io"
 	"math/big"
 	"testing"
 	"time"
@@ -16,9 +17,11 @@ import (
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/tests/bor/mocks"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"golang.org/x/crypto/sha3"
 )
 
 var (
@@ -192,15 +195,15 @@ func TestOutOfTurnSigning(t *testing.T) {
 	header := block.Header()
 	header.Time += (bor.CalcProducerDelay(header.Number.Uint64(), expectedSuccessionNumber, init.genesis.Config.Bor) -
 		bor.CalcProducerDelay(header.Number.Uint64(), 0, init.genesis.Config.Bor))
-	sign(t, header, signerKey)
+	sign(t, header, signerKey, init.genesis.Config.Bor)
 	block = types.NewBlockWithHeader(header)
 	_, err = chain.InsertChain([]*types.Block{block})
 	assert.Equal(t,
 		*err.(*bor.WrongDifficultyError),
 		bor.WrongDifficultyError{Number: spanSize, Expected: expectedDifficulty, Actual: 3, Signer: addr.Bytes()})
 
 	header.Difficulty = new(big.Int).SetUint64(expectedDifficulty)
-	sign(t, header, signerKey)
+	sign(t, header, signerKey, init.genesis.Config.Bor)
 	block = types.NewBlockWithHeader(header)
 	_, err = chain.InsertChain([]*types.Block{block})
 	assert.Nil(t, err)
@@ -502,3 +505,58 @@ func TestEIP1559Transition(t *testing.T) {
 func newGwei(n int64) *big.Int {
 	return new(big.Int).Mul(big.NewInt(n), big.NewInt(params.GWei))
 }
+
+func TestJaipurFork(t *testing.T) {
+	init := buildEthereumInstance(t, rawdb.NewMemoryDatabase())
+	chain := init.ethereum.BlockChain()
+	engine := init.ethereum.Engine()
+	_bor := engine.(*bor.Bor)
+	db := init.ethereum.ChainDb()
+	block := init.genesis.ToBlock(db)
+	for i := uint64(1); i < sprintSize; i++ {
+		block = buildNextBlock(t, _bor, chain, block, nil, init.genesis.Config.Bor)
+		insertNewBlock(t, chain, block)
+		if block.Number().Uint64() == init.genesis.Config.Bor.JaipurBlock-1 {
+			assert.Equal(t, testSealHash(block.Header(), init.genesis.Config.Bor), bor.SealHash(block.Header(), init.genesis.Config.Bor))
+		}
+		if block.Number().Uint64() == init.genesis.Config.Bor.JaipurBlock {
+			assert.Equal(t, testSealHash(block.Header(), init.genesis.Config.Bor), bor.SealHash(block.Header(), init.genesis.Config.Bor))
+		}
+	}
+}
+
+// SealHash returns the hash of a block prior to it being sealed.
+func testSealHash(header *types.Header, c *params.BorConfig) (hash common.Hash) {
+	hasher := sha3.NewLegacyKeccak256()
+	testEncodeSigHeader(hasher, header, c)
+	hasher.Sum(hash[:0])
+	return hash
+}
+
+func testEncodeSigHeader(w io.Writer, header *types.Header, c *params.BorConfig) {
+	enc := []interface{}{
+		header.ParentHash,
+		header.UncleHash,
+		header.Coinbase,
+		header.Root,
+		header.TxHash,
+		header.ReceiptHash,
+		header.Bloom,
+		header.Difficulty,
+		header.Number,
+		header.GasLimit,
+		header.GasUsed,
+		header.Time,
+		header.Extra[:len(header.Extra)-65], // Yes, this will panic if extra is too short
+		header.MixDigest,
+		header.Nonce,
+	}
+	if c.IsJaipur(header.Number.Uint64()) {
+		if header.BaseFee != nil {
+			enc = append(enc, header.BaseFee)
+		}
+	}
+	if err := rlp.Encode(w, enc); err != nil {
+		panic("can't encode: " + err.Error())
+	}
+}

tests/bor/helper.go

@@ -11,6 +11,7 @@ import (
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus/bor"
+	"github.com/ethereum/go-ethereum/consensus/misc"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -111,6 +112,14 @@ func buildNextBlock(t *testing.T, _bor *bor.Bor, chain *core.BlockChain, block *
 		copy(header.Extra[32:], validatorBytes)
 	}
 
+	if chain.Config().IsLondon(header.Number) {
+		header.BaseFee = misc.CalcBaseFee(chain.Config(), block.Header())
+		if !chain.Config().IsLondon(block.Number()) {
+			parentGasLimit := block.GasLimit() * params.ElasticityMultiplier
+			header.GasLimit = core.CalcGasLimit(parentGasLimit, parentGasLimit)
+		}
+	}
+
 	state, err := chain.State()
 	if err != nil {
 		t.Fatalf("%s", err)
@@ -119,12 +128,12 @@ func buildNextBlock(t *testing.T, _bor *bor.Bor, chain *core.BlockChain, block *
 	if err != nil {
 		t.Fatalf("%s", err)
 	}
-	sign(t, header, signer)
+	sign(t, header, signer, borConfig)
 	return types.NewBlockWithHeader(header)
 }
 
-func sign(t *testing.T, header *types.Header, signer []byte) {
-	sig, err := secp256k1.Sign(crypto.Keccak256(bor.BorRLP(header)), signer)
+func sign(t *testing.T, header *types.Header, signer []byte, c *params.BorConfig) {
+	sig, err := secp256k1.Sign(crypto.Keccak256(bor.BorRLP(header, c)), signer)
 	if err != nil {
 		t.Fatalf("%s", err)
 	}

tests/bor/testdata/genesis.json

@@ -12,8 +12,9 @@
     "istanbulBlock": 0,
     "muirGlacierBlock": 0,
     "berlinBlock": 0,
-    "londonBlock": 10,
+    "londonBlock": 1,
     "bor": {
+      "jaipurBlock": 2,
       "period": {
         "0": 1
       },