all: tie timestamp based forks to the passage of London (#27279)

karalabe · web-flow · commit 85a4b82b3373 · 2023-05-19T11:27:19.000+03:00
diff --git a/cmd/evm/internal/t8ntool/transaction.go b/cmd/evm/internal/t8ntool/transaction.go
@@ -140,7 +140,7 @@ func Transaction(ctx *cli.Context) error {
 		}
 		// Check intrinsic gas
 		if gas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil,
-			chainConfig.IsHomestead(new(big.Int)), chainConfig.IsIstanbul(new(big.Int)), chainConfig.IsShanghai(0)); err != nil {
+			chainConfig.IsHomestead(new(big.Int)), chainConfig.IsIstanbul(new(big.Int)), chainConfig.IsShanghai(new(big.Int), 0)); err != nil {
 			r.Error = err
 			results = append(results, r)
 			continue
@@ -172,7 +172,7 @@ func Transaction(ctx *cli.Context) error {
 			r.Error = errors.New("gas * maxFeePerGas exceeds 256 bits")
 		}
 		// Check whether the init code size has been exceeded.
-		if chainConfig.IsShanghai(0) && tx.To() == nil && len(tx.Data()) > params.MaxInitCodeSize {
+		if chainConfig.IsShanghai(new(big.Int), 0) && tx.To() == nil && len(tx.Data()) > params.MaxInitCodeSize {
 			r.Error = errors.New("max initcode size exceeded")
 		}
 		results = append(results, r)
diff --git a/cmd/evm/internal/t8ntool/transition.go b/cmd/evm/internal/t8ntool/transition.go
@@ -261,7 +261,7 @@ func Transition(ctx *cli.Context) error {
 			return NewError(ErrorConfig, errors.New("EIP-1559 config but missing 'currentBaseFee' in env section"))
 		}
 	}
-	if chainConfig.IsShanghai(prestate.Env.Number) && prestate.Env.Withdrawals == nil {
+	if chainConfig.IsShanghai(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp) && prestate.Env.Withdrawals == nil {
 		return NewError(ErrorConfig, errors.New("Shanghai config but missing 'withdrawals' in env section"))
 	}
 	isMerged := chainConfig.TerminalTotalDifficulty != nil && chainConfig.TerminalTotalDifficulty.BitLen() == 0
diff --git a/consensus/beacon/consensus.go b/consensus/beacon/consensus.go
@@ -261,15 +261,15 @@ func (beacon *Beacon) verifyHeader(chain consensus.ChainHeaderReader, header, pa
 		return err
 	}
 	// Verify existence / non-existence of withdrawalsHash.
-	shanghai := chain.Config().IsShanghai(header.Time)
+	shanghai := chain.Config().IsShanghai(header.Number, header.Time)
 	if shanghai && header.WithdrawalsHash == nil {
 		return errors.New("missing withdrawalsHash")
 	}
 	if !shanghai && header.WithdrawalsHash != nil {
 		return fmt.Errorf("invalid withdrawalsHash: have %x, expected nil", header.WithdrawalsHash)
 	}
 	// Verify the existence / non-existence of excessDataGas
-	cancun := chain.Config().IsCancun(header.Time)
+	cancun := chain.Config().IsCancun(header.Number, header.Time)
 	if cancun && header.ExcessDataGas == nil {
 		return errors.New("missing excessDataGas")
 	}
@@ -356,7 +356,7 @@ func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, hea
 	if !beacon.IsPoSHeader(header) {
 		return beacon.ethone.FinalizeAndAssemble(chain, header, state, txs, uncles, receipts, nil)
 	}
-	shanghai := chain.Config().IsShanghai(header.Time)
+	shanghai := chain.Config().IsShanghai(header.Number, header.Time)
 	if shanghai {
 		// All blocks after Shanghai must include a withdrawals root.
 		if withdrawals == nil {
diff --git a/consensus/clique/clique.go b/consensus/clique/clique.go
@@ -298,10 +298,10 @@ func (c *Clique) verifyHeader(chain consensus.ChainHeaderReader, header *types.H
 	if header.GasLimit > params.MaxGasLimit {
 		return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, params.MaxGasLimit)
 	}
-	if chain.Config().IsShanghai(header.Time) {
+	if chain.Config().IsShanghai(header.Number, header.Time) {
 		return fmt.Errorf("clique does not support shanghai fork")
 	}
-	if chain.Config().IsCancun(header.Time) {
+	if chain.Config().IsCancun(header.Number, header.Time) {
 		return fmt.Errorf("clique does not support cancun fork")
 	}
 	// All basic checks passed, verify cascading fields
diff --git a/consensus/ethash/consensus.go b/consensus/ethash/consensus.go
@@ -262,10 +262,10 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, pa
 	if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(big.NewInt(1)) != 0 {
 		return consensus.ErrInvalidNumber
 	}
-	if chain.Config().IsShanghai(header.Time) {
+	if chain.Config().IsShanghai(header.Number, header.Time) {
 		return fmt.Errorf("ethash does not support shanghai fork")
 	}
-	if chain.Config().IsCancun(header.Time) {
+	if chain.Config().IsCancun(header.Number, header.Time) {
 		return fmt.Errorf("ethash does not support cancun fork")
 	}
 	// Add some fake checks for tests
diff --git a/core/genesis.go b/core/genesis.go
@@ -463,7 +463,7 @@ func (g *Genesis) ToBlock() *types.Block {
 		}
 	}
 	var withdrawals []*types.Withdrawal
-	if g.Config != nil && g.Config.IsShanghai(g.Timestamp) {
+	if g.Config != nil && g.Config.IsShanghai(big.NewInt(int64(g.Number)), g.Timestamp) {
 		head.WithdrawalsHash = &types.EmptyWithdrawalsHash
 		withdrawals = make([]*types.Withdrawal, 0)
 	}
diff --git a/core/state_processor.go b/core/state_processor.go
@@ -91,7 +91,7 @@ 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.Time()) {
+	if len(withdrawals) > 0 && !p.config.IsShanghai(block.Number(), block.Time()) {
 		return nil, nil, 0, fmt.Errorf("withdrawals before shanghai")
 	}
 	// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
diff --git a/core/state_processor_test.go b/core/state_processor_test.go
@@ -403,7 +403,7 @@ func GenerateBadBlock(parent *types.Block, engine consensus.Engine, txs types.Tr
 	if config.IsLondon(header.Number) {
 		header.BaseFee = misc.CalcBaseFee(config, parent.Header())
 	}
-	if config.IsShanghai(header.Time) {
+	if config.IsShanghai(header.Number, header.Time) {
 		header.WithdrawalsHash = &types.EmptyWithdrawalsHash
 	}
 	var receipts []*types.Receipt
@@ -423,7 +423,7 @@ func GenerateBadBlock(parent *types.Block, engine consensus.Engine, txs types.Tr
 	}
 	header.Root = common.BytesToHash(hasher.Sum(nil))
 	// Assemble and return the final block for sealing
-	if config.IsShanghai(header.Time) {
+	if config.IsShanghai(header.Number, header.Time) {
 		return types.NewBlockWithWithdrawals(header, txs, nil, receipts, []*types.Withdrawal{}, trie.NewStackTrie(nil))
 	}
 	return types.NewBlock(header, txs, nil, receipts, trie.NewStackTrie(nil))
diff --git a/core/txpool/txpool.go b/core/txpool/txpool.go
@@ -1397,7 +1397,7 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
 	pool.istanbul.Store(pool.chainconfig.IsIstanbul(next))
 	pool.eip2718.Store(pool.chainconfig.IsBerlin(next))
 	pool.eip1559.Store(pool.chainconfig.IsLondon(next))
-	pool.shanghai.Store(pool.chainconfig.IsShanghai(uint64(time.Now().Unix())))
+	pool.shanghai.Store(pool.chainconfig.IsShanghai(next, uint64(time.Now().Unix())))
 }
 
 // promoteExecutables moves transactions that have become processable from the
diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go
@@ -40,7 +40,7 @@ type sigCache struct {
 func MakeSigner(config *params.ChainConfig, blockNumber *big.Int, blockTime uint64) Signer {
 	var signer Signer
 	switch {
-	case config.IsCancun(blockTime):
+	case config.IsCancun(blockNumber, blockTime):
 		signer = NewCancunSigner(config.ChainID)
 	case config.IsLondon(blockNumber):
 		signer = NewLondonSigner(config.ChainID)
diff --git a/eth/catalyst/api.go b/eth/catalyst/api.go
@@ -20,6 +20,7 @@ package catalyst
 import (
 	"errors"
 	"fmt"
+	"math/big"
 	"sync"
 	"time"
 
@@ -167,7 +168,7 @@ func (api *ConsensusAPI) ForkchoiceUpdatedV1(update engine.ForkchoiceStateV1, pa
 		if payloadAttributes.Withdrawals != nil {
 			return engine.STATUS_INVALID, engine.InvalidParams.With(fmt.Errorf("withdrawals not supported in V1"))
 		}
-		if api.eth.BlockChain().Config().IsShanghai(payloadAttributes.Timestamp) {
+		if api.eth.BlockChain().Config().IsShanghai(api.eth.BlockChain().Config().LondonBlock, payloadAttributes.Timestamp) {
 			return engine.STATUS_INVALID, engine.InvalidParams.With(fmt.Errorf("forkChoiceUpdateV1 called post-shanghai"))
 		}
 	}
@@ -185,7 +186,7 @@ func (api *ConsensusAPI) ForkchoiceUpdatedV2(update engine.ForkchoiceStateV1, pa
 }
 
 func (api *ConsensusAPI) verifyPayloadAttributes(attr *engine.PayloadAttributes) error {
-	if !api.eth.BlockChain().Config().IsShanghai(attr.Timestamp) {
+	if !api.eth.BlockChain().Config().IsShanghai(api.eth.BlockChain().Config().LondonBlock, attr.Timestamp) {
 		// Reject payload attributes with withdrawals before shanghai
 		if attr.Withdrawals != nil {
 			return errors.New("withdrawals before shanghai")
@@ -423,7 +424,7 @@ func (api *ConsensusAPI) NewPayloadV1(params engine.ExecutableData) (engine.Payl
 
 // NewPayloadV2 creates an Eth1 block, inserts it in the chain, and returns the status of the chain.
 func (api *ConsensusAPI) NewPayloadV2(params engine.ExecutableData) (engine.PayloadStatusV1, error) {
-	if api.eth.BlockChain().Config().IsShanghai(params.Timestamp) {
+	if api.eth.BlockChain().Config().IsShanghai(new(big.Int).SetUint64(params.Number), params.Timestamp) {
 		if params.Withdrawals == nil {
 			return engine.PayloadStatusV1{Status: engine.INVALID}, engine.InvalidParams.With(fmt.Errorf("nil withdrawals post-shanghai"))
 		}
diff --git a/light/txpool.go b/light/txpool.go
@@ -318,7 +318,7 @@ func (pool *TxPool) setNewHead(head *types.Header) {
 	next := new(big.Int).Add(head.Number, big.NewInt(1))
 	pool.istanbul = pool.config.IsIstanbul(next)
 	pool.eip2718 = pool.config.IsBerlin(next)
-	pool.shanghai = pool.config.IsShanghai(uint64(time.Now().Unix()))
+	pool.shanghai = pool.config.IsShanghai(next, uint64(time.Now().Unix()))
 }
 
 // Stop stops the light transaction pool
diff --git a/params/config.go b/params/config.go
@@ -492,18 +492,18 @@ func (c *ChainConfig) IsTerminalPoWBlock(parentTotalDiff *big.Int, totalDiff *bi
 }
 
 // IsShanghai returns whether time is either equal to the Shanghai fork time or greater.
-func (c *ChainConfig) IsShanghai(time uint64) bool {
-	return isTimestampForked(c.ShanghaiTime, time)
+func (c *ChainConfig) IsShanghai(num *big.Int, time uint64) bool {
+	return c.IsLondon(num) && isTimestampForked(c.ShanghaiTime, time)
 }
 
 // IsCancun returns whether num is either equal to the Cancun fork time or greater.
-func (c *ChainConfig) IsCancun(time uint64) bool {
-	return isTimestampForked(c.CancunTime, time)
+func (c *ChainConfig) IsCancun(num *big.Int, time uint64) bool {
+	return c.IsLondon(num) && isTimestampForked(c.CancunTime, time)
 }
 
 // IsPrague returns whether num is either equal to the Prague fork time or greater.
-func (c *ChainConfig) IsPrague(time uint64) bool {
-	return isTimestampForked(c.PragueTime, time)
+func (c *ChainConfig) IsPrague(num *big.Int, time uint64) bool {
+	return c.IsLondon(num) && isTimestampForked(c.PragueTime, time)
 }
 
 // CheckCompatible checks whether scheduled fork transitions have been imported
@@ -829,8 +829,8 @@ func (c *ChainConfig) Rules(num *big.Int, isMerge bool, timestamp uint64) Rules
 		IsBerlin:         c.IsBerlin(num),
 		IsLondon:         c.IsLondon(num),
 		IsMerge:          isMerge,
-		IsShanghai:       c.IsShanghai(timestamp),
-		IsCancun:         c.IsCancun(timestamp),
-		IsPrague:         c.IsPrague(timestamp),
+		IsShanghai:       c.IsShanghai(num, timestamp),
+		IsCancun:         c.IsCancun(num, timestamp),
+		IsPrague:         c.IsPrague(num, timestamp),
 	}
 }
diff --git a/params/config_test.go b/params/config_test.go
@@ -121,6 +121,7 @@ func TestCheckCompatible(t *testing.T) {
 
 func TestConfigRules(t *testing.T) {
 	c := &ChainConfig{
+		LondonBlock:  new(big.Int),
 		ShanghaiTime: newUint64(500),
 	}
 	var stamp uint64

Original file line number	Diff line number	Diff line change
`@@ -140,7 +140,7 @@ func Transaction(ctx *cli.Context) error {`
`140`	`140`	`}`
`141`	`141`	`// Check intrinsic gas`
`142`	`142`	`if gas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil,`
`143`		`- chainConfig.IsHomestead(new(big.Int)), chainConfig.IsIstanbul(new(big.Int)), chainConfig.IsShanghai(0)); err != nil {`
	`143`	`+ chainConfig.IsHomestead(new(big.Int)), chainConfig.IsIstanbul(new(big.Int)), chainConfig.IsShanghai(new(big.Int), 0)); err != nil {`
`144`	`144`	`r.Error = err`
`145`	`145`	`results = append(results, r)`
`146`	`146`	`continue`
`@@ -172,7 +172,7 @@ func Transaction(ctx *cli.Context) error {`
`172`	`172`	`r.Error = errors.New("gas * maxFeePerGas exceeds 256 bits")`
`173`	`173`	`}`
`174`	`174`	`// Check whether the init code size has been exceeded.`
`175`		`- if chainConfig.IsShanghai(0) && tx.To() == nil && len(tx.Data()) > params.MaxInitCodeSize {`
	`175`	`+ if chainConfig.IsShanghai(new(big.Int), 0) && tx.To() == nil && len(tx.Data()) > params.MaxInitCodeSize {`
`176`	`176`	`r.Error = errors.New("max initcode size exceeded")`
`177`	`177`	`}`
`178`	`178`	`results = append(results, r)`
Original file line number	Diff line number	Diff line change
`@@ -261,7 +261,7 @@ func Transition(ctx *cli.Context) error {`
`261`	`261`	`return NewError(ErrorConfig, errors.New("EIP-1559 config but missing 'currentBaseFee' in env section"))`
`262`	`262`	`}`
`263`	`263`	`}`
`264`		`- if chainConfig.IsShanghai(prestate.Env.Number) && prestate.Env.Withdrawals == nil {`
	`264`	`+ if chainConfig.IsShanghai(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp) && prestate.Env.Withdrawals == nil {`
`265`	`265`	`return NewError(ErrorConfig, errors.New("Shanghai config but missing 'withdrawals' in env section"))`
`266`	`266`	`}`
`267`	`267`	`isMerged := chainConfig.TerminalTotalDifficulty != nil && chainConfig.TerminalTotalDifficulty.BitLen() == 0`
Original file line number	Diff line number	Diff line change
`@@ -261,15 +261,15 @@ func (beacon *Beacon) verifyHeader(chain consensus.ChainHeaderReader, header, pa`
`261`	`261`	`return err`
`262`	`262`	`}`
`263`	`263`	`// Verify existence / non-existence of withdrawalsHash.`
`264`		`- shanghai := chain.Config().IsShanghai(header.Time)`
	`264`	`+ shanghai := chain.Config().IsShanghai(header.Number, header.Time)`
`265`	`265`	`if shanghai && header.WithdrawalsHash == nil {`
`266`	`266`	`return errors.New("missing withdrawalsHash")`
`267`	`267`	`}`
`268`	`268`	`if !shanghai && header.WithdrawalsHash != nil {`
`269`	`269`	`return fmt.Errorf("invalid withdrawalsHash: have %x, expected nil", header.WithdrawalsHash)`
`270`	`270`	`}`
`271`	`271`	`// Verify the existence / non-existence of excessDataGas`
`272`		`- cancun := chain.Config().IsCancun(header.Time)`
	`272`	`+ cancun := chain.Config().IsCancun(header.Number, header.Time)`
`273`	`273`	`if cancun && header.ExcessDataGas == nil {`
`274`	`274`	`return errors.New("missing excessDataGas")`
`275`	`275`	`}`
`@@ -356,7 +356,7 @@ func (beacon *Beacon) FinalizeAndAssemble(chain consensus.ChainHeaderReader, hea`
`356`	`356`	`if !beacon.IsPoSHeader(header) {`
`357`	`357`	`return beacon.ethone.FinalizeAndAssemble(chain, header, state, txs, uncles, receipts, nil)`
`358`	`358`	`}`
`359`		`- shanghai := chain.Config().IsShanghai(header.Time)`
	`359`	`+ shanghai := chain.Config().IsShanghai(header.Number, header.Time)`
`360`	`360`	`if shanghai {`
`361`	`361`	`// All blocks after Shanghai must include a withdrawals root.`
`362`	`362`	`if withdrawals == nil {`
Original file line number	Diff line number	Diff line change
`@@ -298,10 +298,10 @@ func (c Clique) verifyHeader(chain consensus.ChainHeaderReader, header types.H`
`298`	`298`	`if header.GasLimit > params.MaxGasLimit {`
`299`	`299`	`return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, params.MaxGasLimit)`
`300`	`300`	`}`
`301`		`- if chain.Config().IsShanghai(header.Time) {`
	`301`	`+ if chain.Config().IsShanghai(header.Number, header.Time) {`
`302`	`302`	`return fmt.Errorf("clique does not support shanghai fork")`
`303`	`303`	`}`
`304`		`- if chain.Config().IsCancun(header.Time) {`
	`304`	`+ if chain.Config().IsCancun(header.Number, header.Time) {`
`305`	`305`	`return fmt.Errorf("clique does not support cancun fork")`
`306`	`306`	`}`
`307`	`307`	`// All basic checks passed, verify cascading fields`
Original file line number	Diff line number	Diff line change
`@@ -262,10 +262,10 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, pa`
`262`	`262`	`if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(big.NewInt(1)) != 0 {`
`263`	`263`	`return consensus.ErrInvalidNumber`
`264`	`264`	`}`
`265`		`- if chain.Config().IsShanghai(header.Time) {`
	`265`	`+ if chain.Config().IsShanghai(header.Number, header.Time) {`
`266`	`266`	`return fmt.Errorf("ethash does not support shanghai fork")`
`267`	`267`	`}`
`268`		`- if chain.Config().IsCancun(header.Time) {`
	`268`	`+ if chain.Config().IsCancun(header.Number, header.Time) {`
`269`	`269`	`return fmt.Errorf("ethash does not support cancun fork")`
`270`	`270`	`}`
`271`	`271`	`// Add some fake checks for tests`
Original file line number	Diff line number	Diff line change
`@@ -463,7 +463,7 @@ func (g Genesis) ToBlock() types.Block {`
`463`	`463`	`}`
`464`	`464`	`}`
`465`	`465`	`var withdrawals []*types.Withdrawal`
`466`		`- if g.Config != nil && g.Config.IsShanghai(g.Timestamp) {`
	`466`	`+ if g.Config != nil && g.Config.IsShanghai(big.NewInt(int64(g.Number)), g.Timestamp) {`
`467`	`467`	`head.WithdrawalsHash = &types.EmptyWithdrawalsHash`
`468`	`468`	`withdrawals = make([]*types.Withdrawal, 0)`
`469`	`469`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ func (p StateProcessor) Process(block types.Block, statedb *state.StateDB, cfg`
`91`	`91`	`}`
`92`	`92`	`// Fail if Shanghai not enabled and len(withdrawals) is non-zero.`
`93`	`93`	`withdrawals := block.Withdrawals()`
`94`		`- if len(withdrawals) > 0 && !p.config.IsShanghai(block.Time()) {`
	`94`	`+ if len(withdrawals) > 0 && !p.config.IsShanghai(block.Number(), block.Time()) {`
`95`	`95`	`return nil, nil, 0, fmt.Errorf("withdrawals before shanghai")`
`96`	`96`	`}`
`97`	`97`	`// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)`
Original file line number	Diff line number	Diff line change
`@@ -403,7 +403,7 @@ func GenerateBadBlock(parent *types.Block, engine consensus.Engine, txs types.Tr`
`403`	`403`	`if config.IsLondon(header.Number) {`
`404`	`404`	`header.BaseFee = misc.CalcBaseFee(config, parent.Header())`
`405`	`405`	`}`
`406`		`- if config.IsShanghai(header.Time) {`
	`406`	`+ if config.IsShanghai(header.Number, header.Time) {`
`407`	`407`	`header.WithdrawalsHash = &types.EmptyWithdrawalsHash`
`408`	`408`	`}`
`409`	`409`	`var receipts []*types.Receipt`
`@@ -423,7 +423,7 @@ func GenerateBadBlock(parent *types.Block, engine consensus.Engine, txs types.Tr`
`423`	`423`	`}`
`424`	`424`	`header.Root = common.BytesToHash(hasher.Sum(nil))`
`425`	`425`	`// Assemble and return the final block for sealing`
`426`		`- if config.IsShanghai(header.Time) {`
	`426`	`+ if config.IsShanghai(header.Number, header.Time) {`
`427`	`427`	`return types.NewBlockWithWithdrawals(header, txs, nil, receipts, []*types.Withdrawal{}, trie.NewStackTrie(nil))`
`428`	`428`	`}`
`429`	`429`	`return types.NewBlock(header, txs, nil, receipts, trie.NewStackTrie(nil))`
Original file line number	Diff line number	Diff line change
`@@ -1397,7 +1397,7 @@ func (pool TxPool) reset(oldHead, newHead types.Header) {`
`1397`	`1397`	`pool.istanbul.Store(pool.chainconfig.IsIstanbul(next))`
`1398`	`1398`	`pool.eip2718.Store(pool.chainconfig.IsBerlin(next))`
`1399`	`1399`	`pool.eip1559.Store(pool.chainconfig.IsLondon(next))`
`1400`		`- pool.shanghai.Store(pool.chainconfig.IsShanghai(uint64(time.Now().Unix())))`
	`1400`	`+ pool.shanghai.Store(pool.chainconfig.IsShanghai(next, uint64(time.Now().Unix())))`
`1401`	`1401`	`}`
`1402`	`1402`
`1403`	`1403`	`// promoteExecutables moves transactions that have become processable from the`