sweepbatcher: customize initialDelay per sweep

Option WithInitialDelay now accepts a function returning initialDelay
depending on sweep's data.

This is needed to be able to wait longer for sweeps with low priority, but
still sweeping high priority sweeps soon.

Author: starius

sweepbatcher/sweep_batch.go

@@ -150,11 +150,13 @@ type batchConfig struct {
 	// clock provides methods to work with time and timers.
 	clock clock.Clock
 
-	// initialDelay is the delay of first batch publishing after creation.
-	// It only affects newly created batches, not batches loaded from DB,
-	// so publishing does happen in case of a daemon restart (especially
-	// important in case of a crashloop).
-	initialDelay time.Duration
+	// initialDelayProvider provides the delay of first batch publishing
+	// after creation. It only affects newly created batches, not batches
+	// loaded from DB, so publishing does happen in case of a daemon restart
+	// (especially important in case of a crashloop). If a sweep is about to
+	// expire (time until timeout is less that 2x initialDelay), then
+	// waiting is skipped.
+	initialDelayProvider InitialDelayProvider
 
 	// batchPublishDelay is the delay between receiving a new block or
 	// initial delay completion and publishing the batch transaction.
@@ -645,6 +647,7 @@ func (b *batch) Run(ctx context.Context) error {
 
 	// Cache clock variable.
 	clock := b.cfg.clock
+	startTime := clock.Now()
 
 	blockChan, blockErrChan, err :=
 		b.chainNotifier.RegisterBlockEpochNtfn(runCtx)
@@ -674,17 +677,15 @@ func (b *batch) Run(ctx context.Context) error {
 
 	// skipBefore is the time before which we skip batch publishing.
 	// This is needed to facilitate better grouping of sweeps.
+	// The value is set only if the batch has at least one sweep.
 	// For batches loaded from DB initialDelay should be 0.
-	skipBefore := clock.Now().Add(b.cfg.initialDelay)
+	var skipBefore *time.Time
 
 	// initialDelayChan is a timer which fires upon initial delay end.
 	// If initialDelay is set to 0, it will not trigger to avoid setting up
 	// timerChan twice, which could lead to double publishing if
 	// batchPublishDelay is also 0.
 	var initialDelayChan <-chan time.Time
-	if b.cfg.initialDelay > 0 {
-		initialDelayChan = clock.TickAfter(b.cfg.initialDelay)
-	}
 
 	// We use a timer in order to not publish new transactions at the same
 	// time as the block epoch notification. This is done to prevent
@@ -698,6 +699,40 @@ func (b *batch) Run(ctx context.Context) error {
 		b.primarySweepID[0:6], len(b.sweeps))
 
 	for {
+		// If the batch if not empty, find earliest initialDelay.
+		now := clock.Now()
+		skipBeforeUpdated := false
+		for _, sweep := range b.sweeps {
+			initialDelay, err := b.cfg.initialDelayProvider(
+				ctx, sweep.swapHash, sweep.outpoint,
+				sweep.value, sweep.timeout,
+			)
+			if err != nil {
+				b.Warnf("initialDelayProvider failed: %v", err)
+				initialDelay = 0
+			}
+			if initialDelay < 0 {
+				b.Warnf("negative delay: %v", initialDelay)
+				initialDelay = 0
+			}
+			delayStop := now.Add(initialDelay)
+			if skipBefore == nil || delayStop.Before(*skipBefore) {
+				skipBefore = &delayStop
+				skipBeforeUpdated = true
+			}
+		}
+		// Create new timer only if the value of skipBefore was updated,
+		// this happens if this is the first sweep in the batch or if
+		// a sweep with lower initialDelay was added, moving skipBefore
+		// toward the present. Don't create the timer if the delay is 0,
+		// to avoid double publishing if batchPublishDelay is also 0.
+		if skipBeforeUpdated {
+			delay := skipBefore.Sub(now)
+			if delay != 0 {
+				initialDelayChan = clock.TickAfter(delay)
+			}
+		}
+
 		select {
 		case <-b.callEnter:
 			<-b.callLeave
@@ -713,7 +748,7 @@ func (b *batch) Run(ctx context.Context) error {
 
 		case <-initialDelayChan:
 			b.Debugf("initial delay of duration %v has ended",
-				b.cfg.initialDelay)
+				clock.Now().Sub(startTime))
 
 			// Set the timer to publish the batch transaction after
 			// the configured delay.
@@ -727,17 +762,23 @@ func (b *batch) Run(ctx context.Context) error {
 				continue
 			}
 
+			if skipBefore == nil {
+				b.Debugf("Skipping publishing, because " +
+					"the batch is empty.")
+				continue
+			}
+
 			// If the batch became urgent, skipBefore is set to now.
-			if b.isUrgent(skipBefore) {
-				skipBefore = clock.Now()
+			if b.isUrgent(*skipBefore) {
+				*skipBefore = clock.Now()
 			}
 
 			// Check that the initial delay has ended. We have also
 			// batchPublishDelay on top of initialDelay, so if
 			// initialDelayChan has just fired, this check passes.
 			now := clock.Now()
 			if skipBefore.After(now) {
-				b.Debugf(stillWaitingMsg, skipBefore, now)
+				b.Debugf(stillWaitingMsg, *skipBefore, now)
 				continue
 			}
 

sweepbatcher/sweep_batcher.go

@@ -162,6 +162,22 @@ type VerifySchnorrSig func(pubKey *btcec.PublicKey, hash, sig []byte) error
 type FeeRateProvider func(ctx context.Context,
 	swapHash lntypes.Hash) (chainfee.SatPerKWeight, error)
 
+// InitialDelayProvider returns the duration after new batch creation before it
+// is first published. It allows to customize the duration based on swap hash,
+// sweep outpoint, sweep size and expity block height. There is a trade-off
+// between better grouping and getting funds better. If the function returns an
+// error, no delay is used and the error is logged as a warning.
+type InitialDelayProvider func(ctx context.Context, swapHash lntypes.Hash,
+	outpoint wire.OutPoint, value btcutil.Amount,
+	timeout int32) (time.Duration, error)
+
+// zeroInitialDelay returns no delay for any sweeps.
+func zeroInitialDelay(_ context.Context, _ lntypes.Hash, _ wire.OutPoint,
+	_ btcutil.Amount, _ int32) (time.Duration, error) {
+
+	return 0, nil
+}
+
 // PublishErrorHandler is a function that handles transaction publishing error.
 type PublishErrorHandler func(err error, errMsg string, log btclog.Logger)
 
@@ -296,13 +312,13 @@ type Batcher struct {
 	// clock provides methods to work with time and timers.
 	clock clock.Clock
 
-	// initialDelay is the delay of first batch publishing after creation.
-	// It only affects newly created batches, not batches loaded from DB,
-	// so publishing does happen in case of a daemon restart (especially
-	// important in case of a crashloop). If a sweep is about to expire
-	// (time until timeout is less that 2x initialDelay), then waiting is
-	// skipped.
-	initialDelay time.Duration
+	// initialDelayProvider provides the delay of first batch publishing
+	// after creation. It only affects newly created batches, not batches
+	// loaded from DB, so publishing does happen in case of a daemon restart
+	// (especially important in case of a crashloop). If a sweep is about to
+	// expire (time until timeout is less that 2x initialDelay), then
+	// waiting is skipped.
+	initialDelayProvider InitialDelayProvider
 
 	// publishDelay is the delay of batch publishing that is applied in the
 	// beginning, after the appearance of a new block in the network or
@@ -336,13 +352,13 @@ type BatcherConfig struct {
 	// clock provides methods to work with time and timers.
 	clock clock.Clock
 
-	// initialDelay is the delay of first batch publishing after creation.
-	// It only affects newly created batches, not batches loaded from DB,
-	// so publishing does happen in case of a daemon restart (especially
-	// important in case of a crashloop). If a sweep is about to expire
-	// (time until timeout is less that 2x initialDelay), then waiting is
-	// skipped.
-	initialDelay time.Duration
+	// initialDelayProvider provides the delay of first batch publishing
+	// after creation. It only affects newly created batches, not batches
+	// loaded from DB, so publishing does happen in case of a daemon restart
+	// (especially important in case of a crashloop). If a sweep is about to
+	// expire (time until timeout is less that 2x initialDelay), then
+	// waiting is skipped.
+	initialDelayProvider InitialDelayProvider
 
 	// publishDelay is the delay of batch publishing that is applied in the
 	// beginning, after the appearance of a new block in the network or
@@ -387,9 +403,9 @@ func WithClock(clock clock.Clock) BatcherOption {
 // better grouping. Defaults to 0s (no initial delay). If a sweep is about
 // to expire (time until timeout is less that 2x initialDelay), then waiting
 // is skipped.
-func WithInitialDelay(initialDelay time.Duration) BatcherOption {
+func WithInitialDelay(provider InitialDelayProvider) BatcherOption {
 	return func(cfg *BatcherConfig) {
-		cfg.initialDelay = initialDelay
+		cfg.initialDelayProvider = provider
 	}
 }
 
@@ -475,27 +491,27 @@ func NewBatcher(wallet lndclient.WalletKitClient,
 	}
 
 	return &Batcher{
-		batches:             make(map[int32]*batch),
-		sweepReqs:           make(chan SweepRequest),
-		testReqs:            make(chan *testRequest),
-		errChan:             make(chan error, 1),
-		quit:                make(chan struct{}),
-		initDone:            make(chan struct{}),
-		wallet:              wallet,
-		chainNotifier:       chainNotifier,
-		signerClient:        signerClient,
-		musig2ServerSign:    musig2ServerSigner,
-		VerifySchnorrSig:    verifySchnorrSig,
-		chainParams:         chainparams,
-		store:               store,
-		sweepStore:          sweepStore,
-		clock:               cfg.clock,
-		initialDelay:        cfg.initialDelay,
-		publishDelay:        cfg.publishDelay,
-		customFeeRate:       cfg.customFeeRate,
-		txLabeler:           cfg.txLabeler,
-		customMuSig2Signer:  cfg.customMuSig2Signer,
-		publishErrorHandler: cfg.publishErrorHandler,
+		batches:              make(map[int32]*batch),
+		sweepReqs:            make(chan SweepRequest),
+		testReqs:             make(chan *testRequest),
+		errChan:              make(chan error, 1),
+		quit:                 make(chan struct{}),
+		initDone:             make(chan struct{}),
+		wallet:               wallet,
+		chainNotifier:        chainNotifier,
+		signerClient:         signerClient,
+		musig2ServerSign:     musig2ServerSigner,
+		VerifySchnorrSig:     verifySchnorrSig,
+		chainParams:          chainparams,
+		store:                store,
+		sweepStore:           sweepStore,
+		clock:                cfg.clock,
+		initialDelayProvider: cfg.initialDelayProvider,
+		publishDelay:         cfg.publishDelay,
+		customFeeRate:        cfg.customFeeRate,
+		txLabeler:            cfg.txLabeler,
+		customMuSig2Signer:   cfg.customMuSig2Signer,
+		publishErrorHandler:  cfg.publishErrorHandler,
 	}
 }
 
@@ -746,11 +762,10 @@ func (b *Batcher) spinUpBatch(ctx context.Context) (*batch, error) {
 		cfg.batchPublishDelay = b.publishDelay
 	}
 
-	if b.initialDelay < 0 {
-		return nil, fmt.Errorf("negative initialDelay: %v",
-			b.initialDelay)
+	cfg.initialDelayProvider = b.initialDelayProvider
+	if cfg.initialDelayProvider == nil {
+		cfg.initialDelayProvider = zeroInitialDelay
 	}
-	cfg.initialDelay = b.initialDelay
 
 	batchKit := b.newBatchKit()
 
@@ -844,6 +859,8 @@ func (b *Batcher) spinUpBatchFromDB(ctx context.Context, batch *batch) error {
 	// Note that initialDelay and batchPublishDelay are 0 for batches
 	// recovered from DB so publishing happen in case of a daemon restart
 	// (especially important in case of a crashloop).
+	cfg.initialDelayProvider = zeroInitialDelay
+
 	newBatch, err := NewBatchFromDB(cfg, batchKit)
 	if err != nil {
 		return fmt.Errorf("failed in NewBatchFromDB: %w", err)