Add early validation of bundles

Author: LuisPH3

evmcore/tx_pool.go

@@ -106,6 +106,13 @@ var (
 	// ErrSponsoredTransactionsDisabled is returned when validating a sponsorship
 	// request if gas subsidies are disabled in the current network rules.
 	ErrSponsoredTransactionsDisabled = errors.New("sponsored transactions are disabled")
+
+	// ErrBundleTransactionsDisabled is returned when validating a transaction
+	// bundle if transaction bundles are disabled in the current network rules.
+	ErrBundleTransactionsDisabled = errors.New("bundled transactions are disabled")
+
+	// ErrBundleTransactionInvalid is returned when a bundle envelope is ill-formed
+	ErrBundleTransactionInvalid = errors.New("invalid bundle transaction")
 )
 
 var (
@@ -711,8 +718,9 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 		eip7623:  pool.eip7623,
 		eip7702:  pool.eip7702,
 
-		gasSubsidies: pool.chain.CurrentRules().Upgrades.GasSubsidies,
-		brio:         pool.chain.CurrentRules().Upgrades.Brio,
+		gasSubsidies:       pool.chain.CurrentRules().Upgrades.GasSubsidies,
+		brio:               pool.chain.CurrentRules().Upgrades.Brio,
+		transactionBundles: pool.chain.CurrentRules().Upgrades.TransactionBundles,
 	}
 
 	subsidiesChecker := pool.createSubsidiesChecker()

evmcore/tx_validation.go

@@ -17,10 +17,12 @@
 package evmcore
 
 import (
+	"errors"
 	"fmt"
 	"math"
 	"math/big"
 
+	"github.com/0xsoniclabs/sonic/gossip/blockproc/bundle"
 	"github.com/0xsoniclabs/sonic/gossip/blockproc/subsidies"
 	"github.com/0xsoniclabs/sonic/gossip/gasprice/gaspricelimits"
 	"github.com/0xsoniclabs/sonic/inter/state"
@@ -59,8 +61,9 @@ type NetworkRules struct {
 	eip7623 bool // Fork indicator whether we are using EIP-7623 floor gas validation.
 	eip7702 bool // Fork indicator whether we are using EIP-7702 set code transactions.
 
-	gasSubsidies bool // Indicator whether gas subsidies are active.
-	brio         bool // Indicator whether Brio revision is active
+	brio               bool // Indicator whether Brio revision is active
+	gasSubsidies       bool // Indicator whether gas subsidies are active.
+	transactionBundles bool // Indicator whether transaction bundles are active.
 }
 
 // Signer wraps types.Signer to allow mocking it in tests.
@@ -107,6 +110,10 @@ func validateTx(
 		return err
 	}
 
+	if err := validateBundleTransactions(tx, netRules, chain, state, signer); err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -251,7 +258,9 @@ func ValidateTxForBlock(tx *types.Transaction, netRules NetworkRules, chain Stat
 
 	// Ensure Sonic-specific hard bounds
 	isSponsorRequest := netRules.gasSubsidies && subsidies.IsSponsorshipRequest(tx)
-	if baseFee := chain.CurrentBaseFee(); !isSponsorRequest && baseFee != nil {
+	isBundle := netRules.transactionBundles && bundle.IsEnvelope(tx)
+	baseFee := chain.CurrentBaseFee()
+	if !isSponsorRequest && !isBundle {
 		limit := gaspricelimits.GetMinimumFeeCapForTransactionPool(baseFee)
 		if tx.GasFeeCapIntCmp(limit) < 0 {
 			log.Trace("Rejecting underpriced tx: minimumBaseFee", "minimumBaseFee", baseFee, "limit", limit, "tx.GasFeeCap", tx.GasFeeCap())
@@ -348,6 +357,11 @@ func validateSponsoredTransactions(
 	netRules NetworkRules,
 	SubsidiesChecker subsidiesChecker,
 ) error {
+	// Transaction Bundles are identified as sponsorship requests, but they are
+	// checked independently.
+	if bundle.IsEnvelope(tx) {
+		return nil
+	}
 
 	// No check is conducted if gas subsidies are not active.
 	if !netRules.gasSubsidies {
@@ -369,3 +383,59 @@ func validateSponsoredTransactions(
 
 	return nil
 }
+
+// validateBundleTransactions checks if a transaction is a bundle transaction and if so,
+// validates the bundle structure and the validity of each transaction in the bundle.
+// if the bundle is malformed or any bundle-only transactions is invalid,
+// it returns an error rejecting the transaction.
+func validateBundleTransactions(
+	tx *types.Transaction,
+	netRules NetworkRules,
+	chainState StateReader,
+	// Although state can be retrieved from chain, it is passed explicitly to avoid extra db-pool accesses
+	stateDb state.StateDB,
+	signer types.Signer,
+) error {
+	return validateBundleTransactionsInternal(
+		tx,
+		netRules,
+		chainState,
+		stateDb,
+		signer,
+	)
+}
+
+func validateBundleTransactionsInternal(
+	tx *types.Transaction,
+	netRules NetworkRules,
+	chainState StateReader,
+	// Although state can be retrieved from chain, it is passed explicitly to avoid extra db-pool accesses
+	stateDb state.StateDB,
+	signer types.Signer,
+) error {
+	// This check only covers bundle transactions, ignore the rest.
+	if !bundle.IsEnvelope(tx) {
+		return nil
+	}
+
+	// If transaction bundles are not active, reject the transaction.
+	if !netRules.brio {
+		return nil
+	}
+	if !netRules.transactionBundles {
+		return ErrBundleTransactionsDisabled
+	}
+
+	// If the transaction is a bundle, validate its structure and content.
+	_, _, err := bundle.ValidateEnvelope(signer, tx)
+	if err != nil {
+		return errors.Join(ErrBundleTransactionInvalid, err)
+	}
+
+	// Check that the bundle is runnable.
+	// TODO: this requires integration of `GetBundleState`
+	_ = stateDb
+	_ = chainState
+
+	return nil
+}

evmcore/tx_validation_test.go

@@ -22,6 +22,7 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/0xsoniclabs/sonic/gossip/blockproc/bundle"
 	"github.com/0xsoniclabs/sonic/inter/state"
 	"github.com/0xsoniclabs/sonic/opera"
 	"github.com/ethereum/go-ethereum/common"
@@ -1288,6 +1289,44 @@ func TestValidateTx_RejectsTx_WhenStateValidationFails(t *testing.T) {
 	}
 }
 
+func TestValidateTx_RejectsTx_WhenBundleTransactionValidationFails(t *testing.T) {
+	require := require.New(t)
+	ctrl := gomock.NewController(t)
+	signer := NewMockSigner(ctrl)
+	signer.EXPECT().Sender(gomock.Any()).AnyTimes()
+	signer.EXPECT().Equal(gomock.Any()).AnyTimes()
+
+	chain := NewMockStateReader(ctrl)
+	chain.EXPECT().CurrentBaseFee().Return(big.NewInt(5)).AnyTimes()
+	chain.EXPECT().CurrentMaxGasLimit().Return(uint64(100_000)).AnyTimes()
+
+	state := state.NewMockStateDB(ctrl)
+	state.EXPECT().GetNonce(gomock.Any()).Return(uint64(0)).AnyTimes()
+	state.EXPECT().GetBalance(gomock.Any()).Return(uint256.NewInt(0)).AnyTimes()
+	state.EXPECT().GetCode(gomock.Any()).Return(nil).AnyTimes()
+
+	invalidBundle := types.NewTx(&types.LegacyTx{
+		To:  &bundle.BundleProcessor,
+		Gas: 100_000,
+	})
+
+	require.True(bundle.IsEnvelope(invalidBundle))
+	require.ErrorIs(validateTx(
+		invalidBundle,
+		poolOptions{
+			isLocal: true,
+		},
+		NetworkRules{
+			brio:               true,
+			transactionBundles: true,
+		},
+		chain,
+		state,
+		nil,
+		signer,
+	), ErrBundleTransactionInvalid)
+}
+
 func TestValidateTx_AcceptsZeroGasPriceTransactions_WhenSubsidiesAreEnabled(t *testing.T) {
 	tests := []types.TxData{
 		&types.LegacyTx{
@@ -1440,6 +1479,80 @@ func Test_validateSponsoredTransactions_RejectsSponsoredTransactions(t *testing.
 	}
 }
 
+func Test_validateBundleTransactions_AcceptNonBundleTransactions(t *testing.T) {
+	tests := map[string]*types.Transaction{
+		"legacy tx":      types.NewTx(&types.LegacyTx{}),
+		"access list tx": types.NewTx(&types.AccessListTx{}),
+		"dynamic fee tx": types.NewTx(&types.DynamicFeeTx{}),
+		"blob tx":        types.NewTx(&types.BlobTx{}),
+	}
+
+	for name, tx := range tests {
+		t.Run(name, func(t *testing.T) {
+			require := require.New(t)
+			require.False(bundle.IsEnvelope(tx))
+			require.NoError(validateBundleTransactions(tx, NetworkRules{}, nil, nil, nil))
+		})
+	}
+}
+
+func Test_validateBundleTransactions_RespectNetworkRules(t *testing.T) {
+	signer := types.LatestSignerForChainID(big.NewInt(1))
+	bundle := bundle.NewBuilder(signer).Build()
+
+	tests := map[string]struct {
+		rules         NetworkRules
+		expectedError error
+	}{
+		"bundle transactions disabled pre brio": {
+			rules:         NetworkRules{},
+			expectedError: nil,
+		},
+		"bundle transactions enabled pre brio": {
+			rules:         NetworkRules{transactionBundles: true},
+			expectedError: nil,
+		},
+		"bundle transactions disabled post brio": {
+			rules:         NetworkRules{brio: true},
+			expectedError: ErrBundleTransactionsDisabled,
+		},
+		"bundle transactions enabled post brio": {
+			rules:         NetworkRules{brio: true, transactionBundles: true},
+			expectedError: nil,
+		},
+	}
+
+	for name, test := range tests {
+		t.Run(name, func(t *testing.T) {
+			require := require.New(t)
+			err := validateBundleTransactions(bundle, test.rules, nil, nil, nil)
+			if test.expectedError != nil {
+				require.ErrorIs(err, test.expectedError)
+			} else {
+				require.NoError(err)
+			}
+		})
+	}
+}
+
+func Test_validateBundleTransactions_ReturnsErrorWithMalformedEnvelope(t *testing.T) {
+	malformedBundle := types.NewTx(&types.LegacyTx{
+		To:  &bundle.BundleProcessor,
+		Gas: 100_000,
+	})
+
+	require := require.New(t)
+	require.True(bundle.IsEnvelope(malformedBundle))
+
+	bundlesEnabled := NetworkRules{
+		brio:               true,
+		transactionBundles: true,
+	}
+
+	err := validateBundleTransactions(malformedBundle, bundlesEnabled, nil, nil, nil)
+	require.ErrorIs(err, ErrBundleTransactionInvalid)
+}
+
 func TestValidateTx_AllowsSponsoredZeroGasPriceTransactions_WhenSubsidiesAreFunded(t *testing.T) {
 
 	tests := map[string]struct {