address test coverage

Signed-off-by: Chengxuan Xing <[email protected]>

Author: Chengxuan

internal/ethereum/confirmation_reconciler.go

@@ -79,7 +79,7 @@ func (bl *blockListener) buildConfirmationList(ctx context.Context, existingConf
 	// - The `lateList`. This is the most recent set of blocks that we are interesting in and we believe are accurate for the current state of the chain
 
 	earlyList := createEarlyList(existingConfirmations, txBlockInfo, reconcileResult)
-	lateList, err := createLateList(ctx, txBlockInfo, targetConfirmationCount, reconcileResult, bl)
+	lateList, err := createLateList(ctx, txBlockInfo, targetConfirmationCount, bl)
 	if err != nil {
 		return nil, err
 	}
@@ -140,9 +140,6 @@ func newSplice(earlyList []*ffcapi.MinimalBlockInfo, lateList []*ffcapi.MinimalB
 		earlyList: earlyList,
 		lateList:  lateList,
 	}
-	if len(s.earlyList) == 0 || len(s.lateList) == 0 {
-		return s, false
-	}
 	detectedFork := false
 	// if the early list is bigger than the gap between the transaction block number and the first block in the late list, then we have an overlap
 	txBlockNumber := s.earlyList[0].BlockNumber.Uint64()
@@ -178,11 +175,6 @@ func (s *splice) isEarlyListEmpty() bool {
 }
 
 func (s *splice) fillOneGap(ctx context.Context, blockListener *blockListener) error {
-	if !s.hasGap() {
-		// no gap to fill
-		return nil
-	}
-
 	// fill one slot in the gap between the late list and the early list
 	// always fill from the end of the gap ( i.e. the block before the start of the late list) because
 	// the late list is our best view of the current canonical chain so working backwards from there will increase the number of blocks that we have a high confidence in
@@ -191,9 +183,6 @@ func (s *splice) fillOneGap(ctx context.Context, blockListener *blockListener) e
 	if err != nil {
 		return err
 	}
-	if freshBlockInfo == nil {
-		return i18n.NewError(ctx, msgs.MsgBlockNotAvailable)
-	}
 
 	fetchedBlock := &ffcapi.MinimalBlockInfo{
 		BlockNumber: fftypes.FFuint64(freshBlockInfo.Number.BigInt().Uint64()),
@@ -213,25 +202,12 @@ func (s *splice) fillOneGap(ctx context.Context, blockListener *blockListener) e
 }
 
 func (s *splice) removeBrokenLink() {
-	if s.hasGap() {
-		// nothing to remove if there is a gap
-		return
-	}
 	// remove the last block from the early list because it is not the parent of the first block in the late list and we have higher confidence in the late list
 	s.earlyList = s.earlyList[:len(s.earlyList)-1]
 
 }
 
 func (s *splice) toSingleLinkedList() []*ffcapi.MinimalBlockInfo {
-	if s.hasGap() {
-		return nil
-	}
-	if len(s.earlyList) == 0 {
-		return s.lateList
-	}
-	if len(s.lateList) == 0 {
-		return s.earlyList
-	}
 	if s.earlyList[len(s.earlyList)-1].IsParentOf(s.lateList[0]) {
 		return append(s.earlyList, s.lateList...)
 	}
@@ -244,20 +220,20 @@ func (s *splice) toSingleLinkedList() []*ffcapi.MinimalBlockInfo {
 // any blocks that are not contiguous will be discarded
 func createEarlyList(existingConfirmations []*ffcapi.MinimalBlockInfo, txBlockInfo *ffcapi.MinimalBlockInfo, reconcileResult *ffcapi.ConfirmationUpdateResult) (earlyList []*ffcapi.MinimalBlockInfo) {
 	if len(existingConfirmations) > 0 && !existingConfirmations[0].Equal(txBlockInfo) {
-		// otherwise we discard the existing confirmations queue
+		// otherwise we discard the existing confirmations list
 		reconcileResult.NewFork = true
 	} else {
 		earlyList = existingConfirmations
 	}
 
-	if len(existingConfirmations) == 0 {
+	if len(earlyList) == 0 {
 		// either because this is the first time we are reconciling this transaction or because we just discarded the existing confirmations queue
 		earlyList = []*ffcapi.MinimalBlockInfo{txBlockInfo}
 	}
 	return earlyList
 }
 
-func createLateList(ctx context.Context, txBlockInfo *ffcapi.MinimalBlockInfo, targetConfirmationCount uint64, reconcileResult *ffcapi.ConfirmationUpdateResult, blockListener *blockListener) (lateList []*ffcapi.MinimalBlockInfo, err error) {
+func createLateList(ctx context.Context, txBlockInfo *ffcapi.MinimalBlockInfo, targetConfirmationCount uint64, blockListener *blockListener) (lateList []*ffcapi.MinimalBlockInfo, err error) {
 	lateList, err = blockListener.buildConfirmationQueueUsingInMemoryPartialChain(ctx, txBlockInfo, targetConfirmationCount)
 	if err != nil {
 		return nil, err
@@ -270,10 +246,6 @@ func createLateList(ctx context.Context, txBlockInfo *ffcapi.MinimalBlockInfo, t
 		if err != nil {
 			return nil, err
 		}
-		if targetBlockInfo == nil {
-			return nil, i18n.NewError(ctx, msgs.MsgBlockNotAvailable)
-		}
-
 		lateList = []*ffcapi.MinimalBlockInfo{
 			{
 				BlockNumber: fftypes.FFuint64(targetBlockInfo.Number.BigInt().Uint64()),
@@ -360,7 +332,7 @@ func (bl *blockListener) handleZeroTargetConfirmationCount(ctx context.Context,
 	return nil, i18n.NewError(ctx, msgs.MsgInMemoryPartialChainNotCaughtUp, txBlockInfo.BlockNumber.Uint64(), txBlockInfo.BlockHash)
 }
 
-func (bl *blockListener) handleTargetCountLessThanExistingConfirmationLength(ctx context.Context, existingConfirmations []*ffcapi.MinimalBlockInfo, txBlockInfo *ffcapi.MinimalBlockInfo, targetConfirmationCount uint64) (*ffcapi.ConfirmationUpdateResult, error) {
+func (bl *blockListener) handleTargetCountLessThanExistingConfirmationLength(_ context.Context, existingConfirmations []*ffcapi.MinimalBlockInfo, txBlockInfo *ffcapi.MinimalBlockInfo, targetConfirmationCount uint64) (*ffcapi.ConfirmationUpdateResult, error) {
 	bl.mux.RLock()
 	defer bl.mux.RUnlock()
 	nextInMemoryBlock := bl.canonicalChain.Front()

internal/ethereum/confirmation_reconciler_test.go

@@ -229,6 +229,54 @@ func TestReconcileConfirmationsForTransaction_NewConfirmation(t *testing.T) {
 	mRPC.AssertExpectations(t)
 }
 
+func TestReconcileConfirmationsForTransaction_DifferentTxBlock(t *testing.T) {
+
+	_, c, mRPC, _ := newTestConnectorWithNoBlockerFilterDefaultMocks(t)
+	bl := c.blockListener
+	bl.canonicalChain = createTestChain(1976, 1978) // Single block at 50, tx is at 100
+
+	// Mock for TransactionReceipt call
+	mRPC.On("CallRPC", mock.Anything, mock.Anything, "eth_getTransactionReceipt",
+		mock.MatchedBy(func(txHash string) bool {
+			assert.Equal(t, "0x6197ef1a58a2a592bb447efb651f0db7945de21aa8048801b250bd7b7431f9b6", txHash)
+			return true
+		})).
+		Return(nil).
+		Run(func(args mock.Arguments) {
+			err := json.Unmarshal([]byte(sampleJSONRPCReceipt), args[1])
+			assert.NoError(t, err)
+		})
+
+	mRPC.On("CallRPC", mock.Anything, mock.Anything, "eth_getBlockByNumber", mock.MatchedBy(func(bn *ethtypes.HexInteger) bool {
+		return bn.BigInt().String() == "1977"
+	}), false).Return(nil).Run(func(args mock.Arguments) {
+		*args[1].(**blockInfoJSONRPC) = &blockInfoJSONRPC{
+			Number:     ethtypes.NewHexInteger64(1977),
+			Hash:       ethtypes.MustNewHexBytes0xPrefix(generateTestHash(1977)),
+			ParentHash: ethtypes.MustNewHexBytes0xPrefix(generateTestHash(1976)),
+		}
+	})
+
+	// Execute the reconcileConfirmationsForTransaction function
+	result, err := c.ReconcileConfirmationsForTransaction(context.Background(), "0x6197ef1a58a2a592bb447efb651f0db7945de21aa8048801b250bd7b7431f9b6", []*ffcapi.MinimalBlockInfo{
+		{BlockNumber: fftypes.FFuint64(1979), BlockHash: generateTestHash(1979), ParentHash: generateTestHash(1978)},
+		{BlockNumber: fftypes.FFuint64(1980), BlockHash: generateTestHash(1980), ParentHash: generateTestHash(1979)},
+	}, 5)
+
+	// Assertions - expect the existing confirmation queue to be returned because the tx block doesn't match the same block number in the canonical chain
+	assert.NoError(t, err)
+	assert.NotNil(t, result)
+	assert.True(t, result.NewFork)
+	assert.False(t, result.Confirmed)
+	assert.Equal(t, []*ffcapi.MinimalBlockInfo{
+		{BlockNumber: fftypes.FFuint64(1977), BlockHash: generateTestHash(1977), ParentHash: generateTestHash(1976)},
+		{BlockNumber: fftypes.FFuint64(1978), BlockHash: generateTestHash(1978), ParentHash: generateTestHash(1977)},
+	}, result.Confirmations)
+	assert.Equal(t, uint64(5), result.TargetConfirmationCount)
+
+	mRPC.AssertExpectations(t)
+}
+
 func TestBuildConfirmationList_GapInExistingConfirmationsError(t *testing.T) {
 	// Setup
 	_, c, mRPC, _ := newTestConnectorWithNoBlockerFilterDefaultMocks(t)
@@ -281,7 +329,6 @@ func TestBuildConfirmationList_MismatchConfirmationBlockError(t *testing.T) {
 	assert.Nil(t, confirmationUpdateResult)
 	assert.Regexp(t, "FF23063", err.Error())
 }
-
 func TestBuildConfirmationList_ExistingConfirmationLaterThanCurrentBlockError(t *testing.T) {
 	// Setup
 	_, c, mRPC, _ := newTestConnectorWithNoBlockerFilterDefaultMocks(t)
@@ -650,41 +697,6 @@ func TestBuildConfirmationList_ConnectionNodeMismatch(t *testing.T) {
 	assert.Equal(t, txBlockNumber+5, uint64(confirmationUpdateResult.Confirmations[5].BlockNumber))
 }
 
-func TestBuildConfirmationList_CorruptedExistingConfirmationAfterFirstConfirmation(t *testing.T) {
-	// Setup
-	bl, done := newBlockListenerWithTestChain(t, 100, 5, 100, 150, []uint64{})
-	defer done()
-
-	ctx := context.Background()
-	existingQueue := []*ffcapi.MinimalBlockInfo{
-		{BlockHash: generateTestHash(100), BlockNumber: fftypes.FFuint64(100), ParentHash: generateTestHash(99)},
-		{BlockHash: generateTestHash(101), BlockNumber: fftypes.FFuint64(101), ParentHash: generateTestHash(100)},
-		{BlockHash: generateTestHash(102), BlockNumber: fftypes.FFuint64(102), ParentHash: "0xblockwrong"},
-	}
-	txBlockNumber := uint64(100)
-	txBlockHash := generateTestHash(100)
-	txBlockInfo := &ffcapi.MinimalBlockInfo{
-		BlockNumber: fftypes.FFuint64(txBlockNumber),
-		BlockHash:   txBlockHash,
-		ParentHash:  generateTestHash(99),
-	}
-	targetConfirmationCount := uint64(5)
-
-	// Execute
-	confirmationUpdateResult, err := bl.buildConfirmationList(ctx, existingQueue, txBlockInfo, targetConfirmationCount)
-	assert.NoError(t, err)
-	// Assert
-	assert.True(t, confirmationUpdateResult.NewFork)
-	assert.True(t, confirmationUpdateResult.Confirmed)
-	assert.Len(t, confirmationUpdateResult.Confirmations, 6)
-	assert.Equal(t, txBlockNumber, uint64(confirmationUpdateResult.Confirmations[0].BlockNumber))
-	assert.Equal(t, txBlockNumber+1, uint64(confirmationUpdateResult.Confirmations[1].BlockNumber))
-	assert.Equal(t, txBlockNumber+2, uint64(confirmationUpdateResult.Confirmations[2].BlockNumber))
-	assert.Equal(t, txBlockNumber+3, uint64(confirmationUpdateResult.Confirmations[3].BlockNumber))
-	assert.Equal(t, txBlockNumber+4, uint64(confirmationUpdateResult.Confirmations[4].BlockNumber))
-	assert.Equal(t, txBlockNumber+5, uint64(confirmationUpdateResult.Confirmations[5].BlockNumber))
-}
-
 func TestBuildConfirmationList_FailedToFetchBlockInfo(t *testing.T) {
 	// Setup
 	mRPC := &rpcbackendmocks.Backend{}