faucet: update

.github/workflows/pre-release.yml

@@ -82,28 +82,28 @@ jobs:
       # ==============================
 
       - name: Upload Linux Build
-        uses: actions/upload-artifact@v4.3.3
+        uses: actions/upload-artifact@v3
         if: matrix.os == 'ubuntu-latest'
         with:
           name: linux
           path: ./build/bin/geth
 
       - name: Upload MacOS Build
-        uses: actions/upload-artifact@v4.3.3
+        uses: actions/upload-artifact@v3
         if: matrix.os == 'macos-latest'
         with:
           name: macos
           path: ./build/bin/geth
       
       - name: Upload Windows Build
-        uses: actions/upload-artifact@v4.3.3
+        uses: actions/upload-artifact@v3
         if: matrix.os == 'windows-latest'
         with:
           name: windows
           path: ./build/bin/geth.exe
 
       - name: Upload ARM-64 Build
-        uses: actions/upload-artifact@v4.3.3
+        uses: actions/upload-artifact@v3
         if: matrix.os == 'ubuntu-latest'
         with:
           name: arm64

.github/workflows/release.yml

@@ -81,28 +81,28 @@ jobs:
       # ==============================
 
       - name: Upload Linux Build
-        uses: actions/upload-artifact@v4.3.3
+        uses: actions/upload-artifact@v3
         if: matrix.os == 'ubuntu-latest'
         with:
           name: linux
           path: ./build/bin/geth
 
       - name: Upload MacOS Build
-        uses: actions/upload-artifact@v4.3.3
+        uses: actions/upload-artifact@v3
         if: matrix.os == 'macos-latest'
         with:
           name: macos
           path: ./build/bin/geth
       
       - name: Upload Windows Build
-        uses: actions/upload-artifact@v4.3.3
+        uses: actions/upload-artifact@v3
         if: matrix.os == 'windows-latest'
         with:
           name: windows
           path: ./build/bin/geth.exe
 
       - name: Upload ARM-64 Build
-        uses: actions/upload-artifact@v4.3.3
+        uses: actions/upload-artifact@v3
         if: matrix.os == 'ubuntu-latest'
         with:
           name: arm64

CHANGELOG.md

@@ -1,26 +1,4 @@
 # Changelog
-## v1.4.15
-### BUGFIX
-* [\#2680](https://github.com/bnb-chain/bsc/pull/2680) txpool: apply miner's gasceil to txpool
-* [\#2688](https://github.com/bnb-chain/bsc/pull/2688) txpool: set default GasCeil from 30M to 0
-* [\#2696](https://github.com/bnb-chain/bsc/pull/2696) miner: limit block size to eth protocol msg size
-* [\#2684](https://github.com/bnb-chain/bsc/pull/2684) eth: Add sidecars when available to broadcasted current block
-
-### FEATURE
-* [\#2672](https://github.com/bnb-chain/bsc/pull/2672) faucet: with mainnet balance check, 0.002BNB at least
-* [\#2678](https://github.com/bnb-chain/bsc/pull/2678) beaconserver: simulated beacon api server for op-stack
-* [\#2687](https://github.com/bnb-chain/bsc/pull/2687) faucet: support customized token
-* [\#2698](https://github.com/bnb-chain/bsc/pull/2698) faucet: add example for custimized token
-* [\#2706](https://github.com/bnb-chain/bsc/pull/2706) faucet: update DIN token faucet support
-
-### IMPROVEMENT
-* [\#2677](https://github.com/bnb-chain/bsc/pull/2677) log: add some p2p log
-* [\#2679](https://github.com/bnb-chain/bsc/pull/2679) build(deps): bump actions/download-artifact in /.github/workflows
-* [\#2662](https://github.com/bnb-chain/bsc/pull/2662) metrics: add some extra feature flags as node stats
-* [\#2675](https://github.com/bnb-chain/bsc/pull/2675) fetcher: Sleep after marking block as done when requeuing
-* [\#2695](https://github.com/bnb-chain/bsc/pull/2695) CI: nancy ignore CVE-2024-8421
-* [\#2689](https://github.com/bnb-chain/bsc/pull/2689) consensus/parlia: wait more time when processing huge blocks
-
 ## v1.4.14
 
 ### BUGFIX

README.md

@@ -9,15 +9,16 @@ https://pkg.go.dev/badge/github.com/ethereum/go-ethereum
 )](https://pkg.go.dev/github.com/ethereum/go-ethereum?tab=doc)
 [![Discord](https://img.shields.io/badge/discord-join%20chat-blue.svg)](https://discord.gg/z2VpC455eU)
 
-But from that baseline of EVM compatible, BNB Smart Chain introduces a system of 21 validators with Proof of Staked Authority (PoSA) consensus that can support short block time and lower fees. The most bonded validator candidates of staking will become validators and produce blocks. The double-sign detection and other slashing logic guarantee security, stability, and chain finality.
+But from that baseline of EVM compatible, BNB Smart Chain introduces  a system of 21 validators with Proof of Staked Authority (PoSA) consensus that can support short block time and lower fees. The most bonded validator candidates of staking will become validators and produce blocks. The double-sign detection and other slashing logic guarantee security, stability, and chain finality.
 
-**The BNB Smart Chain** will be:
+Cross-chain transfer and other communication are possible due to native support of interoperability. Relayers and on-chain contracts are developed to support that. BNB Beacon Chain DEX remains a liquid venue of the exchange of assets on both chains. This dual-chain architecture will be ideal for users to take advantage of the fast trading on one side and build their decentralized apps on the other side. **The BNB Smart Chain** will be:
 
 - **A self-sovereign blockchain**: Provides security and safety with elected validators.
 - **EVM-compatible**: Supports all the existing Ethereum tooling along with faster finality and cheaper transaction fees.
+- **Interoperable**: Comes with efficient native dual chain communication; Optimized for scaling high-performance dApps that require fast and smooth user experience.
 - **Distributed with on-chain governance**: Proof of Staked Authority brings in decentralization and community participants. As the native token, BNB will serve as both the gas of smart contract execution and tokens for staking.
 
-More details in [White Paper](https://github.com/bnb-chain/whitepaper/blob/master/WHITEPAPER.md).
+More details in [White Paper](https://www.bnbchain.org/en#smartChain).
 
 ## Key features
 
@@ -33,8 +34,18 @@ To combine DPoS and PoA for consensus, BNB Smart Chain implement a novel consens
 
 1. Blocks are produced by a limited set of validators.
 2. Validators take turns to produce blocks in a PoA manner, similar to Ethereum's Clique consensus engine.
-3. Validator set are elected in and out based on a staking based governance on BNB Smart Chain.
-4. Parlia consensus engine will interact with a set of [system contracts](https://docs.bnbchain.org/bnb-smart-chain/staking/overview/#system-contracts) to achieve liveness slash, revenue distributing and validator set renewing func.
+3. Validator set are elected in and out based on a staking based governance on BNB Beacon Chain.
+4. The validator set change is relayed via a cross-chain communication mechanism.
+5. Parlia consensus engine will interact with a set of [system contracts](https://docs.bnbchain.org/bnb-smart-chain/staking/overview/#system-contracts) to achieve liveness slash, revenue distributing and validator set renewing func.
+
+ 
+### Light Client of BNB Beacon Chain
+
+To achieve the cross-chain communication from BNB Beacon Chain to BNB Smart Chain, need introduce a on-chain light client verification algorithm.
+It contains two parts:
+
+1. [Stateless Precompiled contracts](https://github.com/bnb-chain/bsc/blob/master/core/vm/contracts_lightclient.go) to do tendermint header verification and Merkle Proof verification.
+2. [Stateful solidity contracts](https://github.com/bnb-chain/bsc-genesis-contract/blob/master/contracts/TendermintLightClient.sol) to store validator set and trusted appHash.  
 
 ## Native Token
 
@@ -42,6 +53,7 @@ BNB will run on BNB Smart Chain in the same way as ETH runs on Ethereum so that
 BNB will be used to:
 
 1. pay `gas` to deploy or invoke Smart Contract on BSC
+2. perform cross-chain operations, such as transfer token assets across BNB Smart Chain and BNB Beacon Chain.
 
 ## Building the source
 
@@ -235,7 +247,9 @@ running web servers, so malicious web pages could try to subvert locally availab
 APIs!**
 
 ### Operating a private network
-- [BSC-Deploy](https://github.com/bnb-chain/node-deploy/): deploy tool for setting up BNB Smart Chain.
+- [BSC-Deploy](https://github.com/bnb-chain/node-deploy/): deploy tool for setting up both BNB Beacon Chain, BNB Smart Chain and the cross chain infrastructure between them.
+- [BSC-Docker](https://github.com/bnb-chain/bsc-docker): deploy tool for setting up local BSC cluster in container.
+
 
 ## Running a bootnode
 

accounts/abi/bind/backend.go

@@ -24,6 +24,7 @@ import (
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/internal/ethapi"
 )
 
 var (
@@ -100,7 +101,7 @@ type ContractTransactor interface {
 	PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)
 
 	// SendTransactionConditional injects the conditional transaction into the pending pool for execution after verification.
-	SendTransactionConditional(ctx context.Context, tx *types.Transaction, opts types.TransactionOpts) error
+	SendTransactionConditional(ctx context.Context, tx *types.Transaction, opts ethapi.TransactionOpts) error
 }
 
 // DeployBackend wraps the operations needed by WaitMined and WaitDeployed.

accounts/abi/bind/base_test.go

@@ -31,6 +31,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/internal/ethapi"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/stretchr/testify/assert"
 )
@@ -75,7 +76,7 @@ func (mt *mockTransactor) SendTransaction(ctx context.Context, tx *types.Transac
 	return nil
 }
 
-func (mt *mockTransactor) SendTransactionConditional(ctx context.Context, tx *types.Transaction, opts types.TransactionOpts) error {
+func (mt *mockTransactor) SendTransactionConditional(ctx context.Context, tx *types.Transaction, opts ethapi.TransactionOpts) error {
 	return nil
 }
 

cmd/faucet/customized/README.md

@@ -2,10 +2,9 @@
 This is to support some projects with customized tokens that they want to integrate into the BSC faucet tool.
 
 ## 1.1. How to Integrate Your Token
-- Step 1: Fund the faucet address by sending a specific amount of your BEP-20 token to the faucet address (0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3) on the BSC testnet.
-- Step 2: Update this README.md file and create a Pull Request on [bsc github](https://github.com/bnb-chain/bsc) with relevant information.
-
-We will review the request, and once it is approved, the faucet tool will start to support the customized token and list it on https://www.bnbchain.org/en/testnet-faucet.
+- Step 1: Submmit a Pull Request to [bsc develop branch](https://github.com/bnb-chain/bsc/tree/develop) with relevant token information: `symbol`, `amount`, `icon`, `addr`. Append these information in [Section 2: Token List](#2token-list)
+- Step 2: Wait for approval, we will review the request, and once it is approved, the faucet tool will start to support the customized token and list it on https://www.bnbchain.org/en/testnet-faucet.
+- Step 3: Deposit your test token to designated address(0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3) on the BSC testnet.
 
 # 2.Token List
 ## 2.1.DemoToken
@@ -13,11 +12,3 @@ We will review the request, and once it is approved, the faucet tool will start
 - amount: 10000000000000000000
 - icon: ./demotoken.png
 - addr: https://testnet.bscscan.com/address/0xe15c158d768c306dae87b96430a94f884333e55d
-- fundTx: [0xa499dc9aaf918aff0507538a8aa80a88d0af6ca15054e6acc57b69c651945280](https://testnet.bscscan.com/tx/0x2a3f334b6ca756b64331bdec9e6cf3207ac50a4839fda6379e909de4d9a194ca)
-- 
-## 2.2.DIN token
-- symbol: DIN
-- amount: 10000000000000000000
-- icon: ./DIN.png
-- addr: https://testnet.bscscan.com/address/0xb8b40FcC5B4519Dba0E07Ac8821884CE90BdE677
-- fundTx: [0x17fc4c1db133830c7c146a0d41ca1df31cb446989ec11b382d58bb6176d6fde3](https://testnet.bscscan.com/tx/0x17fc4c1db133830c7c146a0d41ca1df31cb446989ec11b382d58bb6176d6fde3)

cmd/geth/chaincmd.go

@@ -63,8 +63,7 @@ var (
 		Flags: flags.Merge([]cli.Flag{
 			utils.CachePreimagesFlag,
 			utils.OverridePassedForkTime,
-			utils.OverridePascal,
-			utils.OverridePrague,
+			utils.OverrideBohr,
 			utils.OverrideVerkle,
 			utils.MultiDataBaseFlag,
 		}, utils.DatabaseFlags),
@@ -259,13 +258,9 @@ func initGenesis(ctx *cli.Context) error {
 		v := ctx.Uint64(utils.OverridePassedForkTime.Name)
 		overrides.OverridePassedForkTime = &v
 	}
-	if ctx.IsSet(utils.OverridePascal.Name) {
-		v := ctx.Uint64(utils.OverridePascal.Name)
-		overrides.OverridePascal = &v
-	}
-	if ctx.IsSet(utils.OverridePrague.Name) {
-		v := ctx.Uint64(utils.OverridePrague.Name)
-		overrides.OverridePrague = &v
+	if ctx.IsSet(utils.OverrideBohr.Name) {
+		v := ctx.Uint64(utils.OverrideBohr.Name)
+		overrides.OverrideBohr = &v
 	}
 	if ctx.IsSet(utils.OverrideVerkle.Name) {
 		v := ctx.Uint64(utils.OverrideVerkle.Name)

cmd/geth/config.go

@@ -191,13 +191,9 @@ func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
 		v := ctx.Uint64(utils.OverridePassedForkTime.Name)
 		cfg.Eth.OverridePassedForkTime = &v
 	}
-	if ctx.IsSet(utils.OverridePascal.Name) {
-		v := ctx.Uint64(utils.OverridePascal.Name)
-		cfg.Eth.OverridePascal = &v
-	}
-	if ctx.IsSet(utils.OverridePrague.Name) {
-		v := ctx.Uint64(utils.OverridePrague.Name)
-		cfg.Eth.OverridePrague = &v
+	if ctx.IsSet(utils.OverrideBohr.Name) {
+		v := ctx.Uint64(utils.OverrideBohr.Name)
+		cfg.Eth.OverrideBohr = &v
 	}
 	if ctx.IsSet(utils.OverrideVerkle.Name) {
 		v := ctx.Uint64(utils.OverrideVerkle.Name)

cmd/geth/main.go

@@ -73,8 +73,7 @@ var (
 		utils.SmartCardDaemonPathFlag,
 		utils.RialtoHash,
 		utils.OverridePassedForkTime,
-		utils.OverridePascal,
-		utils.OverridePrague,
+		utils.OverrideBohr,
 		utils.OverrideVerkle,
 		utils.OverrideFullImmutabilityThreshold,
 		utils.OverrideMinBlocksForBlobRequests,
@@ -92,7 +91,6 @@ var (
 		utils.TxPoolGlobalSlotsFlag,
 		utils.TxPoolAccountQueueFlag,
 		utils.TxPoolGlobalQueueFlag,
-		utils.TxPoolOverflowPoolSlotsFlag,
 		utils.TxPoolLifetimeFlag,
 		utils.TxPoolReannounceTimeFlag,
 		utils.BlobPoolDataDirFlag,

cmd/utils/flags.go

@@ -310,17 +310,12 @@ var (
 	}
 	OverridePassedForkTime = &cli.Uint64Flag{
 		Name:     "override.passedforktime",
-		Usage:    "Manually specify the hard fork timestamps which have passed on the mainnet, overriding the bundled setting",
+		Usage:    "Manually specify the hard fork timestamp except the last one, overriding the bundled setting",
 		Category: flags.EthCategory,
 	}
-	OverridePascal = &cli.Uint64Flag{
-		Name:     "override.pascal",
-		Usage:    "Manually specify the Pascal fork timestamp, overriding the bundled setting",
-		Category: flags.EthCategory,
-	}
-	OverridePrague = &cli.Uint64Flag{
-		Name:     "override.prague",
-		Usage:    "Manually specify the Prague fork timestamp, overriding the bundled setting",
+	OverrideBohr = &cli.Uint64Flag{
+		Name:     "override.bohr",
+		Usage:    "Manually specify the Bohr fork timestamp, overriding the bundled setting",
 		Category: flags.EthCategory,
 	}
 	OverrideVerkle = &cli.Uint64Flag{
@@ -458,12 +453,6 @@ var (
 		Value:    ethconfig.Defaults.TxPool.GlobalQueue,
 		Category: flags.TxPoolCategory,
 	}
-	TxPoolOverflowPoolSlotsFlag = &cli.Uint64Flag{
-		Name:     "txpool.overflowpoolslots",
-		Usage:    "Maximum number of transaction slots in overflow pool",
-		Value:    ethconfig.Defaults.TxPool.OverflowPoolSlots,
-		Category: flags.TxPoolCategory,
-	}
 	TxPoolLifetimeFlag = &cli.DurationFlag{
 		Name:     "txpool.lifetime",
 		Usage:    "Maximum amount of time non-executable transaction are queued",
@@ -1795,9 +1784,6 @@ func setTxPool(ctx *cli.Context, cfg *legacypool.Config) {
 	if ctx.IsSet(TxPoolGlobalQueueFlag.Name) {
 		cfg.GlobalQueue = ctx.Uint64(TxPoolGlobalQueueFlag.Name)
 	}
-	if ctx.IsSet(TxPoolOverflowPoolSlotsFlag.Name) {
-		cfg.OverflowPoolSlots = ctx.Uint64(TxPoolOverflowPoolSlotsFlag.Name)
-	}
 	if ctx.IsSet(TxPoolLifetimeFlag.Name) {
 		cfg.Lifetime = ctx.Duration(TxPoolLifetimeFlag.Name)
 	}
@@ -2319,17 +2305,16 @@ func EnableNodeInfo(poolConfig *legacypool.Config, nodeInfo *p2p.NodeInfo) Setup
 	return func() {
 		// register node info into metrics
 		metrics.NewRegisteredLabel("node-info", nil).Mark(map[string]interface{}{
-			"Enode":             nodeInfo.Enode,
-			"ENR":               nodeInfo.ENR,
-			"ID":                nodeInfo.ID,
-			"PriceLimit":        poolConfig.PriceLimit,
-			"PriceBump":         poolConfig.PriceBump,
-			"AccountSlots":      poolConfig.AccountSlots,
-			"GlobalSlots":       poolConfig.GlobalSlots,
-			"AccountQueue":      poolConfig.AccountQueue,
-			"GlobalQueue":       poolConfig.GlobalQueue,
-			"OverflowPoolSlots": poolConfig.OverflowPoolSlots,
-			"Lifetime":          poolConfig.Lifetime,
+			"Enode":        nodeInfo.Enode,
+			"ENR":          nodeInfo.ENR,
+			"ID":           nodeInfo.ID,
+			"PriceLimit":   poolConfig.PriceLimit,
+			"PriceBump":    poolConfig.PriceBump,
+			"AccountSlots": poolConfig.AccountSlots,
+			"GlobalSlots":  poolConfig.GlobalSlots,
+			"AccountQueue": poolConfig.AccountQueue,
+			"GlobalQueue":  poolConfig.GlobalQueue,
+			"Lifetime":     poolConfig.Lifetime,
 		})
 	}
 }

core/block_validator.go

@@ -66,6 +66,31 @@ func NewBlockValidator(config *params.ChainConfig, blockchain *BlockChain, engin
 	return validator
 }
 
+// ValidateListsInBody validates that UncleHash, WithdrawalsHash, and WithdrawalsHash correspond to the lists in the block body, respectively.
+func ValidateListsInBody(block *types.Block) error {
+	header := block.Header()
+	if hash := types.CalcUncleHash(block.Uncles()); hash != header.UncleHash {
+		return fmt.Errorf("uncle root hash mismatch (header value %x, calculated %x)", header.UncleHash, hash)
+	}
+	if hash := types.DeriveSha(block.Transactions(), trie.NewStackTrie(nil)); hash != header.TxHash {
+		return fmt.Errorf("transaction root hash mismatch: have %x, want %x", hash, header.TxHash)
+	}
+	// Withdrawals are present after the Shanghai fork.
+	if header.WithdrawalsHash != nil {
+		// Withdrawals list must be present in body after Shanghai.
+		if block.Withdrawals() == nil {
+			return errors.New("missing withdrawals in block body")
+		}
+		if hash := types.DeriveSha(block.Withdrawals(), trie.NewStackTrie(nil)); hash != *header.WithdrawalsHash {
+			return fmt.Errorf("withdrawals root hash mismatch (header value %x, calculated %x)", *header.WithdrawalsHash, hash)
+		}
+	} else if block.Withdrawals() != nil { // Withdrawals turn into empty from nil when BlockBody has Sidecars
+		// Withdrawals are not allowed prior to shanghai fork
+		return errors.New("withdrawals present in block body")
+	}
+	return nil
+}
+
 // ValidateBody validates the given block's uncles and verifies the block
 // header's transaction and uncle roots. The headers are assumed to be already
 // validated at this point.
@@ -83,31 +108,12 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error {
 	if err := v.engine.VerifyUncles(v.bc, block); err != nil {
 		return err
 	}
-	if hash := types.CalcUncleHash(block.Uncles()); hash != header.UncleHash {
-		return fmt.Errorf("uncle root hash mismatch (header value %x, calculated %x)", header.UncleHash, hash)
-	}
 
 	validateFuns := []func() error{
 		func() error {
-			if hash := types.DeriveSha(block.Transactions(), trie.NewStackTrie(nil)); hash != header.TxHash {
-				return fmt.Errorf("transaction root hash mismatch: have %x, want %x", hash, header.TxHash)
-			}
-			return nil
+			return ValidateListsInBody(block)
 		},
 		func() error {
-			// Withdrawals are present after the Shanghai fork.
-			if header.WithdrawalsHash != nil {
-				// Withdrawals list must be present in body after Shanghai.
-				if block.Withdrawals() == nil {
-					return errors.New("missing withdrawals in block body")
-				}
-				if hash := types.DeriveSha(block.Withdrawals(), trie.NewStackTrie(nil)); hash != *header.WithdrawalsHash {
-					return fmt.Errorf("withdrawals root hash mismatch (header value %x, calculated %x)", *header.WithdrawalsHash, hash)
-				}
-			} else if block.Withdrawals() != nil { // Withdrawals turn into empty from nil when BlockBody has Sidecars
-				// Withdrawals are not allowed prior to shanghai fork
-				return errors.New("withdrawals present in block body")
-			}
 			// Blob transactions may be present after the Cancun fork.
 			var blobs int
 			for i, tx := range block.Transactions() {

core/genesis.go

@@ -217,8 +217,7 @@ func (e *GenesisMismatchError) Error() string {
 // Typically, these modifications involve hardforks that are not enabled on the BSC mainnet, intended for testing purposes.
 type ChainOverrides struct {
 	OverridePassedForkTime *uint64
-	OverridePascal         *uint64
-	OverridePrague         *uint64
+	OverrideBohr           *uint64
 	OverrideVerkle         *uint64
 }
 
@@ -253,13 +252,9 @@ func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *triedb.Database, g
 				config.CancunTime = overrides.OverridePassedForkTime
 				config.HaberTime = overrides.OverridePassedForkTime
 				config.HaberFixTime = overrides.OverridePassedForkTime
-				config.BohrTime = overrides.OverridePassedForkTime
 			}
-			if overrides != nil && overrides.OverridePascal != nil {
-				config.PascalTime = overrides.OverridePascal
-			}
-			if overrides != nil && overrides.OverridePrague != nil {
-				config.PragueTime = overrides.OverridePrague
+			if overrides != nil && overrides.OverrideBohr != nil {
+				config.BohrTime = overrides.OverrideBohr
 			}
 			if overrides != nil && overrides.OverrideVerkle != nil {
 				config.VerkleTime = overrides.OverrideVerkle

core/systemcontracts/bohr/types.go

@@ -17,3 +17,11 @@ var (
 	//go:embed chapel/StakeHubContract
 	ChapelStakeHubContract string
 )
+
+// contract codes for Rialto upgrade
+var (
+	//go:embed rialto/ValidatorContract
+	RialtoValidatorContract string
+	//go:embed rialto/StakeHubContract
+	RialtoStakeHubContract string
+)

core/systemcontracts/pascal/types.go

@@ -1,168 +0,0 @@
-package pascal
-
-import _ "embed"
-
-// contract codes for Mainnet upgrade
-var (
-
-	//go:embed mainnet/ValidatorContract
-	MainnetValidatorContract string
-
-	//go:embed mainnet/SlashContract
-	MainnetSlashContract string
-
-	//go:embed mainnet/SystemRewardContract
-	MainnetSystemRewardContract string
-
-	//go:embed mainnet/LightClientContract
-	MainnetLightClientContract string
-
-	//go:embed mainnet/TokenHubContract
-	MainnetTokenHubContract string
-
-	//go:embed mainnet/RelayerIncentivizeContract
-	MainnetRelayerIncentivizeContract string
-
-	//go:embed mainnet/RelayerHubContract
-	MainnetRelayerHubContract string
-
-	//go:embed mainnet/GovHubContract
-	MainnetGovHubContract string
-
-	//go:embed mainnet/TokenManagerContract
-	MainnetTokenManagerContract string
-
-	//go:embed mainnet/CrossChainContract
-	MainnetCrossChainContract string
-
-	//go:embed mainnet/StakingContract
-	MainnetStakingContract string
-
-	//go:embed mainnet/StakeHubContract
-	MainnetStakeHubContract string
-
-	//go:embed mainnet/StakeCreditContract
-	MainnetStakeCreditContract string
-
-	//go:embed mainnet/GovernorContract
-	MainnetGovernorContract string
-
-	//go:embed mainnet/GovTokenContract
-	MainnetGovTokenContract string
-
-	//go:embed mainnet/TimelockContract
-	MainnetTimelockContract string
-
-	//go:embed mainnet/TokenRecoverPortalContract
-	MainnetTokenRecoverPortalContract string
-)
-
-// contract codes for Chapel upgrade
-var (
-
-	//go:embed chapel/ValidatorContract
-	ChapelValidatorContract string
-
-	//go:embed chapel/SlashContract
-	ChapelSlashContract string
-
-	//go:embed chapel/SystemRewardContract
-	ChapelSystemRewardContract string
-
-	//go:embed chapel/LightClientContract
-	ChapelLightClientContract string
-
-	//go:embed chapel/TokenHubContract
-	ChapelTokenHubContract string
-
-	//go:embed chapel/RelayerIncentivizeContract
-	ChapelRelayerIncentivizeContract string
-
-	//go:embed chapel/RelayerHubContract
-	ChapelRelayerHubContract string
-
-	//go:embed chapel/GovHubContract
-	ChapelGovHubContract string
-
-	//go:embed chapel/TokenManagerContract
-	ChapelTokenManagerContract string
-
-	//go:embed chapel/CrossChainContract
-	ChapelCrossChainContract string
-
-	//go:embed chapel/StakingContract
-	ChapelStakingContract string
-
-	//go:embed chapel/StakeHubContract
-	ChapelStakeHubContract string
-
-	//go:embed chapel/StakeCreditContract
-	ChapelStakeCreditContract string
-
-	//go:embed chapel/GovernorContract
-	ChapelGovernorContract string
-
-	//go:embed chapel/GovTokenContract
-	ChapelGovTokenContract string
-
-	//go:embed chapel/TimelockContract
-	ChapelTimelockContract string
-
-	//go:embed chapel/TokenRecoverPortalContract
-	ChapelTokenRecoverPortalContract string
-)
-
-// contract codes for Rialto upgrade
-var (
-
-	//go:embed rialto/ValidatorContract
-	RialtoValidatorContract string
-
-	//go:embed rialto/SlashContract
-	RialtoSlashContract string
-
-	//go:embed rialto/SystemRewardContract
-	RialtoSystemRewardContract string
-
-	//go:embed rialto/LightClientContract
-	RialtoLightClientContract string
-
-	//go:embed rialto/TokenHubContract
-	RialtoTokenHubContract string
-
-	//go:embed rialto/RelayerIncentivizeContract
-	RialtoRelayerIncentivizeContract string
-
-	//go:embed rialto/RelayerHubContract
-	RialtoRelayerHubContract string
-
-	//go:embed rialto/GovHubContract
-	RialtoGovHubContract string
-
-	//go:embed rialto/TokenManagerContract
-	RialtoTokenManagerContract string
-
-	//go:embed rialto/CrossChainContract
-	RialtoCrossChainContract string
-
-	//go:embed rialto/StakingContract
-	RialtoStakingContract string
-
-	//go:embed rialto/StakeHubContract
-	RialtoStakeHubContract string
-
-	//go:embed rialto/StakeCreditContract
-	RialtoStakeCreditContract string
-
-	//go:embed rialto/GovernorContract
-	RialtoGovernorContract string
-
-	//go:embed rialto/GovTokenContract
-	RialtoGovTokenContract string
-
-	//go:embed rialto/TimelockContract
-	RialtoTimelockContract string
-
-	//go:embed rialto/TokenRecoverPortalContract
-	RialtoTokenRecoverPortalContract string
-)

core/systemcontracts/upgrade.go

@@ -20,7 +20,6 @@ import (
 	"github.com/ethereum/go-ethereum/core/systemcontracts/mirror"
 	"github.com/ethereum/go-ethereum/core/systemcontracts/moran"
 	"github.com/ethereum/go-ethereum/core/systemcontracts/niels"
-	"github.com/ethereum/go-ethereum/core/systemcontracts/pascal"
 	"github.com/ethereum/go-ethereum/core/systemcontracts/planck"
 	"github.com/ethereum/go-ethereum/core/systemcontracts/plato"
 	"github.com/ethereum/go-ethereum/core/systemcontracts/ramanujan"
@@ -83,8 +82,6 @@ var (
 	haberFixUpgrade = make(map[string]*Upgrade)
 
 	bohrUpgrade = make(map[string]*Upgrade)
-
-	pascalUpgrade = make(map[string]*Upgrade)
 )
 
 func init() {
@@ -776,275 +773,18 @@ func init() {
 		},
 	}
 
-	pascalUpgrade[mainNet] = &Upgrade{
-		UpgradeName: "pascal",
+	bohrUpgrade[rialtoNet] = &Upgrade{
+		UpgradeName: "bohr",
 		Configs: []*UpgradeConfig{
 			{
 				ContractAddr: common.HexToAddress(ValidatorContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetValidatorContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(SlashContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetSlashContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(SystemRewardContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetSystemRewardContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(LightClientContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetLightClientContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(TokenHubContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetTokenHubContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(RelayerIncentivizeContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetRelayerIncentivizeContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(RelayerHubContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetRelayerHubContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(GovHubContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetGovHubContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(TokenManagerContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetTokenManagerContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(CrossChainContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetCrossChainContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(StakingContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetStakingContract,
+				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/398c9364aad5261c1ecd90ac3ab2df89b65c45e3",
+				Code:         bohr.RialtoValidatorContract,
 			},
 			{
 				ContractAddr: common.HexToAddress(StakeHubContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetStakeHubContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(StakeCreditContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetStakeCreditContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(GovernorContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetGovernorContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(GovTokenContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetGovTokenContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(TimelockContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetTimelockContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(TokenRecoverPortalContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.MainnetTokenRecoverPortalContract,
-			},
-		},
-	}
-
-	pascalUpgrade[chapelNet] = &Upgrade{
-		UpgradeName: "pascal",
-		Configs: []*UpgradeConfig{
-			{
-				ContractAddr: common.HexToAddress(ValidatorContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelValidatorContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(SlashContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelSlashContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(SystemRewardContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelSystemRewardContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(LightClientContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelLightClientContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(TokenHubContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelTokenHubContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(RelayerIncentivizeContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelRelayerIncentivizeContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(RelayerHubContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelRelayerHubContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(GovHubContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelGovHubContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(TokenManagerContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelTokenManagerContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(CrossChainContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelCrossChainContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(StakingContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelStakingContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(StakeHubContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelStakeHubContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(StakeCreditContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelStakeCreditContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(GovernorContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelGovernorContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(GovTokenContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelGovTokenContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(TimelockContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelTimelockContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(TokenRecoverPortalContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.ChapelTokenRecoverPortalContract,
-			},
-		},
-	}
-
-	pascalUpgrade[rialtoNet] = &Upgrade{
-		UpgradeName: "pascal",
-		Configs: []*UpgradeConfig{
-			{
-				ContractAddr: common.HexToAddress(ValidatorContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoValidatorContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(SlashContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoSlashContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(SystemRewardContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoSystemRewardContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(LightClientContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoLightClientContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(TokenHubContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoTokenHubContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(RelayerIncentivizeContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoRelayerIncentivizeContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(RelayerHubContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoRelayerHubContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(GovHubContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoGovHubContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(TokenManagerContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoTokenManagerContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(CrossChainContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoCrossChainContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(StakingContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoStakingContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(StakeHubContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoStakeHubContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(StakeCreditContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoStakeCreditContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(GovernorContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoGovernorContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(GovTokenContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoGovTokenContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(TimelockContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoTimelockContract,
-			},
-			{
-				ContractAddr: common.HexToAddress(TokenRecoverPortalContract),
-				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/020c0459e37d1f9d635c1cff86dd1099ab1383fa",
-				Code:         pascal.RialtoTokenRecoverPortalContract,
+				CommitUrl:    "https://github.com/bnb-chain/bsc-genesis-contract/commit/398c9364aad5261c1ecd90ac3ab2df89b65c45e3",
+				Code:         bohr.RialtoStakeHubContract,
 			},
 		},
 	}
@@ -1133,10 +873,6 @@ func UpgradeBuildInSystemContract(config *params.ChainConfig, blockNumber *big.I
 		applySystemContractUpgrade(bohrUpgrade[network], blockNumber, statedb, logger)
 	}
 
-	if config.IsOnPascal(blockNumber, lastBlockTime, blockTime) {
-		applySystemContractUpgrade(pascalUpgrade[network], blockNumber, statedb, logger)
-	}
-
 	/*
 		apply other upgrades
 	*/

core/txpool/legacypool/legacypool.go

@@ -19,7 +19,6 @@ package legacypool
 
 import (
 	"errors"
-	"fmt"
 	"math"
 	"math/big"
 	"sort"
@@ -100,11 +99,10 @@ var (
 	// that this number is pretty low, since txpool reorgs happen very frequently.
 	dropBetweenReorgHistogram = metrics.NewRegisteredHistogram("txpool/dropbetweenreorg", nil, metrics.NewExpDecaySample(1028, 0.015))
 
-	pendingGauge      = metrics.NewRegisteredGauge("txpool/pending", nil)
-	queuedGauge       = metrics.NewRegisteredGauge("txpool/queued", nil)
-	localGauge        = metrics.NewRegisteredGauge("txpool/local", nil)
-	slotsGauge        = metrics.NewRegisteredGauge("txpool/slots", nil)
-	OverflowPoolGauge = metrics.NewRegisteredGauge("txpool/overflowpool", nil)
+	pendingGauge = metrics.NewRegisteredGauge("txpool/pending", nil)
+	queuedGauge  = metrics.NewRegisteredGauge("txpool/queued", nil)
+	localGauge   = metrics.NewRegisteredGauge("txpool/local", nil)
+	slotsGauge   = metrics.NewRegisteredGauge("txpool/slots", nil)
 
 	reheapTimer = metrics.NewRegisteredTimer("txpool/reheap", nil)
 )
@@ -135,11 +133,10 @@ type Config struct {
 	PriceLimit uint64 // Minimum gas price to enforce for acceptance into the pool
 	PriceBump  uint64 // Minimum price bump percentage to replace an already existing transaction (nonce)
 
-	AccountSlots      uint64 // Number of executable transaction slots guaranteed per account
-	GlobalSlots       uint64 // Maximum number of executable transaction slots for all accounts
-	AccountQueue      uint64 // Maximum number of non-executable transaction slots permitted per account
-	GlobalQueue       uint64 // Maximum number of non-executable transaction slots for all accounts
-	OverflowPoolSlots uint64 // Maximum number of transaction slots in overflow pool
+	AccountSlots uint64 // Number of executable transaction slots guaranteed per account
+	GlobalSlots  uint64 // Maximum number of executable transaction slots for all accounts
+	AccountQueue uint64 // Maximum number of non-executable transaction slots permitted per account
+	GlobalQueue  uint64 // Maximum number of non-executable transaction slots for all accounts
 
 	Lifetime       time.Duration // Maximum amount of time non-executable transaction are queued
 	ReannounceTime time.Duration // Duration for announcing local pending transactions again
@@ -153,11 +150,10 @@ var DefaultConfig = Config{
 	PriceLimit: 1,
 	PriceBump:  10,
 
-	AccountSlots:      16,
-	GlobalSlots:       4096 + 1024, // urgent + floating queue capacity with 4:1 ratio
-	AccountQueue:      64,
-	GlobalQueue:       1024,
-	OverflowPoolSlots: 0,
+	AccountSlots: 16,
+	GlobalSlots:  4096 + 1024, // urgent + floating queue capacity with 4:1 ratio
+	AccountQueue: 64,
+	GlobalQueue:  1024,
 
 	Lifetime:       3 * time.Hour,
 	ReannounceTime: 10 * 365 * 24 * time.Hour,
@@ -239,8 +235,6 @@ type LegacyPool struct {
 	all     *lookup                      // All transactions to allow lookups
 	priced  *pricedList                  // All transactions sorted by price
 
-	localBufferPool *TxOverflowPool // Local buffer transactions
-
 	reqResetCh      chan *txpoolResetRequest
 	reqPromoteCh    chan *accountSet
 	queueTxEventCh  chan *types.Transaction
@@ -278,7 +272,6 @@ func New(config Config, chain BlockChain) *LegacyPool {
 		reorgDoneCh:     make(chan chan struct{}),
 		reorgShutdownCh: make(chan struct{}),
 		initDoneCh:      make(chan struct{}),
-		localBufferPool: NewTxOverflowPoolHeap(config.OverflowPoolSlots),
 	}
 	pool.locals = newAccountSet(pool.signer)
 	for _, addr := range config.Locals {
@@ -415,6 +408,7 @@ func (pool *LegacyPool) loop() {
 					if !pool.locals.contains(addr) {
 						continue
 					}
+
 					for _, tx := range list.Flatten() {
 						// Default ReannounceTime is 10 years, won't announce by default.
 						if time.Since(tx.Time()) < pool.config.ReannounceTime {
@@ -523,17 +517,6 @@ func (pool *LegacyPool) Stats() (int, int) {
 	return pool.stats()
 }
 
-func (pool *LegacyPool) statsOverflowPool() int {
-	pool.mu.RLock()
-	defer pool.mu.RUnlock()
-
-	if pool.localBufferPool == nil {
-		return 0
-	}
-
-	return pool.localBufferPool.Size()
-}
-
 // stats retrieves the current pool stats, namely the number of pending and the
 // number of queued (non-executable) transactions.
 func (pool *LegacyPool) stats() (int, int) {
@@ -848,8 +831,6 @@ func (pool *LegacyPool) add(tx *types.Transaction, local bool) (replaced bool, e
 			}
 		}
 
-		pool.addToOverflowPool(drop, isLocal)
-
 		// Kick out the underpriced remote transactions.
 		for _, tx := range drop {
 			log.Trace("Discarding freshly underpriced transaction", "hash", tx.Hash(), "gasTipCap", tx.GasTipCap(), "gasFeeCap", tx.GasFeeCap())
@@ -906,29 +887,6 @@ func (pool *LegacyPool) add(tx *types.Transaction, local bool) (replaced bool, e
 	return replaced, nil
 }
 
-func (pool *LegacyPool) addToOverflowPool(drop types.Transactions, isLocal bool) {
-	// calculate total number of slots in drop. Accordingly add them to OverflowPool (if there is space)
-	availableSlotsOverflowPool := pool.availableSlotsOverflowPool()
-	if availableSlotsOverflowPool > 0 {
-		// transfer availableSlotsOverflowPool number of transactions slots from drop to OverflowPool
-		currentSlotsUsed := 0
-		for i, tx := range drop {
-			txSlots := numSlots(tx)
-			if currentSlotsUsed+txSlots <= availableSlotsOverflowPool {
-				from, _ := types.Sender(pool.signer, tx)
-				pool.localBufferPool.Add(tx)
-				log.Debug("adding to OverflowPool", "transaction", tx.Hash().String(), "from", from.String())
-				currentSlotsUsed += txSlots
-			} else {
-				log.Debug("not all got added to OverflowPool", "totalAdded", i+1)
-				return
-			}
-		}
-	} else {
-		log.Debug("adding to OverflowPool unsuccessful", "availableSlotsOverflowPool", availableSlotsOverflowPool)
-	}
-}
-
 // isGapped reports whether the given transaction is immediately executable.
 func (pool *LegacyPool) isGapped(from common.Address, tx *types.Transaction) bool {
 	// Short circuit if transaction falls within the scope of the pending list
@@ -1375,6 +1333,7 @@ func (pool *LegacyPool) runReorg(done chan struct{}, reset *txpoolResetRequest,
 		reorgDurationTimer.Update(time.Since(t0))
 	}(time.Now())
 	defer close(done)
+
 	var promoteAddrs []common.Address
 	if dirtyAccounts != nil && reset == nil {
 		// Only dirty accounts need to be promoted, unless we're resetting.
@@ -1432,9 +1391,6 @@ func (pool *LegacyPool) runReorg(done chan struct{}, reset *txpoolResetRequest,
 	pool.changesSinceReorg = 0 // Reset change counter
 	pool.mu.Unlock()
 
-	// Transfer transactions from OverflowPool to MainPool for new block import
-	pool.transferTransactions()
-
 	// Notify subsystems for newly added transactions
 	for _, tx := range promoted {
 		addr, _ := types.Sender(pool.signer, tx)
@@ -2082,50 +2038,3 @@ func (t *lookup) RemotesBelowTip(threshold *big.Int) types.Transactions {
 func numSlots(tx *types.Transaction) int {
 	return int((tx.Size() + txSlotSize - 1) / txSlotSize)
 }
-
-// transferTransactions moves transactions from OverflowPool to MainPool
-func (pool *LegacyPool) transferTransactions() {
-	// Fail fast if the overflow pool is empty
-	if pool.localBufferPool.Size() == 0 {
-		return
-	}
-
-	maxMainPoolSize := int(pool.config.GlobalSlots + pool.config.GlobalQueue)
-	// Use pool.all.Slots() to get the total slots used by all transactions
-	currentMainPoolSize := pool.all.Slots()
-	if currentMainPoolSize >= maxMainPoolSize {
-		return
-	}
-
-	extraSlots := maxMainPoolSize - currentMainPoolSize
-	extraTransactions := (extraSlots + 3) / 4 // Since a transaction can take up to 4 slots
-	log.Debug("Will attempt to transfer from OverflowPool to MainPool", "transactions", extraTransactions)
-	txs := pool.localBufferPool.Flush(extraTransactions)
-	if len(txs) == 0 {
-		return
-	}
-
-	pool.Add(txs, true, false)
-}
-
-func (pool *LegacyPool) availableSlotsOverflowPool() int {
-	maxOverflowPoolSize := int(pool.config.OverflowPoolSlots)
-	availableSlots := maxOverflowPoolSize - pool.localBufferPool.Size()
-	if availableSlots > 0 {
-		return availableSlots
-	}
-	return 0
-}
-
-func (pool *LegacyPool) PrintTxStats() {
-	for _, l := range pool.pending {
-		for _, transaction := range l.txs.items {
-			from, _ := types.Sender(pool.signer, transaction)
-			fmt.Println("from: ", from, " Pending:", transaction.Hash().String(), transaction.GasFeeCap(), transaction.GasTipCap())
-		}
-	}
-
-	pool.localBufferPool.PrintTxStats()
-	fmt.Println("length of all: ", pool.all.Slots())
-	fmt.Println("----------------------------------------------------")
-}

core/txpool/legacypool/legacypool_test.go

@@ -40,7 +40,6 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/trie"
 	"github.com/holiman/uint256"
-	"github.com/stretchr/testify/assert"
 )
 
 var (
@@ -1740,7 +1739,6 @@ func TestRepricingKeepsLocals(t *testing.T) {
 // Note, local transactions are never allowed to be dropped.
 func TestUnderpricing(t *testing.T) {
 	t.Parallel()
-	testTxPoolConfig.OverflowPoolSlots = 5
 
 	// Create the pool to test the pricing enforcement with
 	statedb, _ := state.New(types.EmptyRootHash, state.NewDatabase(rawdb.NewMemoryDatabase()), nil)
@@ -1933,8 +1931,6 @@ func TestUnderpricingDynamicFee(t *testing.T) {
 	pool.config.GlobalSlots = 2
 	pool.config.GlobalQueue = 2
 
-	pool.config.OverflowPoolSlots = 0
-
 	// Keep track of transaction events to ensure all executables get announced
 	events := make(chan core.NewTxsEvent, 32)
 	sub := pool.txFeed.Subscribe(events)
@@ -1959,6 +1955,7 @@ func TestUnderpricingDynamicFee(t *testing.T) {
 	// Import the batch and that both pending and queued transactions match up
 	pool.addRemotes(txs) // Pend K0:0, K0:1; Que K1:1
 	pool.addLocal(ltx)   // +K2:0 => Pend K0:0, K0:1, K2:0; Que K1:1
+
 	pending, queued := pool.Stats()
 	if pending != 3 {
 		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 3)
@@ -1998,9 +1995,9 @@ func TestUnderpricingDynamicFee(t *testing.T) {
 		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 2)
 	}
 	if queued != 2 {
-		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 1)
+		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 2)
 	}
-	if err := validateEvents(events, 2); err != nil { // todo make it 4...After this validateEvents the pending becomes 3?!
+	if err := validateEvents(events, 2); err != nil {
 		t.Fatalf("additional event firing failed: %v", err)
 	}
 	if err := validatePoolInternals(pool); err != nil {
@@ -2015,12 +2012,11 @@ func TestUnderpricingDynamicFee(t *testing.T) {
 	if err := pool.addLocal(ltx); err != nil {
 		t.Fatalf("failed to add new underpriced local transaction: %v", err)
 	}
-
 	pending, queued = pool.Stats()
-	if pending != 3 { // 3
+	if pending != 3 {
 		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 3)
 	}
-	if queued != 1 { // 1
+	if queued != 1 {
 		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 1)
 	}
 	if err := validateEvents(events, 2); err != nil {
@@ -2036,51 +2032,41 @@ func TestUnderpricingDynamicFee(t *testing.T) {
 func TestDualHeapEviction(t *testing.T) {
 	t.Parallel()
 
-	testTxPoolConfig.OverflowPoolSlots = 1
 	pool, _ := setupPoolWithConfig(eip1559Config)
 	defer pool.Close()
 
-	pool.config.GlobalSlots = 2
-	pool.config.GlobalQueue = 2
-	pool.config.OverflowPoolSlots = 1
+	pool.config.GlobalSlots = 10
+	pool.config.GlobalQueue = 10
 
 	var (
 		highTip, highCap *types.Transaction
 		baseFee          int
-		highCapValue     int64
-		highTipValue     int64
 	)
 
 	check := func(tx *types.Transaction, name string) {
 		if pool.all.GetRemote(tx.Hash()) == nil {
-			t.Fatalf("highest %s transaction evicted from the pool, gasTip: %s, gasFeeCap: %s, hash: %s", name, highTip.GasTipCap().String(), highCap.GasFeeCap().String(), tx.Hash().String())
+			t.Fatalf("highest %s transaction evicted from the pool", name)
 		}
 	}
 
 	add := func(urgent bool) {
-		for i := 0; i < 4; i++ {
+		for i := 0; i < 20; i++ {
 			var tx *types.Transaction
 			// Create a test accounts and fund it
 			key, _ := crypto.GenerateKey()
 			testAddBalance(pool, crypto.PubkeyToAddress(key.PublicKey), big.NewInt(1000000000000))
 			if urgent {
 				tx = dynamicFeeTx(0, 100000, big.NewInt(int64(baseFee+1+i)), big.NewInt(int64(1+i)), key)
-				if int64(1+i) > highTipValue || (int64(1+i) == highTipValue && int64(baseFee+1+i) > highTip.GasFeeCap().Int64()) {
-					highTipValue = int64(1 + i)
-					highTip = tx
-				}
+				highTip = tx
 			} else {
 				tx = dynamicFeeTx(0, 100000, big.NewInt(int64(baseFee+200+i)), big.NewInt(1), key)
-				if int64(baseFee+200+i) > highCapValue {
-					highCapValue = int64(baseFee + 200 + i)
-					highCap = tx
-				}
+				highCap = tx
 			}
 			pool.addRemotesSync([]*types.Transaction{tx})
 		}
 		pending, queued := pool.Stats()
-		if pending+queued != 4 {
-			t.Fatalf("transaction count mismatch: have %d, want %d, pending %d, queued %d, OverflowPool %d", pending+queued, 5, pending, queued, pool.localBufferPool.Size())
+		if pending+queued != 20 {
+			t.Fatalf("transaction count mismatch: have %d, want %d", pending+queued, 10)
 		}
 	}
 
@@ -2245,50 +2231,6 @@ func TestReplacement(t *testing.T) {
 	}
 }
 
-func TestTransferTransactions(t *testing.T) {
-	t.Parallel()
-	testTxPoolConfig.OverflowPoolSlots = 1
-	pool, _ := setupPoolWithConfig(eip1559Config)
-	defer pool.Close()
-
-	pool.config.GlobalSlots = 1
-	pool.config.GlobalQueue = 2
-
-	// Create a number of test accounts and fund them
-	keys := make([]*ecdsa.PrivateKey, 5)
-	for i := 0; i < len(keys); i++ {
-		keys[i], _ = crypto.GenerateKey()
-		testAddBalance(pool, crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000))
-	}
-
-	tx := dynamicFeeTx(0, 100000, big.NewInt(3), big.NewInt(2), keys[0])
-	from, _ := types.Sender(pool.signer, tx)
-	pool.addToOverflowPool([]*types.Transaction{tx}, true)
-	pending, queue := pool.Stats()
-
-	assert.Equal(t, 0, pending, "pending transactions mismatched")
-	assert.Equal(t, 0, queue, "queued transactions mismatched")
-	assert.Equal(t, 1, pool.statsOverflowPool(), "OverflowPool size unexpected")
-
-	tx2 := dynamicFeeTx(0, 100000, big.NewInt(3), big.NewInt(2), keys[1])
-	pool.addToOverflowPool([]*types.Transaction{tx2}, true)
-	assert.Equal(t, 1, pool.statsOverflowPool(), "OverflowPool size unexpected")
-	<-pool.requestPromoteExecutables(newAccountSet(pool.signer, from))
-	pending, queue = pool.Stats()
-
-	assert.Equal(t, 0, pending, "pending transactions mismatched")
-	assert.Equal(t, 1, queue, "queued transactions mismatched")
-	assert.Equal(t, 0, pool.statsOverflowPool(), "OverflowPool size unexpected")
-
-	tx3 := dynamicFeeTx(0, 100000, big.NewInt(3), big.NewInt(2), keys[2])
-	pool.addToOverflowPool([]*types.Transaction{tx3}, true)
-	pending, queue = pool.Stats()
-
-	assert.Equal(t, 1, pending, "pending transactions mismatched")
-	assert.Equal(t, 0, queue, "queued transactions mismatched")
-	assert.Equal(t, 1, pool.statsOverflowPool(), "OverflowPool size unexpected")
-}
-
 // Tests that the pool rejects replacement dynamic fee transactions that don't
 // meet the minimum price bump required.
 func TestReplacementDynamicFee(t *testing.T) {

core/txpool/legacypool/tx_overflowpool.go

@@ -1,171 +0,0 @@
-package legacypool
-
-import (
-	"container/heap"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-)
-
-// txHeapItem implements the Interface interface (https://pkg.go.dev/container/heap#Interface) of heap so that it can be heapified
-type txHeapItem struct {
-	tx        *types.Transaction
-	timestamp int64 // Unix timestamp (nanoseconds) of when the transaction was added
-	index     int
-}
-
-type txHeap []*txHeapItem
-
-func (h txHeap) Len() int { return len(h) }
-func (h txHeap) Less(i, j int) bool {
-	return h[i].timestamp < h[j].timestamp
-}
-func (h txHeap) Swap(i, j int) {
-	if i < 0 || j < 0 || i >= len(h) || j >= len(h) {
-		return // Silently fail if indices are out of bounds
-	}
-	h[i], h[j] = h[j], h[i]
-	if h[i] != nil {
-		h[i].index = i
-	}
-	if h[j] != nil {
-		h[j].index = j
-	}
-}
-
-func (h *txHeap) Push(x interface{}) {
-	item, ok := x.(*txHeapItem)
-	if !ok {
-		return
-	}
-	n := len(*h)
-	item.index = n
-	*h = append(*h, item)
-}
-
-func (h *txHeap) Pop() interface{} {
-	old := *h
-	n := len(old)
-	if n == 0 {
-		return nil // Return nil if the heap is empty
-	}
-	item := old[n-1]
-	old[n-1] = nil // avoid memory leak
-	*h = old[0 : n-1]
-	if item != nil {
-		item.index = -1 // for safety
-	}
-	return item
-}
-
-type TxOverflowPool struct {
-	txHeap    txHeap
-	index     map[common.Hash]*txHeapItem
-	mu        sync.RWMutex
-	maxSize   uint64
-	totalSize int
-}
-
-func NewTxOverflowPoolHeap(estimatedMaxSize uint64) *TxOverflowPool {
-	return &TxOverflowPool{
-		txHeap:  make(txHeap, 0, estimatedMaxSize),
-		index:   make(map[common.Hash]*txHeapItem, estimatedMaxSize),
-		maxSize: estimatedMaxSize,
-	}
-}
-
-func (tp *TxOverflowPool) Add(tx *types.Transaction) {
-	tp.mu.Lock()
-	defer tp.mu.Unlock()
-
-	if _, exists := tp.index[tx.Hash()]; exists {
-		// Transaction already in pool, ignore
-		return
-	}
-
-	if uint64(len(tp.txHeap)) >= tp.maxSize {
-		// Remove the oldest transaction to make space
-		oldestItem, ok := heap.Pop(&tp.txHeap).(*txHeapItem)
-		if !ok || oldestItem == nil {
-			return
-		}
-		delete(tp.index, oldestItem.tx.Hash())
-		tp.totalSize -= numSlots(oldestItem.tx)
-		OverflowPoolGauge.Dec(1)
-	}
-
-	item := &txHeapItem{
-		tx:        tx,
-		timestamp: time.Now().UnixNano(),
-	}
-	heap.Push(&tp.txHeap, item)
-	tp.index[tx.Hash()] = item
-	tp.totalSize += numSlots(tx)
-	OverflowPoolGauge.Inc(1)
-}
-
-func (tp *TxOverflowPool) Get(hash common.Hash) (*types.Transaction, bool) {
-	tp.mu.RLock()
-	defer tp.mu.RUnlock()
-	if item, ok := tp.index[hash]; ok {
-		return item.tx, true
-	}
-	return nil, false
-}
-
-func (tp *TxOverflowPool) Remove(hash common.Hash) {
-	tp.mu.Lock()
-	defer tp.mu.Unlock()
-	if item, ok := tp.index[hash]; ok {
-		heap.Remove(&tp.txHeap, item.index)
-		delete(tp.index, hash)
-		tp.totalSize -= numSlots(item.tx)
-		OverflowPoolGauge.Dec(1)
-	}
-}
-
-func (tp *TxOverflowPool) Flush(n int) []*types.Transaction {
-	tp.mu.Lock()
-	defer tp.mu.Unlock()
-	if n > tp.txHeap.Len() {
-		n = tp.txHeap.Len()
-	}
-	txs := make([]*types.Transaction, n)
-	for i := 0; i < n; i++ {
-		item, ok := heap.Pop(&tp.txHeap).(*txHeapItem)
-		if !ok || item == nil {
-			continue
-		}
-		txs[i] = item.tx
-		delete(tp.index, item.tx.Hash())
-		tp.totalSize -= numSlots(item.tx)
-	}
-
-	OverflowPoolGauge.Dec(int64(n))
-	return txs
-}
-
-func (tp *TxOverflowPool) Len() int {
-	tp.mu.RLock()
-	defer tp.mu.RUnlock()
-	return tp.txHeap.Len()
-}
-
-func (tp *TxOverflowPool) Size() int {
-	tp.mu.RLock()
-	defer tp.mu.RUnlock()
-	return tp.totalSize
-}
-
-func (tp *TxOverflowPool) PrintTxStats() {
-	tp.mu.RLock()
-	defer tp.mu.RUnlock()
-	for _, item := range tp.txHeap {
-		tx := item.tx
-		fmt.Printf("Hash: %s, Timestamp: %d, GasFeeCap: %s, GasTipCap: %s\n",
-			tx.Hash().String(), item.timestamp, tx.GasFeeCap().String(), tx.GasTipCap().String())
-	}
-}

core/txpool/legacypool/tx_overflowpool_test.go

@@ -1,266 +0,0 @@
-package legacypool
-
-import (
-	"math/big"
-	rand2 "math/rand"
-	"testing"
-	"time"
-
-	"github.com/cometbft/cometbft/libs/rand"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-)
-
-// Helper function to create a test transaction
-func createTestTx(nonce uint64, gasPrice *big.Int) *types.Transaction {
-	to := common.HexToAddress("0x1234567890123456789012345678901234567890")
-	return types.NewTransaction(nonce, to, big.NewInt(1000), 21000, gasPrice, nil)
-}
-
-func TestNewTxOverflowPoolHeap(t *testing.T) {
-	pool := NewTxOverflowPoolHeap(0)
-	if pool == nil {
-		t.Fatal("NewTxOverflowPoolHeap returned nil")
-	}
-	if pool.Len() != 0 {
-		t.Errorf("New pool should be empty, got length %d", pool.Len())
-	}
-}
-
-func TestTxOverflowPoolHeapAdd(t *testing.T) {
-	pool := NewTxOverflowPoolHeap(1)
-	tx := createTestTx(1, big.NewInt(1000))
-
-	pool.Add(tx)
-	if pool.Len() != 1 {
-		t.Errorf("Pool should have 1 transaction, got %d", pool.Len())
-	}
-
-	// Add the same transaction again
-	pool.Add(tx)
-	if pool.Len() != 1 {
-		t.Errorf("Pool should still have 1 transaction after adding duplicate, got %d", pool.Len())
-	}
-}
-
-func TestTxOverflowPoolHeapGet(t *testing.T) {
-	pool := NewTxOverflowPoolHeap(1)
-	tx := createTestTx(1, big.NewInt(1000))
-	pool.Add(tx)
-
-	gotTx, exists := pool.Get(tx.Hash())
-	if !exists {
-		t.Fatal("Get returned false for existing transaction")
-	}
-	if gotTx.Hash() != tx.Hash() {
-		t.Errorf("Get returned wrong transaction. Want %v, got %v", tx.Hash(), gotTx.Hash())
-	}
-
-	_, exists = pool.Get(common.Hash{})
-	if exists {
-		t.Error("Get returned true for non-existent transaction")
-	}
-}
-
-func TestTxOverflowPoolHeapRemove(t *testing.T) {
-	pool := NewTxOverflowPoolHeap(1)
-	tx := createTestTx(1, big.NewInt(1000))
-	pool.Add(tx)
-
-	pool.Remove(tx.Hash())
-	if pool.Len() != 0 {
-		t.Errorf("Pool should be empty after removing the only transaction, got length %d", pool.Len())
-	}
-
-	// Try to remove non-existent transaction
-	pool.Remove(common.Hash{})
-	if pool.Len() != 0 {
-		t.Error("Removing non-existent transaction should not affect pool size")
-	}
-}
-
-func TestTxOverflowPoolHeapPopN(t *testing.T) {
-	pool := NewTxOverflowPoolHeap(3)
-	tx1 := createTestTx(1, big.NewInt(1000))
-	tx2 := createTestTx(2, big.NewInt(2000))
-	tx3 := createTestTx(3, big.NewInt(3000))
-
-	pool.Add(tx1)
-	time.Sleep(time.Millisecond) // Ensure different timestamps
-	pool.Add(tx2)
-	time.Sleep(time.Millisecond)
-	pool.Add(tx3)
-
-	popped := pool.Flush(2)
-	if len(popped) != 2 {
-		t.Fatalf("PopN(2) should return 2 transactions, got %d", len(popped))
-	}
-	if popped[0].Hash() != tx1.Hash() || popped[1].Hash() != tx2.Hash() {
-		t.Error("PopN returned transactions in wrong order")
-	}
-	if pool.Len() != 1 {
-		t.Errorf("Pool should have 1 transaction left, got %d", pool.Len())
-	}
-
-	// Pop more than available
-	popped = pool.Flush(2)
-	if len(popped) != 1 {
-		t.Fatalf("PopN(2) should return 1 transaction when only 1 is left, got %d", len(popped))
-	}
-	if popped[0].Hash() != tx3.Hash() {
-		t.Error("PopN returned wrong transaction")
-	}
-	if pool.Len() != 0 {
-		t.Errorf("Pool should be empty, got length %d", pool.Len())
-	}
-}
-
-func TestTxOverflowPoolHeapOrdering(t *testing.T) {
-	pool := NewTxOverflowPoolHeap(3)
-	tx1 := createTestTx(1, big.NewInt(1000))
-	tx2 := createTestTx(2, big.NewInt(2000))
-	tx3 := createTestTx(3, big.NewInt(3000))
-
-	pool.Add(tx2)
-	time.Sleep(time.Millisecond) // Ensure different timestamps
-	pool.Add(tx1)
-	pool.Add(tx3) // Added immediately after tx1, should have same timestamp but higher sequence
-
-	popped := pool.Flush(3)
-	if len(popped) != 3 {
-		t.Fatalf("PopN(3) should return 3 transactions, got %d", len(popped))
-	}
-	if popped[0].Hash() != tx2.Hash() || popped[1].Hash() != tx1.Hash() || popped[2].Hash() != tx3.Hash() {
-		t.Error("Transactions not popped in correct order (earliest timestamp first, then by sequence)")
-	}
-}
-
-func TestTxOverflowPoolHeapLen(t *testing.T) {
-	pool := NewTxOverflowPoolHeap(2)
-	if pool.Len() != 0 {
-		t.Errorf("New pool should have length 0, got %d", pool.Len())
-	}
-
-	pool.Add(createTestTx(1, big.NewInt(1000)))
-	if pool.Len() != 1 {
-		t.Errorf("Pool should have length 1 after adding a transaction, got %d", pool.Len())
-	}
-
-	pool.Add(createTestTx(2, big.NewInt(2000)))
-	if pool.Len() != 2 {
-		t.Errorf("Pool should have length 2 after adding another transaction, got %d", pool.Len())
-	}
-
-	pool.Flush(1)
-	if pool.Len() != 1 {
-		t.Errorf("Pool should have length 1 after popping a transaction, got %d", pool.Len())
-	}
-}
-
-// Helper function to create a random test transaction
-func createRandomTestTx() *types.Transaction {
-	nonce := uint64(rand.Intn(1000000))
-	to := common.BytesToAddress(rand.Bytes(20))
-	amount := new(big.Int).Rand(rand2.New(rand2.NewSource(rand.Int63())), big.NewInt(1e18))
-	gasLimit := uint64(21000)
-	gasPrice := new(big.Int).Rand(rand2.New(rand2.NewSource(rand.Int63())), big.NewInt(1e9))
-	data := rand.Bytes(100)
-	return types.NewTransaction(nonce, to, amount, gasLimit, gasPrice, data)
-}
-
-func createRandomTestTxs(n int) []*types.Transaction {
-	txs := make([]*types.Transaction, n)
-	for i := 0; i < n; i++ {
-		txs[i] = createRandomTestTx()
-	}
-	return txs
-}
-
-// goos: darwin
-// goarch: arm64
-// pkg: github.com/ethereum/go-ethereum/core/txpool/legacypool
-// BenchmarkTxOverflowPoolHeapAdd-8              	  813326	      2858 ns/op
-func BenchmarkTxOverflowPoolHeapAdd(b *testing.B) {
-	pool := NewTxOverflowPoolHeap(uint64(b.N))
-	txs := createRandomTestTxs(b.N)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		pool.Add(txs[i])
-	}
-}
-
-// BenchmarkTxOverflowPoolHeapGet-8              	32613938	        35.63 ns/op
-func BenchmarkTxOverflowPoolHeapGet(b *testing.B) {
-	pool := NewTxOverflowPoolHeap(1000)
-	txs := createRandomTestTxs(1000)
-	for _, tx := range txs {
-		pool.Add(tx)
-	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		pool.Get(txs[i%1000].Hash())
-	}
-}
-
-// BenchmarkTxOverflowPoolHeapRemove-8           	 3020841	       417.8 ns/op
-func BenchmarkTxOverflowPoolHeapRemove(b *testing.B) {
-	pool := NewTxOverflowPoolHeap(uint64(b.N))
-	txs := createRandomTestTxs(b.N)
-	for _, tx := range txs {
-		pool.Add(tx)
-	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		pool.Remove(txs[i].Hash())
-	}
-}
-
-// BenchmarkTxOverflowPoolHeapFlush-8            	42963656	        29.90 ns/op
-func BenchmarkTxOverflowPoolHeapFlush(b *testing.B) {
-	pool := NewTxOverflowPoolHeap(1000)
-	txs := createRandomTestTxs(1000)
-	for _, tx := range txs {
-		pool.Add(tx)
-	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		pool.Flush(10)
-	}
-}
-
-// BenchmarkTxOverflowPoolHeapLen-8              	79147188	        20.07 ns/op
-func BenchmarkTxOverflowPoolHeapLen(b *testing.B) {
-	pool := NewTxOverflowPoolHeap(1000)
-	txs := createRandomTestTxs(1000)
-	for _, tx := range txs {
-		pool.Add(tx)
-	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		pool.Len()
-	}
-}
-
-// BenchmarkTxOverflowPoolHeapAddRemove-8        	  902896	      1546 ns/op
-func BenchmarkTxOverflowPoolHeapAddRemove(b *testing.B) {
-	pool := NewTxOverflowPoolHeap(uint64(b.N))
-	txs := createRandomTestTxs(b.N)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		pool.Add(txs[i])
-		pool.Remove(txs[i].Hash())
-	}
-}
-
-// BenchmarkTxOverflowPoolHeapAddFlush-8         	   84417	     14899 ns/op
-func BenchmarkTxOverflowPoolHeapAddFlush(b *testing.B) {
-	pool := NewTxOverflowPoolHeap(uint64(b.N * 10))
-	txs := createRandomTestTxs(b.N * 10)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		for j := 0; j < 10; j++ {
-			pool.Add(txs[i*10+j])
-		}
-		pool.Flush(10)
-	}
-}

core/types/transaction_options.go

@@ -1,43 +0,0 @@
-package types
-
-import (
-	"encoding/json"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-)
-
-type AccountStorage struct {
-	StorageRoot  *common.Hash
-	StorageSlots map[common.Hash]common.Hash
-}
-
-func (a *AccountStorage) UnmarshalJSON(data []byte) error {
-	var hash common.Hash
-	if err := json.Unmarshal(data, &hash); err == nil {
-		a.StorageRoot = &hash
-		return nil
-	}
-	return json.Unmarshal(data, &a.StorageSlots)
-}
-
-func (a AccountStorage) MarshalJSON() ([]byte, error) {
-	if a.StorageRoot != nil {
-		return json.Marshal(*a.StorageRoot)
-	}
-	return json.Marshal(a.StorageSlots)
-}
-
-type KnownAccounts map[common.Address]AccountStorage
-
-// It is known that marshaling is broken
-// https://github.com/golang/go/issues/55890
-
-//go:generate go run github.com/fjl/gencodec -type TransactionOpts -out gen_tx_opts_json.go
-type TransactionOpts struct {
-	KnownAccounts  KnownAccounts   `json:"knownAccounts"`
-	BlockNumberMin *hexutil.Uint64 `json:"blockNumberMin,omitempty"`
-	BlockNumberMax *hexutil.Uint64 `json:"blockNumberMax,omitempty"`
-	TimestampMin   *hexutil.Uint64 `json:"timestampMin,omitempty"`
-	TimestampMax   *hexutil.Uint64 `json:"timestampMax,omitempty"`
-}

crypto/secp256k1/libsecp256k1/sage/group_prover.sage

@@ -17,7 +17,7 @@
 #   - A constraint describing the requirements of the law, called "require"
 # * Implementations are transliterated into functions that operate as well on
 #   algebraic input points, and are called once per combination of branches
-#   executed. Each execution returns:
+#   exectured. Each execution returns:
 #   - A constraint describing the assumptions this implementation requires
 #     (such as Z1=1), called "assumeFormula"
 #   - A constraint describing the assumptions this specific branch requires,

eth/backend.go

@@ -193,16 +193,11 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 		chainConfig.CancunTime = config.OverridePassedForkTime
 		chainConfig.HaberTime = config.OverridePassedForkTime
 		chainConfig.HaberFixTime = config.OverridePassedForkTime
-		chainConfig.BohrTime = config.OverridePassedForkTime
 		overrides.OverridePassedForkTime = config.OverridePassedForkTime
 	}
-	if config.OverridePascal != nil {
-		chainConfig.PascalTime = config.OverridePascal
-		overrides.OverridePascal = config.OverridePascal
-	}
-	if config.OverridePrague != nil {
-		chainConfig.PragueTime = config.OverridePrague
-		overrides.OverridePrague = config.OverridePrague
+	if config.OverrideBohr != nil {
+		chainConfig.BohrTime = config.OverrideBohr
+		overrides.OverrideBohr = config.OverrideBohr
 	}
 	if config.OverrideVerkle != nil {
 		chainConfig.VerkleTime = config.OverrideVerkle

eth/ethconfig/config.go

@@ -191,11 +191,8 @@ type Config struct {
 	// OverridePassedForkTime
 	OverridePassedForkTime *uint64 `toml:",omitempty"`
 
-	// OverridePascal (TODO: remove after the fork)
-	OverridePascal *uint64 `toml:",omitempty"`
-
-	// OverridePrague (TODO: remove after the fork)
-	OverridePrague *uint64 `toml:",omitempty"`
+	// OverrideBohr (TODO: remove after the fork)
+	OverrideBohr *uint64 `toml:",omitempty"`
 
 	// OverrideVerkle (TODO: remove after the fork)
 	OverrideVerkle *uint64 `toml:",omitempty"`

eth/ethconfig/gen_config.go

@@ -70,9 +70,8 @@ func (c Config) MarshalTOML() (interface{}, error) {
 		RPCGasCap               uint64
 		RPCEVMTimeout           time.Duration
 		RPCTxFeeCap             float64
-		OverridePassedForkTime  *uint64 `toml:",omitempty"`
-		OverridePascal          *uint64 `toml:",omitempty"`
-		OverridePrague          *uint64 `toml:",omitempty"`
+		OverridePassedForkTime      *uint64 `toml:",omitempty"`
+		OverrideBohr            *uint64 `toml:",omitempty"`
 		OverrideVerkle          *uint64 `toml:",omitempty"`
 		BlobExtraReserve        uint64
 	}
@@ -131,8 +130,7 @@ func (c Config) MarshalTOML() (interface{}, error) {
 	enc.RPCEVMTimeout = c.RPCEVMTimeout
 	enc.RPCTxFeeCap = c.RPCTxFeeCap
 	enc.OverridePassedForkTime = c.OverridePassedForkTime
-	enc.OverridePascal = c.OverridePascal
-	enc.OverridePrague = c.OverridePrague
+	enc.OverrideBohr = c.OverrideBohr
 	enc.OverrideVerkle = c.OverrideVerkle
 	enc.BlobExtraReserve = c.BlobExtraReserve
 	return &enc, nil
@@ -194,9 +192,8 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 		RPCGasCap               *uint64
 		RPCEVMTimeout           *time.Duration
 		RPCTxFeeCap             *float64
-		OverridePassedForkTime  *uint64 `toml:",omitempty"`
-		OverridePascal          *uint64 `toml:",omitempty"`
-		OverridePrague          *uint64 `toml:",omitempty"`
+		OverridePassedForkTime      *uint64 `toml:",omitempty"`
+		OverrideBohr            *uint64 `toml:",omitempty"`
 		OverrideVerkle          *uint64 `toml:",omitempty"`
 		BlobExtraReserve        *uint64
 	}
@@ -366,11 +363,8 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 	if dec.OverridePassedForkTime != nil {
 		c.OverridePassedForkTime = dec.OverridePassedForkTime
 	}
-	if dec.OverridePascal != nil {
-		c.OverridePascal = dec.OverridePascal
-	}
-	if dec.OverridePrague != nil {
-		c.OverridePrague = dec.OverridePrague
+	if dec.OverrideBohr != nil {
+		c.OverrideBohr = dec.OverrideBohr
 	}
 	if dec.OverrideVerkle != nil {
 		c.OverrideVerkle = dec.OverrideVerkle

eth/handler.go

@@ -321,14 +321,21 @@ func newHandler(config *handlerConfig) (*handler, error) {
 
 	broadcastBlockWithCheck := func(block *types.Block, propagate bool) {
 		if propagate {
-			if !(block.Header().WithdrawalsHash == nil && block.Withdrawals() == nil) &&
-				!(block.Header().EmptyWithdrawalsHash() && block.Withdrawals() != nil && len(block.Withdrawals()) == 0) {
-				log.Error("Propagated block has invalid withdrawals")
-				return
-			}
-			if err := core.IsDataAvailable(h.chain, block); err != nil {
-				log.Error("Propagating block with invalid sidecars", "number", block.Number(), "hash", block.Hash(), "err", err)
-				return
+			checkErrs := make(chan error, 2)
+
+			go func() {
+				checkErrs <- core.ValidateListsInBody(block)
+			}()
+			go func() {
+				checkErrs <- core.IsDataAvailable(h.chain, block)
+			}()
+
+			for i := 0; i < cap(checkErrs); i++ {
+				err := <-checkErrs
+				if err != nil {
+					log.Error("Propagating invalid block", "number", block.Number(), "hash", block.Hash(), "err", err)
+					return
+				}
 			}
 		}
 		h.BroadcastBlock(block, propagate)

ethclient/ethclient.go

@@ -29,6 +29,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/internal/ethapi"
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
@@ -736,7 +737,7 @@ func (ec *Client) SendTransaction(ctx context.Context, tx *types.Transaction) er
 //
 // If the transaction was a contract creation use the TransactionReceipt method to get the
 // contract address after the transaction has been mined.
-func (ec *Client) SendTransactionConditional(ctx context.Context, tx *types.Transaction, opts types.TransactionOpts) error {
+func (ec *Client) SendTransactionConditional(ctx context.Context, tx *types.Transaction, opts ethapi.TransactionOpts) error {
 	data, err := tx.MarshalBinary()
 	if err != nil {
 		return err

ethclient/ethclient_test.go

@@ -34,6 +34,7 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/eth"
 	"github.com/ethereum/go-ethereum/eth/ethconfig"
+	"github.com/ethereum/go-ethereum/internal/ethapi"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
@@ -769,9 +770,9 @@ func sendTransactionConditional(ec *Client) error {
 	}
 
 	root := common.HexToHash("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
-	return ec.SendTransactionConditional(context.Background(), tx, types.TransactionOpts{
-		KnownAccounts: map[common.Address]types.AccountStorage{
-			testAddr: types.AccountStorage{
+	return ec.SendTransactionConditional(context.Background(), tx, ethapi.TransactionOpts{
+		KnownAccounts: map[common.Address]ethapi.AccountStorage{
+			testAddr: ethapi.AccountStorage{
 				StorageRoot: &root,
 			},
 		},

ethclient/simulated/backend.go

@@ -30,6 +30,7 @@ import (
 	"github.com/ethereum/go-ethereum/eth/ethconfig"
 	"github.com/ethereum/go-ethereum/eth/filters"
 	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/internal/ethapi"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/params"
@@ -38,7 +39,7 @@ import (
 
 // TransactionConditionalSender injects the conditional transaction into the pending pool for execution after verification.
 type TransactionConditionalSender interface {
-	SendTransactionConditional(ctx context.Context, tx *types.Transaction, opts types.TransactionOpts) error
+	SendTransactionConditional(ctx context.Context, tx *types.Transaction, opts ethapi.TransactionOpts) error
 }
 
 // Client exposes the methods provided by the Ethereum RPC client.

internal/ethapi/api.go

@@ -2314,7 +2314,7 @@ func (s *TransactionAPI) SendRawTransaction(ctx context.Context, input hexutil.B
 
 // SendRawTransactionConditional will add the signed transaction to the transaction pool.
 // The sender/bundler is responsible for signing the transaction
-func (s *TransactionAPI) SendRawTransactionConditional(ctx context.Context, input hexutil.Bytes, opts types.TransactionOpts) (common.Hash, error) {
+func (s *TransactionAPI) SendRawTransactionConditional(ctx context.Context, input hexutil.Bytes, opts TransactionOpts) (common.Hash, error) {
 	tx := new(types.Transaction)
 	if err := tx.UnmarshalBinary(input); err != nil {
 		return common.Hash{}, err
@@ -2324,7 +2324,7 @@ func (s *TransactionAPI) SendRawTransactionConditional(ctx context.Context, inpu
 	if state == nil || err != nil {
 		return common.Hash{}, err
 	}
-	if err := TxOptsCheck(opts, header.Number.Uint64(), header.Time, state); err != nil {
+	if err := opts.Check(header.Number.Uint64(), header.Time, state); err != nil {
 		return common.Hash{}, err
 	}
 	return SubmitTransaction(ctx, s.b, tx)

internal/ethapi/gen_tx_opts_json.go

@@ -1,9 +1,10 @@
 // Code generated by github.com/fjl/gencodec. DO NOT EDIT.
 
-package types
+package ethapi
 
 import (
 	"encoding/json"
+
 	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 

internal/ethapi/transaction_options.go

@@ -2,15 +2,52 @@ package ethapi
 
 import (
 	"bytes"
+	"encoding/json"
 	"errors"
 
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/state"
-	"github.com/ethereum/go-ethereum/core/types"
 )
 
+type AccountStorage struct {
+	StorageRoot  *common.Hash
+	StorageSlots map[common.Hash]common.Hash
+}
+
+func (a *AccountStorage) UnmarshalJSON(data []byte) error {
+	var hash common.Hash
+	if err := json.Unmarshal(data, &hash); err == nil {
+		a.StorageRoot = &hash
+		return nil
+	}
+	return json.Unmarshal(data, &a.StorageSlots)
+}
+
+func (a AccountStorage) MarshalJSON() ([]byte, error) {
+	if a.StorageRoot != nil {
+		return json.Marshal(*a.StorageRoot)
+	}
+	return json.Marshal(a.StorageSlots)
+}
+
+type KnownAccounts map[common.Address]AccountStorage
+
+// It is known that marshaling is broken
+// https://github.com/golang/go/issues/55890
+
+//go:generate go run github.com/fjl/gencodec -type TransactionOpts -out gen_tx_opts_json.go
+type TransactionOpts struct {
+	KnownAccounts  KnownAccounts   `json:"knownAccounts"`
+	BlockNumberMin *hexutil.Uint64 `json:"blockNumberMin,omitempty"`
+	BlockNumberMax *hexutil.Uint64 `json:"blockNumberMax,omitempty"`
+	TimestampMin   *hexutil.Uint64 `json:"timestampMin,omitempty"`
+	TimestampMax   *hexutil.Uint64 `json:"timestampMax,omitempty"`
+}
+
 const MaxNumberOfEntries = 1000
 
-func TxOptsCheck(o types.TransactionOpts, blockNumber uint64, timeStamp uint64, statedb *state.StateDB) error {
+func (o *TransactionOpts) Check(blockNumber uint64, timeStamp uint64, statedb *state.StateDB) error {
 	if o.BlockNumberMin != nil && blockNumber < uint64(*o.BlockNumberMin) {
 		return errors.New("BlockNumberMin condition not met")
 	}
@@ -34,10 +71,10 @@ func TxOptsCheck(o types.TransactionOpts, blockNumber uint64, timeStamp uint64,
 	if counter > MaxNumberOfEntries {
 		return errors.New("knownAccounts too large")
 	}
-	return TxOptsCheckStorage(o, statedb)
+	return o.CheckStorage(statedb)
 }
 
-func TxOptsCheckStorage(o types.TransactionOpts, statedb *state.StateDB) error {
+func (o *TransactionOpts) CheckStorage(statedb *state.StateDB) error {
 	for address, accountStorage := range o.KnownAccounts {
 		if accountStorage.StorageRoot != nil {
 			rootHash := statedb.GetRoot(address)

internal/ethapi/transaction_options_test.go

@@ -1,4 +1,4 @@
-package types
+package ethapi_test
 
 import (
 	"encoding/json"
@@ -7,6 +7,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/internal/ethapi"
 )
 
 func ptr(hash common.Hash) *common.Hash {
@@ -22,15 +23,15 @@ func TestTransactionOptsJSONUnMarshalTrip(t *testing.T) {
 		name     string
 		input    string
 		mustFail bool
-		expected TransactionOpts
+		expected ethapi.TransactionOpts
 	}{
 		{
 			"StateRoot",
 			`{"knownAccounts":{"0x6b3A8798E5Fb9fC5603F3aB5eA2e8136694e55d0":"0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563"}}`,
 			false,
-			TransactionOpts{
-				KnownAccounts: map[common.Address]AccountStorage{
-					common.HexToAddress("0x6b3A8798E5Fb9fC5603F3aB5eA2e8136694e55d0"): AccountStorage{
+			ethapi.TransactionOpts{
+				KnownAccounts: map[common.Address]ethapi.AccountStorage{
+					common.HexToAddress("0x6b3A8798E5Fb9fC5603F3aB5eA2e8136694e55d0"): ethapi.AccountStorage{
 						StorageRoot: ptr(common.HexToHash("0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563")),
 					},
 				},
@@ -40,9 +41,9 @@ func TestTransactionOptsJSONUnMarshalTrip(t *testing.T) {
 			"StorageSlots",
 			`{"knownAccounts":{"0x6b3A8798E5Fb9fC5603F3aB5eA2e8136694e55d0":{"0xc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a8":"0x0000000000000000000000000000000000000000000000000000000000000000"}}}`,
 			false,
-			TransactionOpts{
-				KnownAccounts: map[common.Address]AccountStorage{
-					common.HexToAddress("0x6b3A8798E5Fb9fC5603F3aB5eA2e8136694e55d0"): AccountStorage{
+			ethapi.TransactionOpts{
+				KnownAccounts: map[common.Address]ethapi.AccountStorage{
+					common.HexToAddress("0x6b3A8798E5Fb9fC5603F3aB5eA2e8136694e55d0"): ethapi.AccountStorage{
 						StorageRoot: nil,
 						StorageSlots: map[common.Hash]common.Hash{
 							common.HexToHash("0xc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a8"): common.HexToHash("0x"),
@@ -55,15 +56,15 @@ func TestTransactionOptsJSONUnMarshalTrip(t *testing.T) {
 			"EmptyObject",
 			`{"knownAccounts":{}}`,
 			false,
-			TransactionOpts{
-				KnownAccounts: make(map[common.Address]AccountStorage),
+			ethapi.TransactionOpts{
+				KnownAccounts: make(map[common.Address]ethapi.AccountStorage),
 			},
 		},
 		{
 			"EmptyStrings",
 			`{"knownAccounts":{"":""}}`,
 			true,
-			TransactionOpts{
+			ethapi.TransactionOpts{
 				KnownAccounts: nil,
 			},
 		},
@@ -71,7 +72,7 @@ func TestTransactionOptsJSONUnMarshalTrip(t *testing.T) {
 			"BlockNumberMin",
 			`{"blockNumberMin":"0x1"}`,
 			false,
-			TransactionOpts{
+			ethapi.TransactionOpts{
 				BlockNumberMin: u64Ptr(1),
 			},
 		},
@@ -79,7 +80,7 @@ func TestTransactionOptsJSONUnMarshalTrip(t *testing.T) {
 			"BlockNumberMax",
 			`{"blockNumberMin":"0x1", "blockNumberMax":"0x2"}`,
 			false,
-			TransactionOpts{
+			ethapi.TransactionOpts{
 				BlockNumberMin: u64Ptr(1),
 				BlockNumberMax: u64Ptr(2),
 			},
@@ -88,7 +89,7 @@ func TestTransactionOptsJSONUnMarshalTrip(t *testing.T) {
 			"TimestampMin",
 			`{"timestampMin":"0xffff"}`,
 			false,
-			TransactionOpts{
+			ethapi.TransactionOpts{
 				TimestampMin: u64Ptr(0xffff),
 			},
 		},
@@ -96,7 +97,7 @@ func TestTransactionOptsJSONUnMarshalTrip(t *testing.T) {
 			"TimestampMax",
 			`{"timestampMax":"0xffffff"}`,
 			false,
-			TransactionOpts{
+			ethapi.TransactionOpts{
 				TimestampMax: u64Ptr(0xffffff),
 			},
 		},
@@ -104,7 +105,7 @@ func TestTransactionOptsJSONUnMarshalTrip(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			var opts TransactionOpts
+			var opts ethapi.TransactionOpts
 			err := json.Unmarshal([]byte(test.input), &opts)
 			if test.mustFail && err == nil {
 				t.Errorf("Test %s should fail", test.name)

params/config.go

@@ -155,9 +155,6 @@ var (
 		HaberTime:           newUint64(1718863500), // 2024-06-20 06:05:00 AM UTC
 		HaberFixTime:        newUint64(1727316120), // 2024-09-26 02:02:00 AM UTC
 		BohrTime:            newUint64(1727317200), // 2024-09-26 02:20:00 AM UTC
-		// TODO
-		PascalTime: nil,
-		PragueTime: nil,
 
 		Parlia: &ParliaConfig{
 			Period: 3,
@@ -199,9 +196,6 @@ var (
 		HaberTime:           newUint64(1716962820), // 2024-05-29 06:07:00 AM UTC
 		HaberFixTime:        newUint64(1719986788), // 2024-07-03 06:06:28 AM UTC
 		BohrTime:            newUint64(1724116996), // 2024-08-20 01:23:16 AM UTC
-		// TODO
-		PascalTime: nil,
-		PragueTime: nil,
 
 		Parlia: &ParliaConfig{
 			Period: 3,
@@ -244,9 +238,6 @@ var (
 		HaberTime:           newUint64(0),
 		HaberFixTime:        newUint64(0),
 		BohrTime:            newUint64(0),
-		// TODO: set them to `0` when passed on the mainnet
-		PascalTime: nil,
-		PragueTime: nil,
 
 		Parlia: &ParliaConfig{
 			Period: 3,
@@ -526,7 +517,6 @@ type ChainConfig struct {
 	HaberTime      *uint64 `json:"haberTime,omitempty"`      // Haber switch time (nil = no fork, 0 = already on haber)
 	HaberFixTime   *uint64 `json:"haberFixTime,omitempty"`   // HaberFix switch time (nil = no fork, 0 = already on haberFix)
 	BohrTime       *uint64 `json:"bohrTime,omitempty"`       // Bohr switch time (nil = no fork, 0 = already on bohr)
-	PascalTime     *uint64 `json:"pascalTime,omitempty"`     // Pascal switch time (nil = no fork, 0 = already on pascal)
 	PragueTime     *uint64 `json:"pragueTime,omitempty"`     // Prague switch time (nil = no fork, 0 = already on prague)
 	VerkleTime     *uint64 `json:"verkleTime,omitempty"`     // Verkle switch time (nil = no fork, 0 = already on verkle)
 
@@ -647,17 +637,7 @@ func (c *ChainConfig) String() string {
 		BohrTime = big.NewInt(0).SetUint64(*c.BohrTime)
 	}
 
-	var PascalTime *big.Int
-	if c.PascalTime != nil {
-		PascalTime = big.NewInt(0).SetUint64(*c.PascalTime)
-	}
-
-	var PragueTime *big.Int
-	if c.PragueTime != nil {
-		PragueTime = big.NewInt(0).SetUint64(*c.PragueTime)
-	}
-
-	return fmt.Sprintf("{ChainID: %v Homestead: %v DAO: %v DAOSupport: %v EIP150: %v EIP155: %v EIP158: %v Byzantium: %v Constantinople: %v Petersburg: %v Istanbul: %v, Muir Glacier: %v, Ramanujan: %v, Niels: %v, MirrorSync: %v, Bruno: %v, Berlin: %v, YOLO v3: %v, CatalystBlock: %v, London: %v, ArrowGlacier: %v, MergeFork:%v, Euler: %v, Gibbs: %v, Nano: %v, Moran: %v, Planck: %v,Luban: %v, Plato: %v, Hertz: %v, Hertzfix: %v, ShanghaiTime: %v, KeplerTime: %v, FeynmanTime: %v, FeynmanFixTime: %v, CancunTime: %v, HaberTime: %v, HaberFixTime: %v, BohrTime: %v, PascalTime: %v, PragueTime: %v, Engine: %v}",
+	return fmt.Sprintf("{ChainID: %v Homestead: %v DAO: %v DAOSupport: %v EIP150: %v EIP155: %v EIP158: %v Byzantium: %v Constantinople: %v Petersburg: %v Istanbul: %v, Muir Glacier: %v, Ramanujan: %v, Niels: %v, MirrorSync: %v, Bruno: %v, Berlin: %v, YOLO v3: %v, CatalystBlock: %v, London: %v, ArrowGlacier: %v, MergeFork:%v, Euler: %v, Gibbs: %v, Nano: %v, Moran: %v, Planck: %v,Luban: %v, Plato: %v, Hertz: %v, Hertzfix: %v, ShanghaiTime: %v, KeplerTime: %v, FeynmanTime: %v, FeynmanFixTime: %v, CancunTime: %v, HaberTime: %v, HaberFixTime: %v, BohrTime: %v, Engine: %v}",
 		c.ChainID,
 		c.HomesteadBlock,
 		c.DAOForkBlock,
@@ -697,8 +677,6 @@ func (c *ChainConfig) String() string {
 		HaberTime,
 		HaberFixTime,
 		BohrTime,
-		PascalTime,
-		PragueTime,
 		engine,
 	)
 }
@@ -999,20 +977,6 @@ func (c *ChainConfig) IsOnBohr(currentBlockNumber *big.Int, lastBlockTime uint64
 	return !c.IsBohr(lastBlockNumber, lastBlockTime) && c.IsBohr(currentBlockNumber, currentBlockTime)
 }
 
-// IsPascal returns whether time is either equal to the Pascal fork time or greater.
-func (c *ChainConfig) IsPascal(num *big.Int, time uint64) bool {
-	return c.IsLondon(num) && isTimestampForked(c.PascalTime, time)
-}
-
-// IsOnPascal returns whether currentBlockTime is either equal to the Pascal fork time or greater firstly.
-func (c *ChainConfig) IsOnPascal(currentBlockNumber *big.Int, lastBlockTime uint64, currentBlockTime uint64) bool {
-	lastBlockNumber := new(big.Int)
-	if currentBlockNumber.Cmp(big.NewInt(1)) >= 0 {
-		lastBlockNumber.Sub(currentBlockNumber, big.NewInt(1))
-	}
-	return !c.IsPascal(lastBlockNumber, lastBlockTime) && c.IsPascal(currentBlockNumber, currentBlockTime)
-}
-
 // IsPrague returns whether num is either equal to the Prague fork time or greater.
 func (c *ChainConfig) IsPrague(num *big.Int, time uint64) bool {
 	return c.IsLondon(num) && isTimestampForked(c.PragueTime, time)
@@ -1079,8 +1043,7 @@ func (c *ChainConfig) CheckConfigForkOrder() error {
 		{name: "haberTime", timestamp: c.HaberTime},
 		{name: "haberFixTime", timestamp: c.HaberFixTime},
 		{name: "bohrTime", timestamp: c.BohrTime},
-		{name: "pascalTime", timestamp: c.PascalTime},
-		{name: "pragueTime", timestamp: c.PragueTime},
+		{name: "pragueTime", timestamp: c.PragueTime, optional: true},
 		{name: "verkleTime", timestamp: c.VerkleTime, optional: true},
 	} {
 		if lastFork.name != "" {
@@ -1236,9 +1199,6 @@ func (c *ChainConfig) checkCompatible(newcfg *ChainConfig, headNumber *big.Int,
 	if isForkTimestampIncompatible(c.BohrTime, newcfg.BohrTime, headTimestamp) {
 		return newTimestampCompatError("Bohr fork timestamp", c.BohrTime, newcfg.BohrTime)
 	}
-	if isForkTimestampIncompatible(c.PascalTime, newcfg.PascalTime, headTimestamp) {
-		return newTimestampCompatError("Pascal fork timestamp", c.PascalTime, newcfg.PascalTime)
-	}
 	if isForkTimestampIncompatible(c.PragueTime, newcfg.PragueTime, headTimestamp) {
 		return newTimestampCompatError("Prague fork timestamp", c.PragueTime, newcfg.PragueTime)
 	}
@@ -1422,7 +1382,7 @@ type Rules struct {
 	IsHertz                                                 bool
 	IsHertzfix                                              bool
 	IsShanghai, IsKepler, IsFeynman, IsCancun, IsHaber      bool
-	IsBohr, IsPascal, IsPrague, IsVerkle                    bool
+	IsBohr, IsPrague, IsVerkle                              bool
 }
 
 // Rules ensures c's ChainID is not nil.
@@ -1459,7 +1419,6 @@ func (c *ChainConfig) Rules(num *big.Int, isMerge bool, timestamp uint64) Rules
 		IsCancun:         c.IsCancun(num, timestamp),
 		IsHaber:          c.IsHaber(num, timestamp),
 		IsBohr:           c.IsBohr(num, timestamp),
-		IsPascal:         c.IsPascal(num, timestamp),
 		IsPrague:         c.IsPrague(num, timestamp),
 		IsVerkle:         c.IsVerkle(num, timestamp),
 	}

params/version.go

@@ -23,7 +23,7 @@ import (
 const (
 	VersionMajor = 1  // Major version component of the current release
 	VersionMinor = 4  // Minor version component of the current release
-	VersionPatch = 15 // Patch version component of the current release
+	VersionPatch = 14 // Patch version component of the current release
 	VersionMeta  = "" // Version metadata to append to the version string
 )