fix(taiko-client): fix an issue in missing ancients search (#19323)

Author: davidtaikocha

packages/taiko-client/driver/driver_test.go

@@ -875,17 +875,17 @@ func (s *DriverTestSuite) TestGossipMessagesRandomReorgs() {
 	s.Equal(l2Head1.Number.Uint64(), headL1Origin.BlockID.Uint64())
 }
 
-func (s *DriverTestSuite) TestOnUnsafeL2PayloadWithMissingAncients() {
+func (s *DriverTestSuite) TestOnUnsafeL2PayloadWithMissingChildren() {
 	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)
+	l2Head1, err := s.d.rpc.L2.BlockByNumber(context.Background(), nil)
 	s.Nil(err)
 
 	headL1Origin, err := s.RPCClient.L2.HeadL1Origin(context.Background())
 	s.Nil(err)
-	s.Equal(l2Head1.Number.Uint64(), headL1Origin.BlockID.Uint64())
+	s.Equal(l2Head1.Number().Uint64(), headL1Origin.BlockID.Uint64())
 
 	snapshotID := s.SetL1Snapshot()
 
@@ -895,33 +895,54 @@ func (s *DriverTestSuite) TestOnUnsafeL2PayloadWithMissingAncients() {
 
 	l2Head2, err := s.d.rpc.L2.HeaderByNumber(context.Background(), nil)
 	s.Nil(err)
-	s.Greater(l2Head2.Number.Uint64(), l2Head1.Number.Uint64())
+	s.Greater(l2Head2.Number.Uint64(), l2Head1.Number().Uint64())
 
 	blocks := []*types.Block{}
-	for i := l2Head1.Number.Uint64() + 1; i <= l2Head2.Number.Uint64(); i++ {
+	for i := l2Head1.Number().Uint64() + 1; i <= l2Head2.Number.Uint64(); i++ {
 		block, err := s.RPCClient.L2.BlockByNumber(context.Background(), new(big.Int).SetUint64(i))
 		s.Nil(err)
 		blocks = append(blocks, block)
 	}
-	s.Equal(l2Head2.Number.Uint64()-l2Head1.Number.Uint64(), uint64(len(blocks)))
+	s.Equal(l2Head2.Number.Uint64()-l2Head1.Number().Uint64(), uint64(len(blocks)))
 
 	s.RevertL1Snapshot(snapshotID)
-	s.Nil(rpc.SetHead(context.Background(), s.RPCClient.L2, l2Head1.Number))
+	s.Nil(rpc.SetHead(context.Background(), s.RPCClient.L2, l2Head1.Number()))
 	_, err = s.RPCClient.L2Engine.SetHeadL1Origin(context.Background(), headL1Origin.BlockID)
 	s.Nil(err)
 
 	headL1Origin, err = s.RPCClient.L2.HeadL1Origin(context.Background())
 	s.Nil(err)
-	s.Equal(l2Head1.Number.Uint64(), headL1Origin.BlockID.Uint64())
+	s.Equal(l2Head1.Number().Uint64(), headL1Origin.BlockID.Uint64())
 
-	l2Head3, err := s.d.rpc.L2.HeaderByNumber(context.Background(), nil)
+	l2Head3, err := s.d.rpc.L2.BlockByNumber(context.Background(), nil)
+	s.Nil(err)
+	s.Equal(l2Head1.Number().Uint64(), l2Head3.Number().Uint64())
+
+	baseFee, overflow := uint256.FromBig(l2Head1.BaseFee())
+	s.False(overflow)
+
+	b, err := utils.EncodeAndCompressTxList(l2Head1.Transactions())
 	s.Nil(err)
-	s.Equal(l2Head1.Number.Uint64(), l2Head3.Number.Uint64())
+	s.GreaterOrEqual(len(l2Head1.Transactions()), 1)
+
+	s.d.preconfBlockServer.PutPayloadsCache(l2Head1.Number().Uint64(), &eth.ExecutionPayload{
+		BlockHash:     l2Head1.Hash(),
+		ParentHash:    l2Head1.ParentHash(),
+		FeeRecipient:  l2Head1.Coinbase(),
+		PrevRandao:    eth.Bytes32(l2Head1.MixDigest()),
+		BlockNumber:   eth.Uint64Quantity(l2Head1.Number().Uint64()),
+		GasLimit:      eth.Uint64Quantity(l2Head1.GasLimit()),
+		Timestamp:     eth.Uint64Quantity(l2Head1.Time()),
+		ExtraData:     l2Head1.Extra(),
+		BaseFeePerGas: eth.Uint256Quantity(*baseFee),
+		Transactions:  []eth.Data{b},
+		Withdrawals:   &types.Withdrawals{},
+	})
 
 	// Randomly gossip preconfirmation messages with missing ancients
 	blockNums := rand.Perm(len(blocks))
 	for i := range blockNums {
-		blockNums[i] += int(l2Head1.Number.Uint64() + 1)
+		blockNums[i] += int(l2Head1.Number().Uint64() + 1)
 	}
 
 	getBlock := func(blockNum uint64) *types.Block {
@@ -1001,7 +1022,7 @@ func (s *DriverTestSuite) TestOnUnsafeL2PayloadWithMissingAncients() {
 
 	// Insert all blocks except the first one
 	for _, blockNum := range blockNums {
-		if blockNum == int(l2Head1.Number.Uint64()+1) {
+		if blockNum <= int(l2Head1.Number().Uint64()+2) {
 			continue
 		}
 
@@ -1013,10 +1034,33 @@ func (s *DriverTestSuite) TestOnUnsafeL2PayloadWithMissingAncients() {
 
 	l2Head4, err := s.d.rpc.L2.BlockByNumber(context.Background(), nil)
 	s.Nil(err)
-	s.Equal(l2Head1.Number.Uint64(), l2Head4.Number().Uint64())
+	s.Equal(l2Head1.Number().Uint64(), l2Head4.Number().Uint64())
+
+	// Insert the only two missing ancient blocks
+	block := getBlock(l2Head1.Number().Uint64() + 1)
+	s.NotNil(block)
+	baseFee, overflow = uint256.FromBig(block.BaseFee())
+	s.False(overflow)
+
+	b, err = utils.EncodeAndCompressTxList(block.Transactions())
+	s.Nil(err)
+	s.GreaterOrEqual(len(block.Transactions()), 1)
+
+	s.d.preconfBlockServer.PutPayloadsCache(block.Number().Uint64(), &eth.ExecutionPayload{
+		BlockHash:     block.Hash(),
+		ParentHash:    block.ParentHash(),
+		FeeRecipient:  block.Coinbase(),
+		PrevRandao:    eth.Bytes32(block.MixDigest()),
+		BlockNumber:   eth.Uint64Quantity(block.Number().Uint64()),
+		GasLimit:      eth.Uint64Quantity(block.GasLimit()),
+		Timestamp:     eth.Uint64Quantity(block.Time()),
+		ExtraData:     block.Extra(),
+		BaseFeePerGas: eth.Uint256Quantity(*baseFee),
+		Transactions:  []eth.Data{b},
+		Withdrawals:   &types.Withdrawals{},
+	})
 
-	// Insert the only missing ancient block
-	block := getBlock(l2Head1.Number.Uint64() + 1)
+	block = getBlock(l2Head1.Number().Uint64() + 2)
 	s.NotNil(block)
 	insertPayloadFromBlock(block, false)
 

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

@@ -313,6 +313,15 @@ func (s *PreconfBlockAPIServer) ImportMissingAncientsFromCache(
 				currentPayload.ParentHash.Hex(),
 			)
 		}
+		if parentPayload.BlockHash == headL1Origin.L2BlockHash {
+			log.Debug(
+				"Reached canonical chain head, skip searching for ancients in cache",
+				"parentNumber", parentPayload.BlockNumber,
+				"parentHash", parentPayload.BlockHash,
+			)
+			break
+		}
+
 		payloadsToImport = append([]*eth.ExecutionPayload{parentPayload}, payloadsToImport...)
 
 		// Check if the found parent payload is in the canonical chain,
@@ -507,3 +516,8 @@ func (s *PreconfBlockAPIServer) checkLookaheadHandover(feeRecipient common.Addre
 		return nil
 	}
 }
+
+// PutPayloadsCache puts the given payload into the payload cache queue, should ONLY be used in testing.
+func (s *PreconfBlockAPIServer) PutPayloadsCache(id uint64, payload *eth.ExecutionPayload) {
+	s.payloadsCache.put(id, payload)
+}