Merge pull request #1644 from maticnetwork/v2.2.9-candidate

v2.2.9

Author: pratikspatil024

.github/matic-cli-config.yml

@@ -21,7 +21,7 @@ blockNumber:
   - '0'
 
 sprintSize:
-  - '64'
+  - '16'
 sprintSizeBlockNumber:
   - '0'
 

.github/workflows/ci.yml

@@ -260,15 +260,7 @@ jobs:
 
       - name: Run smoke tests
         run: |
-          echo "Deposit 100 matic for each account to bor network"
-          cd matic-cli/devnet/devnet
-          SCRIPT_ADDRESS=$(jq -r '.[0].address' signer-dump.json)
-          SCRIPT_PRIVATE_KEY=$(jq -r '.[0].priv_key' signer-dump.json)
-          cd ../code/pos-contracts
-          CONTRACT_ADDRESS=$(jq -r .root.tokens.MaticToken contractAddresses.json)
-          forge script scripts/matic-cli-scripts/Deposit.s.sol:MaticDeposit --rpc-url http://localhost:9545 --private-key $SCRIPT_PRIVATE_KEY --broadcast --sig "run(address,address,uint256)" $SCRIPT_ADDRESS $CONTRACT_ADDRESS 100000000000000000000
-          cd ../../../..
-          timeout 60m bash bor/integration-tests/smoke_test.sh
+          timeout 20m bash bor/integration-tests/smoke_test.sh
 
       - name: Run RPC Tests
         run: |

accounts/abi/bind/backends/simulated.go

@@ -714,7 +714,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
 	vmEnv := vm.NewEVM(evmContext, stateDB, b.config, vm.Config{NoBaseFee: true})
 	gasPool := new(core.GasPool).AddGas(gomath.MaxUint64)
 
-	return core.ApplyMessage(vmEnv, msg, gasPool, context.Background())
+	return core.ApplyMessage(vmEnv, msg, gasPool, nil)
 }
 
 // SendTransaction updates the pending block to include the given transaction.

builder/files/config.toml

@@ -163,7 +163,13 @@ syncmode = "full"
   # timeout = "1h0m0s"
   # fdlimit = 0
 
-[accounts]
+# [history]
+#   transactions = 2350000
+#   logs = 2350000
+#   "logs.disable" = false
+#   state = 90000
+
+# [accounts]
   # allow-insecure-unlock = true
   # password = "/var/lib/bor/password.txt"
   # unlock = ["VALIDATOR ADDRESS"]

core/blockchain.go

@@ -3029,7 +3029,14 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Header) error
 			return errInvalidNewChain
 		}
 	}
+
 	// Ensure the user sees large reorgs
+	if len(oldChain) == 0 && len(newChain) == 0 {
+		// No actual reorg, same block
+		log.Info("No reorg needed; old and new head are identical", "number", oldHead.Number, "hash", oldHead.Hash())
+		return nil
+	}
+
 	if len(oldChain) > 0 && len(newChain) > 0 {
 		bc.chain2HeadFeed.Send(Chain2HeadEvent{
 			Type:     Chain2HeadReorgEvent,

core/parallel_state_processor.go

@@ -276,6 +276,11 @@ func (p *ParallelStateProcessor) Process(block *types.Block, statedb *state.Stat
 		metadata    bool
 	)
 
+	// Set an empty context if nil
+	if interruptCtx == nil {
+		interruptCtx = context.Background()
+	}
+
 	// Mutate the block and state according to any hard-fork specs
 	if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 {
 		misc.ApplyDAOHardFork(statedb)

core/state_prefetcher.go

@@ -17,7 +17,6 @@
 package core
 
 import (
-	"context"
 	"sync/atomic"
 
 	"github.com/ethereum/go-ethereum/core/state"
@@ -71,7 +70,7 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, c
 
 		// We attempt to apply a transaction. The goal is not to execute
 		// the transaction successfully, rather to warm up touched data slots.
-		if _, err := ApplyMessage(evm, msg, gaspool, context.Background()); err != nil {
+		if _, err := ApplyMessage(evm, msg, gaspool, nil); err != nil {
 			return // Ugh, something went horribly wrong, bail out
 		}
 		// If we're pre-byzantium, pre-load trie nodes for the intermediate root

core/state_processor.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"fmt"
 	"math/big"
+	"sync/atomic"
 
 	"github.com/ethereum/go-ethereum/common"
 	cmath "github.com/ethereum/go-ethereum/common/math"
@@ -69,6 +70,11 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 		gp          = new(GasPool).AddGas(block.GasLimit())
 	)
 
+	// Set an empty context if nil
+	if interruptCtx == nil {
+		interruptCtx = context.Background()
+	}
+
 	// Mutate the block and state according to any hard-fork specs
 	if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 {
 		misc.ApplyDAOHardFork(statedb)
@@ -96,21 +102,21 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 
 	// Iterate over and process the individual transactions
 	for i, tx := range block.Transactions() {
-		if interruptCtx != nil {
-			select {
-			case <-interruptCtx.Done():
-				return nil, interruptCtx.Err()
-			default:
-			}
+		// Check if execution should be cancelled or not
+		select {
+		case <-interruptCtx.Done():
+			return nil, interruptCtx.Err()
+		default:
 		}
+
 		msg, err := TransactionToMessage(tx, signer, header.BaseFee)
 		if err != nil {
 			return nil, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)
 		}
 
 		statedb.SetTxContext(tx.Hash(), i)
 
-		receipt, err := ApplyTransactionWithEVM(msg, gp, statedb, blockNumber, blockHash, tx, usedGas, evm, interruptCtx)
+		receipt, err := ApplyTransactionWithEVM(msg, gp, statedb, blockNumber, blockHash, tx, usedGas, evm, nil)
 		if err != nil {
 			return nil, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err)
 		}
@@ -154,7 +160,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 // ApplyTransactionWithEVM attempts to apply a transaction to the given state database
 // and uses the input parameters for its environment similar to ApplyTransaction. However,
 // this method takes an already created EVM instance as input.
-func ApplyTransactionWithEVM(msg *Message, gp *GasPool, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, tx *types.Transaction, usedGas *uint64, evm *vm.EVM, interruptCtx context.Context) (receipt *types.Receipt, err error) {
+func ApplyTransactionWithEVM(msg *Message, gp *GasPool, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, tx *types.Transaction, usedGas *uint64, evm *vm.EVM, interrupt *atomic.Bool) (receipt *types.Receipt, err error) {
 	if hooks := evm.Config.Tracer; hooks != nil {
 		if hooks.OnTxStart != nil {
 			hooks.OnTxStart(evm.GetVMContext(), tx, msg.From)
@@ -180,7 +186,7 @@ func ApplyTransactionWithEVM(msg *Message, gp *GasPool, statedb *state.StateDB,
 	// resume recording read and write
 	statedb.SetMVHashmap(backupMVHashMap)
 
-	result, err = ApplyMessageNoFeeBurnOrTip(evm, *msg, gp, interruptCtx)
+	result, err = ApplyMessageNoFeeBurnOrTip(evm, *msg, gp, interrupt)
 	if err != nil {
 		return nil, err
 	}
@@ -272,13 +278,13 @@ func MakeReceipt(evm *vm.EVM, result *ExecutionResult, statedb *state.StateDB, b
 // and uses the input parameters for its environment. It returns the receipt
 // for the transaction, gas used and an error if the transaction failed,
 // indicating the block was invalid.
-func ApplyTransaction(evm *vm.EVM, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, interruptCtx context.Context) (*types.Receipt, error) {
+func ApplyTransaction(evm *vm.EVM, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, interrupt *atomic.Bool) (*types.Receipt, error) {
 	msg, err := TransactionToMessage(tx, types.MakeSigner(evm.ChainConfig(), header.Number, header.Time), header.BaseFee)
 	if err != nil {
 		return nil, err
 	}
 	// Create a new context to be used in the EVM environment
-	return ApplyTransactionWithEVM(msg, gp, statedb, header.Number, header.Hash(), tx, usedGas, evm, interruptCtx)
+	return ApplyTransactionWithEVM(msg, gp, statedb, header.Number, header.Hash(), tx, usedGas, evm, interrupt)
 }
 
 // ProcessBeaconBlockRoot applies the EIP-4788 system call to the beacon block root

core/state_transition.go

@@ -18,10 +18,10 @@ package core
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"math"
 	"math/big"
+	"sync/atomic"
 
 	"github.com/ethereum/go-ethereum/common"
 	cmath "github.com/ethereum/go-ethereum/common/math"
@@ -220,16 +220,16 @@ func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.In
 // the gas used (which includes gas refunds) and an error if it failed. An error always
 // indicates a core error meaning that the message would always fail for that particular
 // state and would never be accepted within a block.
-func ApplyMessage(evm *vm.EVM, msg *Message, gp *GasPool, interruptCtx context.Context) (*ExecutionResult, error) {
+func ApplyMessage(evm *vm.EVM, msg *Message, gp *GasPool, interrupt *atomic.Bool) (*ExecutionResult, error) {
 	evm.SetTxContext(NewEVMTxContext(msg))
-	return newStateTransition(evm, msg, gp).execute(interruptCtx)
+	return newStateTransition(evm, msg, gp).execute(interrupt)
 }
 
-func ApplyMessageNoFeeBurnOrTip(evm *vm.EVM, msg Message, gp *GasPool, interruptCtx context.Context) (*ExecutionResult, error) {
+func ApplyMessageNoFeeBurnOrTip(evm *vm.EVM, msg Message, gp *GasPool, interrupt *atomic.Bool) (*ExecutionResult, error) {
 	st := newStateTransition(evm, &msg, gp)
 	st.noFeeBurnAndTip = true
 
-	return st.execute(interruptCtx)
+	return st.execute(interrupt)
 }
 
 // stateTransition represents a state transition.
@@ -438,7 +438,7 @@ func (st *stateTransition) preCheck() error {
 //
 // However if any consensus issue encountered, return the error directly with
 // nil evm execution result.
-func (st *stateTransition) execute(interruptCtx context.Context) (*ExecutionResult, error) {
+func (st *stateTransition) execute(interrupt *atomic.Bool) (*ExecutionResult, error) {
 	input1 := st.state.GetBalance(st.msg.From)
 
 	var input2 *uint256.Int
@@ -548,7 +548,7 @@ func (st *stateTransition) execute(interruptCtx context.Context) (*ExecutionResu
 		}
 
 		// Execute the transaction's call.
-		ret, st.gasRemaining, vmerr = st.evm.Call(msg.From, st.to(), msg.Data, st.gasRemaining, value, interruptCtx)
+		ret, st.gasRemaining, vmerr = st.evm.Call(msg.From, st.to(), msg.Data, st.gasRemaining, value, interrupt)
 	}
 
 	// Record the gas used excluding gas refunds. This value represents the actual

core/types/transaction_signing.go

@@ -600,32 +600,32 @@ func deriveChainId(v *big.Int) *big.Int {
 }
 
 // FakeSigner implements the Signer interface and accepts unprotected transactions
-type FakeSigner struct{ londonSigner }
+type FakeSigner struct{ pragueSigner }
 
 var _ Signer = FakeSigner{}
 
 func NewFakeSigner(chainId *big.Int) Signer {
-	signer := NewLondonSigner(chainId)
-	ls, _ := signer.(londonSigner)
-	return FakeSigner{londonSigner: ls}
+	signer := NewPragueSigner(chainId)
+	ps, _ := signer.(pragueSigner)
+	return FakeSigner{pragueSigner: ps}
 }
 
 func (f FakeSigner) Sender(tx *Transaction) (common.Address, error) {
-	return f.londonSigner.Sender(tx)
+	return f.pragueSigner.Sender(tx)
 }
 
 func (f FakeSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *big.Int, err error) {
-	return f.londonSigner.SignatureValues(tx, sig)
+	return f.pragueSigner.SignatureValues(tx, sig)
 }
 
 func (f FakeSigner) ChainID() *big.Int {
-	return f.londonSigner.ChainID()
+	return f.pragueSigner.ChainID()
 }
 
 // Hash returns 'signature hash', i.e. the transaction hash that is signed by the
 // private key. This hash does not uniquely identify the transaction.
 func (f FakeSigner) Hash(tx *Transaction) common.Hash {
-	return f.londonSigner.Hash(tx)
+	return f.pragueSigner.Hash(tx)
 }
 
 // Equal returns true if the given signer is the same as the receiver.