wip

clientcontroller/babylon.go

@@ -332,13 +332,13 @@ func (bc *BabylonController) QueryLastCommittedPublicRand(fpPk *btcec.PublicKey,
 	return res.PubRandCommitMap, nil
 }
 
-func (bc *BabylonController) QueryBlocks(startHeight, endHeight uint64, limit uint32) ([]*types.BlockInfo, error) {
+func (bc *BabylonController) QueryBlocks(startHeight, endHeight uint64, limit uint64) ([]*types.BlockInfo, error) {
 	if endHeight < startHeight {
 		return nil, fmt.Errorf("the startHeight %v should not be higher than the endHeight %v", startHeight, endHeight)
 	}
 	count := endHeight - startHeight + 1
-	if count > uint64(limit) {
-		count = uint64(limit)
+	if count > limit {
+		count = limit
 	}
 
 	return bc.queryLatestBlocks(sdk.Uint64ToBigEndian(startHeight), count, finalitytypes.QueriedBlockStatus_ANY, false)

clientcontroller/interface.go

@@ -73,7 +73,7 @@ type ClientController interface {
 	QueryBlock(height uint64) (*types.BlockInfo, error)
 
 	// QueryBlocks returns a list of blocks from startHeight to endHeight
-	QueryBlocks(startHeight, endHeight uint64, limit uint32) ([]*types.BlockInfo, error)
+	QueryBlocks(startHeight, endHeight uint64, limit uint64) ([]*types.BlockInfo, error)
 
 	// QueryBestBlock queries the tip block of the consumer chain
 	QueryBestBlock() (*types.BlockInfo, error)

finality-provider/service/chain_poller.go

@@ -140,7 +140,7 @@ func (cp *ChainPoller) blockWithRetry(height uint64) (*types.BlockInfo, error) {
 	return block, nil
 }
 
-func (cp *ChainPoller) blocksWithRetry(start, end uint64, limit uint32) ([]*types.BlockInfo, error) {
+func (cp *ChainPoller) blocksWithRetry(start, end, limit uint64) ([]*types.BlockInfo, error) {
 	var (
 		block []*types.BlockInfo
 		err   error
@@ -163,7 +163,7 @@ func (cp *ChainPoller) blocksWithRetry(start, end uint64, limit uint32) ([]*type
 			zap.Uint("max_attempts", RtyAttNum),
 			zap.Uint64("start_height", start),
 			zap.Uint64("end_height", end),
-			zap.Uint32("limit", limit),
+			zap.Uint64("limit", limit),
 			zap.Error(err),
 		)
 	})); err != nil {
@@ -243,7 +243,7 @@ func (cp *ChainPoller) pollChain() {
 			// start polling in the first iteration
 			blockToRetrieve := cp.nextHeight
 
-			blocks, err := cp.blocksWithRetry(blockToRetrieve, latestBlock.Height, uint32(latestBlock.Height))
+			blocks, err := cp.blocksWithRetry(blockToRetrieve, latestBlock.Height, latestBlock.Height)
 			if err != nil {
 				failedCycles++
 				cp.logger.Debug(
@@ -289,8 +289,8 @@ func (cp *ChainPoller) pollChain() {
 			// no need to skip heights if the target height is not higher
 			// than the next height to retrieve
 			targetHeight := req.height
-			fmt.Printf("target height %d, next height %d\n", targetHeight, cp.nextHeight)
 			if targetHeight <= cp.nextHeight {
+				fmt.Printf("target height %d, next height %d\n", targetHeight, cp.nextHeight)
 				resp := &skipHeightResponse{
 					err: fmt.Errorf(
 						"the target height %d is not higher than the next height %d to retrieve",

finality-provider/service/chain_poller_test.go

@@ -78,9 +78,7 @@ func FuzzChainPoller_SkipHeight(f *testing.F) {
 		currentHeight := uint64(r.Int63n(100) + 1)
 		startHeight := currentHeight + 1
 		endHeight := startHeight + uint64(r.Int63n(10)+2)
-		skipHeight := endHeight + uint64(r.Int63n(10)+1)
-
-		t.Log(startHeight, endHeight, skipHeight)
+		skipHeight := endHeight + uint64(r.Int63n(10)+2)
 
 		t.Log(startHeight, endHeight, skipHeight)
 
@@ -101,13 +99,19 @@ func FuzzChainPoller_SkipHeight(f *testing.F) {
 			}
 			resBlocks = append(resBlocks, resBlock)
 		}
-		mockClientController.EXPECT().QueryBlocks(gomock.Any(), gomock.Any(), gomock.Any()).Return(resBlocks, nil).AnyTimes()
+		//mockClientController.EXPECT().QueryBlocks(gomock.Any(), gomock.Any(), gomock.Any()).Return(resBlocks, nil).AnyTimes()
+		mockClientController.EXPECT().QueryBlocks(startHeight, endHeight, endHeight).Return(resBlocks, nil).AnyTimes()
+		mockClientController.EXPECT().QueryBlocks(endHeight+1, endHeight, endHeight).Return(resBlocks, nil).AnyTimes()
+
+		resBlocks = append(resBlocks, &types.BlockInfo{
+			Height: skipHeight,
+		})
+		mockClientController.EXPECT().QueryBlocks(startHeight, skipHeight, skipHeight).Return(resBlocks, nil).AnyTimes()
+		mockClientController.EXPECT().QueryBlocks(skipHeight+1, skipHeight, skipHeight).Return(resBlocks, nil).AnyTimes()
+		mockClientController.EXPECT().QueryBlocks(skipHeight, endHeight, endHeight).Return(resBlocks, nil).AnyTimes()
+		mockClientController.EXPECT().QueryBlocks(skipHeight+1, skipHeight, skipHeight).Return(resBlocks, nil).AnyTimes()
 
-		//
-		//mockClientController.EXPECT().QueryBlocks(startHeight, skipHeight, uint32(skipHeight)).Return(resBlocks, nil).AnyTimes()
 		//mockClientController.EXPECT().QueryBlocks(skipHeight, skipHeight, uint32(skipHeight)).Return(resBlocks, nil).AnyTimes()
-		//mockClientController.EXPECT().QueryBlocks(skipHeight+1, skipHeight, uint32(skipHeight)).Return(resBlocks, nil).AnyTimes()
-		//mockClientController.EXPECT().QueryBlocks(startHeight, endHeight, uint32(endHeight)).Return(resBlocks, nil).AnyTimes()
 
 		m := metrics.NewFpMetrics()
 		pollerCfg := fpcfg.DefaultChainPollerConfig()
@@ -118,13 +122,13 @@ func FuzzChainPoller_SkipHeight(f *testing.F) {
 		require.Error(t, err)
 		err = poller.Start(startHeight)
 		require.NoError(t, err)
-		//defer func() {
-		//	err := poller.Stop()
-		//	require.NoError(t, err)
-		//	// should expect error if the poller is stopped
-		//	err = poller.SkipToHeight(skipHeight)
-		//	require.Error(t, err)
-		//}()
+		defer func() {
+			err := poller.Stop()
+			require.NoError(t, err)
+			// should expect error if the poller is stopped
+			err = poller.SkipToHeight(skipHeight)
+			require.Error(t, err)
+		}()
 
 		var wg sync.WaitGroup
 		wg.Add(1)
@@ -153,6 +157,7 @@ func FuzzChainPoller_SkipHeight(f *testing.F) {
 				if info.Height == skipHeight {
 					skipped = true
 				} else {
+					t.Log(i, info.Height)
 					require.Equal(t, i, info.Height)
 				}
 			case <-time.After(10 * time.Second):
@@ -161,6 +166,7 @@ func FuzzChainPoller_SkipHeight(f *testing.F) {
 		}
 
 		wg.Wait()
+		t.Log(skipHeight+1, poller.NextHeight())
 		require.Equal(t, skipHeight+1, poller.NextHeight())
 	})
 }