feat(tbtcpg): add bounded lookback window for deposit sweep event queries

Add a configurable look-back period (DepositSweepLookBackBlocks = 216000
blocks, ~30 days) to FindDepositsToSweep so it only scans recent blocks
for DepositRevealed events instead of the full chain history. When the
current block exceeds the look-back window, filterStartBlock is computed
as currentBlock - lookBackBlocks; otherwise it falls back to 0 to guard
against underflow. FindDeposits (used by the MovingFunds safety guard)
continues to scan from block 0 to preserve full-history coverage.

Add tests for both the bounded lookback path (currentBlock=300000,
filterStartBlock=84000) and the underflow guard path
(currentBlock=100000, filterStartBlock=0). Wire MockBlockCounter into
the existing JSON-driven scenario tests so they pass with the new
BlockCounter dependency.

Author: lrsaturnino

pkg/tbtcpg/deposit_sweep.go

@@ -19,6 +19,11 @@ import (
 // This will ensure that deposit sweep transaction fees are not underestimated.
 const depositScriptByteSize = 126
 
+// DepositSweepLookBackBlocks is the look-back period in blocks used
+// when searching for submitted deposit-related events. It's equal to
+// 30 days assuming 12 seconds per block.
+const DepositSweepLookBackBlocks = uint64(216000)
+
 // DepositSweepTask is a task that may produce a deposit sweep proposal.
 type DepositSweepTask struct {
 	chain    Chain
@@ -110,7 +115,9 @@ type Deposit struct {
 	Confirmations       uint
 }
 
-// FindDeposits finds deposits according to the given criteria.
+// FindDeposits finds deposits according to the given criteria. It always
+// performs a full-history scan (from block 0) to ensure all matching deposits
+// are returned regardless of age.
 func FindDeposits(
 	chain Chain,
 	btcChain bitcoin.Chain,
@@ -127,10 +134,13 @@ func FindDeposits(
 		maxNumberOfDeposits,
 		skipSwept,
 		skipUnconfirmed,
+		0,
 	)
 }
 
 // findDeposits finds deposits according to the given criteria.
+// The filterStartBlock parameter controls the earliest block from which
+// deposit-revealed events are queried.
 func findDeposits(
 	fnLogger log.StandardLogger,
 	chain Chain,
@@ -139,6 +149,7 @@ func findDeposits(
 	maxNumberOfDeposits int,
 	skipSwept bool,
 	skipUnconfirmed bool,
+	filterStartBlock uint64,
 ) ([]*Deposit, error) {
 	fnLogger.Infof("reading revealed deposits from chain")
 
@@ -151,7 +162,9 @@ func findDeposits(
 	}
 	depositMinAge := time.Duration(depositMinAgeSeconds) * time.Second
 
-	filter := &tbtc.DepositRevealedEventFilter{}
+	filter := &tbtc.DepositRevealedEventFilter{
+		StartBlock: filterStartBlock,
+	}
 	if walletPublicKeyHash != [20]byte{} {
 		filter.WalletPublicKeyHash = [][20]byte{walletPublicKeyHash}
 	}
@@ -280,6 +293,27 @@ func (dst *DepositSweepTask) FindDepositsToSweep(
 
 	taskLogger.Infof("fetching max [%d] deposits", maxNumberOfDeposits)
 
+	blockCounter, err := dst.chain.BlockCounter()
+	if err != nil {
+		return nil, fmt.Errorf(
+			"failed to get block counter: [%w]",
+			err,
+		)
+	}
+
+	currentBlockNumber, err := blockCounter.CurrentBlock()
+	if err != nil {
+		return nil, fmt.Errorf(
+			"failed to get current block number: [%w]",
+			err,
+		)
+	}
+
+	filterStartBlock := uint64(0)
+	if currentBlockNumber > DepositSweepLookBackBlocks {
+		filterStartBlock = currentBlockNumber - DepositSweepLookBackBlocks
+	}
+
 	unsweptDeposits, err := findDeposits(
 		taskLogger,
 		dst.chain,
@@ -288,6 +322,7 @@ func (dst *DepositSweepTask) FindDepositsToSweep(
 		int(maxNumberOfDeposits),
 		true,
 		true,
+		filterStartBlock,
 	)
 	if err != nil {
 		return nil, err

pkg/tbtcpg/deposit_sweep_test.go

@@ -3,6 +3,7 @@ package tbtcpg_test
 import (
 	"reflect"
 	"testing"
+	"time"
 
 	"github.com/go-test/deep"
 	"github.com/ipfs/go-log"
@@ -13,6 +14,179 @@ import (
 	"github.com/keep-network/keep-core/pkg/tbtcpg/internal/test"
 )
 
+func TestDepositSweepLookBackBlocks(t *testing.T) {
+	// The look-back period should be 30 days at 12 seconds per block,
+	// matching the value used by MovedFundsSweepLookBackBlocks.
+	expectedValue := uint64(216000)
+
+	if tbtcpg.DepositSweepLookBackBlocks != expectedValue {
+		t.Errorf(
+			"unexpected DepositSweepLookBackBlocks\n"+
+				"expected: %d\n"+
+				"actual:   %d",
+			expectedValue,
+			tbtcpg.DepositSweepLookBackBlocks,
+		)
+	}
+}
+
+func TestDepositSweepTask_FindDepositsToSweep_BoundedLookback(t *testing.T) {
+	// When the current block (300000) exceeds the look-back window
+	// (216000 blocks), the filter start block should be bounded:
+	// filterStartBlock = 300000 - 216000 = 84000.
+	currentBlock := uint64(300000)
+	expectedStartBlock := currentBlock - tbtcpg.DepositSweepLookBackBlocks
+
+	walletPublicKeyHash := hexToByte20(
+		"7670343fc00ccc2d0cd65360e6ad400697ea0fed",
+	)
+
+	tbtcChain := tbtcpg.NewLocalChain()
+	btcChain := tbtcpg.NewLocalBitcoinChain()
+
+	blockCounter := tbtcpg.NewMockBlockCounter()
+	blockCounter.SetCurrentBlock(currentBlock)
+	tbtcChain.SetBlockCounter(blockCounter)
+
+	tbtcChain.SetDepositMinAge(3600)
+
+	fundingTxHash := hashFromString(
+		"a8c3b3c1975094550d481bdffdee1b7b7613dd74dbce37a5f6dce7fd9ac0ace1",
+	)
+
+	tbtcChain.SetDepositRequest(
+		fundingTxHash,
+		uint32(1),
+		&tbtc.DepositChainRequest{
+			RevealedAt: time.Now().Add(-2 * time.Hour),
+			SweptAt:    time.Unix(0, 0),
+		},
+	)
+
+	btcChain.SetTransaction(fundingTxHash, &bitcoin.Transaction{})
+	btcChain.SetTransactionConfirmations(
+		fundingTxHash,
+		tbtc.DepositSweepRequiredFundingTxConfirmations,
+	)
+
+	// Register events under the filter with the bounded start block.
+	// The production code will query with StartBlock = expectedStartBlock,
+	// so the event registration must use the same filter key.
+	err := tbtcChain.AddPastDepositRevealedEvent(
+		&tbtc.DepositRevealedEventFilter{
+			StartBlock:          expectedStartBlock,
+			WalletPublicKeyHash: [][20]byte{walletPublicKeyHash},
+		},
+		&tbtc.DepositRevealedEvent{
+			BlockNumber:         290000,
+			WalletPublicKeyHash: walletPublicKeyHash,
+			FundingTxHash:       fundingTxHash,
+			FundingOutputIndex:  1,
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	task := tbtcpg.NewDepositSweepTask(tbtcChain, btcChain)
+
+	deposits, err := task.FindDepositsToSweep(
+		&testutils.MockLogger{},
+		walletPublicKeyHash,
+		5,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(deposits) != 1 {
+		t.Fatalf("expected 1 deposit, got %d", len(deposits))
+	}
+
+	if deposits[0].FundingTxHash != fundingTxHash {
+		t.Errorf("unexpected funding tx hash")
+	}
+
+	if deposits[0].FundingOutputIndex != 1 {
+		t.Errorf("unexpected funding output index")
+	}
+}
+
+func TestDepositSweepTask_FindDepositsToSweep_UnderflowGuard(t *testing.T) {
+	// When the current block is less than the look-back window, the filter
+	// start block should remain 0 to avoid underflow.
+	currentBlock := uint64(100000)
+
+	walletPublicKeyHash := hexToByte20(
+		"7670343fc00ccc2d0cd65360e6ad400697ea0fed",
+	)
+
+	tbtcChain := tbtcpg.NewLocalChain()
+	btcChain := tbtcpg.NewLocalBitcoinChain()
+
+	blockCounter := tbtcpg.NewMockBlockCounter()
+	blockCounter.SetCurrentBlock(currentBlock)
+	tbtcChain.SetBlockCounter(blockCounter)
+
+	tbtcChain.SetDepositMinAge(3600)
+
+	fundingTxHash := hashFromString(
+		"d91868ca43db4deb96047d727a5e782f282864fde2d9364f8c562c8998ba64bf",
+	)
+
+	tbtcChain.SetDepositRequest(
+		fundingTxHash,
+		uint32(1),
+		&tbtc.DepositChainRequest{
+			RevealedAt: time.Now().Add(-2 * time.Hour),
+			SweptAt:    time.Unix(0, 0),
+		},
+	)
+
+	btcChain.SetTransaction(fundingTxHash, &bitcoin.Transaction{})
+	btcChain.SetTransactionConfirmations(
+		fundingTxHash,
+		tbtc.DepositSweepRequiredFundingTxConfirmations,
+	)
+
+	// Register events under the filter with StartBlock = 0,
+	// since the underflow guard should keep the filter at 0.
+	err := tbtcChain.AddPastDepositRevealedEvent(
+		&tbtc.DepositRevealedEventFilter{
+			StartBlock:          0,
+			WalletPublicKeyHash: [][20]byte{walletPublicKeyHash},
+		},
+		&tbtc.DepositRevealedEvent{
+			BlockNumber:         90000,
+			WalletPublicKeyHash: walletPublicKeyHash,
+			FundingTxHash:       fundingTxHash,
+			FundingOutputIndex:  1,
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	task := tbtcpg.NewDepositSweepTask(tbtcChain, btcChain)
+
+	deposits, err := task.FindDepositsToSweep(
+		&testutils.MockLogger{},
+		walletPublicKeyHash,
+		5,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(deposits) != 1 {
+		t.Fatalf("expected 1 deposit, got %d", len(deposits))
+	}
+
+	if deposits[0].FundingTxHash != fundingTxHash {
+		t.Errorf("unexpected funding tx hash")
+	}
+}
+
 func TestDepositSweepTask_FindDepositsToSweep(t *testing.T) {
 	err := log.SetLogLevel("*", "DEBUG")
 	if err != nil {
@@ -31,6 +205,20 @@ func TestDepositSweepTask_FindDepositsToSweep(t *testing.T) {
 
 			tbtcChain.SetDepositMinAge(scenario.ChainParameters.DepositMinAge)
 
+			// Wire the MockBlockCounter using the scenario's current
+			// block value. FindDepositsToSweep requires a block
+			// counter to compute the bounded lookback window.
+			blockCounter := tbtcpg.NewMockBlockCounter()
+			blockCounter.SetCurrentBlock(scenario.ChainParameters.CurrentBlock)
+			tbtcChain.SetBlockCounter(blockCounter)
+
+			// Compute the expected filter start block using the same
+			// logic as the production code.
+			filterStartBlock := uint64(0)
+			if scenario.ChainParameters.CurrentBlock > tbtcpg.DepositSweepLookBackBlocks {
+				filterStartBlock = scenario.ChainParameters.CurrentBlock - tbtcpg.DepositSweepLookBackBlocks
+			}
+
 			// Chain setup.
 			for _, deposit := range scenario.Deposits {
 				tbtcChain.SetDepositRequest(
@@ -48,7 +236,10 @@ func TestDepositSweepTask_FindDepositsToSweep(t *testing.T) {
 				)
 
 				err := tbtcChain.AddPastDepositRevealedEvent(
-					&tbtc.DepositRevealedEventFilter{WalletPublicKeyHash: [][20]byte{deposit.WalletPublicKeyHash}},
+					&tbtc.DepositRevealedEventFilter{
+						StartBlock:          filterStartBlock,
+						WalletPublicKeyHash: [][20]byte{deposit.WalletPublicKeyHash},
+					},
 					&tbtc.DepositRevealedEvent{
 						BlockNumber:         deposit.RevealBlockNumber,
 						WalletPublicKeyHash: deposit.WalletPublicKeyHash,