Merge V1.1.0 beta candidate to 'develop'

consensus/bor/bor.go

@@ -381,11 +381,14 @@
 
 	// Verify that the gas limit is <= 2^63-1
 	gasCap := uint64(0x7fffffffffffffff)
-
 	if header.GasLimit > gasCap {
 		return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, gasCap)
 	}
 
+	if header.WithdrawalsHash != nil {
+		return consensus.ErrUnexpectedWithdrawals
+	}
+
 	// All basic checks passed, verify cascading fields
 	return c.verifyCascadingFields(chain, header, parents)
 }
@@ -816,13 +819,7 @@
 
 	headerNumber := header.Number.Uint64()
 
-	if len(withdrawals) > 0 {
-		log.Error("Bor does not support withdrawals", "number", headerNumber)
-		return
-	}
-
-	if header.WithdrawalsHash != nil {
-		log.Error("Bor does not support withdrawalHash", "number", headerNumber)
+	if withdrawals != nil || header.WithdrawalsHash != nil {
 		return
 	}
 
@@ -898,18 +895,14 @@
 	finalizeCtx, finalizeSpan := tracing.StartSpan(ctx, "bor.FinalizeAndAssemble")
 	defer tracing.EndSpan(finalizeSpan)
 
-	if len(withdrawals) > 0 {
-		return nil, errors.New("Bor does not support withdrawals")
-	}
+	headerNumber := header.Number.Uint64()
 
-	if header.WithdrawalsHash != nil {
-		return nil, errors.New("Bor does not support withdrawalHash")
+	if withdrawals != nil || header.WithdrawalsHash != nil {
+		return nil, consensus.ErrUnexpectedWithdrawals
 	}
 
 	stateSyncData := []*types.StateSyncData{}
 
-	headerNumber := header.Number.Uint64()
-
 	var err error
 
 	if IsSprintStart(headerNumber, c.config.CalculateSprint(headerNumber)) {

consensus/bor/statefull/processor.go

@@ -1,6 +1,7 @@
 package statefull
 
 import (
+	"bytes"
 	"context"
 	"math"
 	"math/big"
@@ -90,7 +91,11 @@ func ApplyMessage(
 
 	success := big.NewInt(5).SetBytes(ret)
 
-	if success.Cmp(big.NewInt(0)) == 0 {
+	validatorContract := common.HexToAddress(chainConfig.Bor.ValidatorContract)
+
+	// if success == 0 and msg.To() != validatorContractAddress, log Error
+	// if msg.To() == validatorContractAddress, its committing a span and we don't get any return value
+	if success.Cmp(big.NewInt(0)) == 0 && !bytes.Equal(msg.To().Bytes(), validatorContract.Bytes()) {
 		log.Error("message execution failed on contract", "msgData", msg.Data)
 	}
 

consensus/errors.go

@@ -38,4 +38,7 @@ var (
 	// ErrInvalidTerminalBlock is returned if a block is invalid wrt. the terminal
 	// total difficulty.
 	ErrInvalidTerminalBlock = errors.New("invalid terminal block")
+
+	// ErrUnexpectedWithdrawals is returned if a pre-Shanghai block has withdrawals.
+	ErrUnexpectedWithdrawals = errors.New("unexpected withdrawals")
 )

core/genesis.go

@@ -529,8 +529,8 @@ func (g *Genesis) ToBlock() *types.Block {
 	var withdrawals []*types.Withdrawal
 
 	if g.Config != nil && g.Config.IsShanghai(new(big.Int).SetUint64(g.Number)) {
-		head.WithdrawalsHash = &types.EmptyWithdrawalsHash
-		withdrawals = make([]*types.Withdrawal, 0)
+		head.WithdrawalsHash = nil
+		withdrawals = nil
 	}
 
 	return types.NewBlock(head, nil, nil, nil, trie.NewStackTrie(nil)).WithWithdrawals(withdrawals)

core/state_processor.go

@@ -101,9 +101,13 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	}
 	// Fail if Shanghai not enabled and len(withdrawals) is non-zero.
 	withdrawals := block.Withdrawals()
-	if len(withdrawals) > 0 && !p.config.IsShanghai(block.Number()) {
+	if !p.config.IsShanghai(block.Number()) && withdrawals != nil {
 		return nil, nil, 0, fmt.Errorf("withdrawals before shanghai")
 	}
+	// Bor does not support withdrawals
+	if withdrawals != nil {
+		withdrawals = nil
+	}
 	// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
 	p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles(), withdrawals)
 

core/vm/jump_table.go

@@ -90,12 +90,15 @@ func newShanghaiInstructionSet() JumpTable {
 
 func newMergeInstructionSet() JumpTable {
 	instructionSet := newLondonInstructionSet()
-	instructionSet[PREVRANDAO] = &operation{
-		execute:     opRandom,
-		constantGas: GasQuickStep,
-		minStack:    minStack(0, 1),
-		maxStack:    maxStack(0, 1),
-	}
+
+	// disabling in pos due to incompatibility with prevrandao
+
+	// instructionSet[PREVRANDAO] = &operation{
+	// 	execute:     opRandom,
+	// 	constantGas: GasQuickStep,
+	// 	minStack:    minStack(0, 1),
+	// 	maxStack:    maxStack(0, 1),
+	// }
 
 	return validate(instructionSet)
 }

eth/api.go

@@ -277,6 +277,9 @@
 		// both the pending block as well as the pending state from
 		// the miner and operate on those
 		_, stateDb := api.eth.miner.Pending()
+		if stateDb == nil {
+			return state.Dump{}, errors.New("pending state is not available")
+		}
 		return stateDb.RawDump(opts), nil
 	}
 
@@ -385,6 +388,9 @@
 			// both the pending block as well as the pending state from
 			// the miner and operate on those
 			_, stateDb = api.eth.miner.Pending()
+			if stateDb == nil {
+				return state.IteratorDump{}, errors.New("pending state is not available")
+			}
 		} else {
 			var header *types.Header
 			if number == rpc.LatestBlockNumber {

eth/api_backend.go

@@ -68,6 +68,9 @@
 	// Pending block is only known by the miner
 	if number == rpc.PendingBlockNumber {
 		block := b.eth.miner.PendingBlock()
+		if block == nil {
+			return nil, errors.New("pending block is not available")
+		}
 		return block.Header(), nil
 	}
 	// Otherwise resolve and return the block
@@ -136,6 +139,9 @@
 	// Pending block is only known by the miner
 	if number == rpc.PendingBlockNumber {
 		block := b.eth.miner.PendingBlock()
+		if block == nil {
+			return nil, errors.New("pending block is not available")
+		}
 		return block, nil
 	}
 	// Otherwise resolve and return the block
@@ -217,6 +223,9 @@
 	// Pending state is only known by the miner
 	if number == rpc.PendingBlockNumber {
 		block, state := b.eth.miner.Pending()
+		if block == nil || state == nil {
+			return nil, nil, errors.New("pending state is not available")
+		}
 		return state, block.Header(), nil
 	}
 	// Otherwise resolve the block number and return its state

eth/filters/filter.go

@@ -328,6 +328,9 @@
 // pendingLogs returns the logs matching the filter criteria within the pending block.
 func (f *Filter) pendingLogs() ([]*types.Log, error) {
 	block, receipts := f.sys.backend.PendingBlockAndReceipts()
+	if block == nil || receipts == nil {
+		return nil, errors.New("pending block is not available")
+	}
 	if bloomFilter(block.Bloom(), f.addresses, f.topics) {
 		var unfiltered []*types.Log
 		for _, r := range receipts {

eth/protocols/eth/handler_test.go

@@ -367,11 +367,7 @@ func TestGetBlockBodies68(t *testing.T) {
 func testGetBlockBodies(t *testing.T, protocol uint) {
 	gen := func(n int, g *core.BlockGen) {
 		if n%2 == 0 {
-			w := &types.Withdrawal{
-				Address: common.Address{0xaa},
-				Amount:  42,
-			}
-			g.AddWithdrawal(w)
+			g.AddWithdrawal(&types.Withdrawal{})
 		}
 	}