feat: add more tx list checks in ValidateExecutionPayload

Author: davidtaikocha

packages/taiko-client/driver/chain_syncer/chain_syncer.go

@@ -47,13 +47,7 @@ func New(
 	go tracker.Track(ctx)
 
 	beaconSyncer := beaconsync.NewSyncer(ctx, rpc, state, tracker)
-	blobSyncer, err := blob.NewSyncer(
-		ctx,
-		rpc,
-		state,
-		tracker,
-		blobServerEndpoint,
-	)
+	blobSyncer, err := blob.NewSyncer(ctx, rpc, state, tracker, blobServerEndpoint)
 	if err != nil {
 		return nil, err
 	}

packages/taiko-client/driver/driver.go

@@ -118,6 +118,7 @@ func (d *Driver) InitFromConfig(ctx context.Context, cfg *Config) (err error) {
 		if d.preconfBlockServer, err = preconfBlocks.New(
 			d.PreconfBlockServerCORSOrigins,
 			d.PreconfBlockServerJWTSecret,
+			d.TaikoL2Address,
 			d.l2ChainSyncer.BlobSyncer().BlocksInserterPacaya(),
 			d.rpc,
 		); err != nil {

packages/taiko-client/driver/driver_test.go

@@ -564,7 +564,6 @@ func (s *DriverTestSuite) TestOnUnsafeL2Payload() {
 	b, err := utils.EncodeAndCompressTxList(types.Transactions{anchorTx})
 	s.Nil(err)
 
-	// failed to decode txList: rlp: expected input list for types.Transactions
 	payload := &eth.ExecutionPayload{
 		ParentHash:    l2Head1.Hash(),
 		FeeRecipient:  s.TestAddr,
@@ -597,6 +596,45 @@ func (s *DriverTestSuite) TestOnUnsafeL2Payload() {
 	s.Equal(anchorTx.Hash(), l2Head2.Transactions()[0].Hash())
 }
 
+func (s *DriverTestSuite) TestOnUnsafeL2PayloadWithInvalidPayload() {
+	s.ForkIntoPacaya(s.p, s.d.ChainSyncer().BlobSyncer())
+	// Propose some valid L2 blocks
+	s.ProposeAndInsertEmptyBlocks(s.p, s.d.ChainSyncer().BlobSyncer())
+
+	l2Head1, err := s.d.rpc.L2.HeaderByNumber(context.Background(), nil)
+	s.Nil(err)
+
+	b, err := utils.Compress(testutils.RandomBytes(32))
+	s.Nil(err)
+
+	baseFee, overflow := uint256.FromBig(common.Big256)
+	s.False(overflow)
+
+	payload := &eth.ExecutionPayload{
+		ParentHash:    l2Head1.Hash(),
+		FeeRecipient:  s.TestAddr,
+		PrevRandao:    eth.Bytes32(testutils.RandomHash()),
+		BlockNumber:   eth.Uint64Quantity(l2Head1.Number.Uint64() + 1),
+		GasLimit:      eth.Uint64Quantity(l2Head1.GasLimit),
+		Timestamp:     eth.Uint64Quantity(time.Now().Unix()),
+		ExtraData:     l2Head1.Extra,
+		BaseFeePerGas: eth.Uint256Quantity(*baseFee),
+		Transactions:  []eth.Data{b},
+		Withdrawals:   &types.Withdrawals{},
+	}
+
+	s.Nil(s.d.preconfBlockServer.OnUnsafeL2Payload(
+		context.Background(),
+		peer.ID(testutils.RandomBytes(32)),
+		&eth.ExecutionPayloadEnvelope{ExecutionPayload: payload},
+	))
+
+	l2Head2, err := s.d.rpc.L2.BlockByNumber(context.Background(), nil)
+	s.Nil(err)
+	s.Equal(l2Head1.Number.Uint64(), l2Head2.Number().Uint64())
+	s.Equal(l2Head1.Hash(), l2Head2.Hash())
+}
+
 func (s *DriverTestSuite) TestOnUnsafeL2PayloadWithMissingAncients() {
 	s.ForkIntoPacaya(s.p, s.d.ChainSyncer().BlobSyncer())
 	// Propose some valid L2 blocks

packages/taiko-client/driver/preconf_blocks/server.go

@@ -15,15 +15,17 @@ import (
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/holiman/uint256"
 	echojwt "github.com/labstack/echo-jwt/v4"
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
 	"github.com/libp2p/go-libp2p/core/peer"
 
-	txListDecompressor "github.com/taikoxyz/taiko-mono/packages/taiko-client/driver/txlist_decompressor"
 	"github.com/taikoxyz/taiko-mono/packages/taiko-client/internal/metrics"
 	"github.com/taikoxyz/taiko-mono/packages/taiko-client/pkg/rpc"
+	"github.com/taikoxyz/taiko-mono/packages/taiko-client/pkg/utils"
+	validator "github.com/taikoxyz/taiko-mono/packages/taiko-client/prover/anchor_tx_validator"
 )
 
 // preconfBlockChainSyncer is an interface for preconf block chain syncer.
@@ -44,10 +46,10 @@ type preconfBlockChainSyncer interface {
 // @license.url https://github.com/taikoxyz/taiko-mono/blob/main/LICENSE.md
 // PreconfBlockAPIServer represents a preconfirmation block server instance.
 type PreconfBlockAPIServer struct {
-	echo               *echo.Echo
-	chainSyncer        preconfBlockChainSyncer
-	rpc                *rpc.Client
-	txListDecompressor *txListDecompressor.TxListDecompressor
+	echo            *echo.Echo
+	chainSyncer     preconfBlockChainSyncer
+	rpc             *rpc.Client
+	anchorValidator *validator.AnchorTxValidator
 	// P2P network for preconf block propagation
 	p2pNode        *p2p.NodeP2P
 	p2pSigner      p2p.Signer
@@ -60,25 +62,22 @@ type PreconfBlockAPIServer struct {
 func New(
 	cors string,
 	jwtSecret []byte,
+	taikoAnchorAddress common.Address,
 	chainSyncer preconfBlockChainSyncer,
 	cli *rpc.Client,
 ) (*PreconfBlockAPIServer, error) {
-	protocolConfigs, err := cli.GetProtocolConfigs(nil)
+	anchorValidator, err := validator.New(taikoAnchorAddress, cli.L2.ChainID, cli)
 	if err != nil {
-		return nil, fmt.Errorf("failed to fetch protocol configs: %w", err)
+		return nil, err
 	}
 
 	server := &PreconfBlockAPIServer{
-		echo:        echo.New(),
-		chainSyncer: chainSyncer,
-		txListDecompressor: txListDecompressor.NewTxListDecompressor(
-			uint64(protocolConfigs.BlockMaxGasLimit()),
-			uint64(rpc.BlobBytes),
-			cli.L2.ChainID,
-		),
-		rpc:           cli,
-		payloadsCache: newPayloadQueue(),
-		lookahead:     &Lookahead{},
+		echo:            echo.New(),
+		anchorValidator: anchorValidator,
+		chainSyncer:     chainSyncer,
+		rpc:             cli,
+		payloadsCache:   newPayloadQueue(),
+		lookahead:       &Lookahead{},
 	}
 
 	server.echo.HideBanner = true
@@ -375,6 +374,22 @@ func (s *PreconfBlockAPIServer) ValidateExecutionPayload(payload *eth.ExecutionP
 	if len(payload.Transactions[0]) > eth.MaxBlobDataSize {
 		return errors.New("compressed transactions size exceeds max blob data size")
 	}
+
+	var txs types.Transactions
+	b, err := utils.DecompressPacaya(payload.Transactions[0])
+	if err != nil {
+		return fmt.Errorf("invalid zlib bytes for transactions: %w", err)
+	}
+	if err := rlp.DecodeBytes(b, &txs); err != nil {
+		return fmt.Errorf("invalid RLP bytes for transactions: %w", err)
+	}
+	if len(txs) == 0 {
+		return errors.New("empty transactions list, missing anchor transaction")
+	}
+	if err := s.anchorValidator.ValidateAnchorTx(txs[0]); err != nil {
+		return fmt.Errorf("invalid anchor transaction: %w", err)
+	}
+
 	return nil
 }
 

packages/taiko-client/driver/preconf_blocks/server_test.go

@@ -2,8 +2,10 @@ package preconfblocks
 
 import (
 	"context"
+	"os"
 	"testing"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/stretchr/testify/suite"
 
@@ -17,7 +19,7 @@ type PreconfBlockAPIServerTestSuite struct {
 
 func (s *PreconfBlockAPIServerTestSuite) SetupTest() {
 	s.ClientTestSuite.SetupTest()
-	server, err := New("*", nil, nil, s.RPCClient)
+	server, err := New("*", nil, common.HexToAddress(os.Getenv("TAIKO_ANCHOR")), nil, s.RPCClient)
 	s.Nil(err)
 	s.s = server
 	go func() {