multi: retries for register spend and conf

starius · starius · commit 2108dddba3bf · 2025-11-07T13:29:31.000-03:00
diff --git a/instantout/actions.go b/instantout/actions.go
@@ -16,6 +16,7 @@ import (
 	"github.com/lightninglabs/loop/loopdb"
 	"github.com/lightninglabs/loop/swap"
 	"github.com/lightninglabs/loop/swapserverrpc"
+	"github.com/lightninglabs/loop/utils"
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
 	"github.com/lightningnetwork/lnd/lntypes"
@@ -460,11 +461,10 @@ func (f *FSM) WaitForSweeplessSweepConfirmedAction(ctx context.Context,
 		return f.HandleError(err)
 	}
 
-	confChan, confErrChan, err := f.cfg.ChainNotifier.
-		RegisterConfirmationsNtfn(
-			ctx, f.InstantOut.SweepTxHash, pkscript,
-			1, f.InstantOut.initiationHeight,
-		)
+	confChan, confErrChan, err := utils.RegisterConfirmationsNtfnWithRetry(
+		ctx, f.cfg.ChainNotifier, f.InstantOut.SweepTxHash, pkscript,
+		1, f.InstantOut.initiationHeight,
+	)
 	if err != nil {
 		return f.HandleError(err)
 	}
@@ -505,12 +505,11 @@ func (f *FSM) PublishHtlcAction(ctx context.Context,
 	f.Debugf("published htlc tx: %v", txHash)
 
 	// We'll now wait for the htlc to be confirmed.
-	confChan, confErrChan, err := f.cfg.ChainNotifier.
-		RegisterConfirmationsNtfn(
-			ctx, &txHash,
-			f.InstantOut.finalizedHtlcTx.TxOut[0].PkScript,
-			1, f.InstantOut.initiationHeight,
-		)
+	confChan, confErrChan, err := utils.RegisterConfirmationsNtfnWithRetry(
+		ctx, f.cfg.ChainNotifier, &txHash,
+		f.InstantOut.finalizedHtlcTx.TxOut[0].PkScript,
+		1, f.InstantOut.initiationHeight,
+	)
 	if err != nil {
 		return f.HandleError(err)
 	}
@@ -575,9 +574,9 @@ func (f *FSM) WaitForHtlcSweepConfirmedAction(ctx context.Context,
 		return f.HandleError(err)
 	}
 
-	confChan, confErrChan, err := f.cfg.ChainNotifier.RegisterConfirmationsNtfn(
-		ctx, f.InstantOut.SweepTxHash, sweepPkScript,
-		1, f.InstantOut.initiationHeight,
+	confChan, confErrChan, err := utils.RegisterConfirmationsNtfnWithRetry(
+		ctx, f.cfg.ChainNotifier, f.InstantOut.SweepTxHash,
+		sweepPkScript, 1, f.InstantOut.initiationHeight,
 	)
 	if err != nil {
 		return f.HandleError(err)
diff --git a/instantout/reservation/actions.go b/instantout/reservation/actions.go
@@ -95,9 +95,9 @@ func (f *FSM) SubscribeToConfirmationAction(ctx context.Context,
 		"initiation height: %v", f.reservation.ID, pkscript,
 		f.reservation.InitiationHeight)
 
-	confChan, errConfChan, err := f.cfg.ChainNotifier.RegisterConfirmationsNtfn(
-		callCtx, nil, pkscript, DefaultConfTarget,
-		f.reservation.InitiationHeight,
+	confChan, errConfChan, err := utils.RegisterConfirmationsNtfnWithRetry(
+		callCtx, f.cfg.ChainNotifier, nil, pkscript,
+		DefaultConfTarget, f.reservation.InitiationHeight,
 	)
 	if err != nil {
 		f.Errorf("unable to subscribe to conf notification: %v", err)
@@ -173,8 +173,8 @@ func (f *FSM) AsyncWaitForExpiredOrSweptAction(ctx context.Context,
 		return f.HandleError(err)
 	}
 
-	spendChan, errSpendChan, err := f.cfg.ChainNotifier.RegisterSpendNtfn(
-		notifCtx, f.reservation.Outpoint, pkScript,
+	spendChan, errSpendChan, err := utils.RegisterSpendNtfnWithRetry(
+		notifCtx, f.cfg.ChainNotifier, f.reservation.Outpoint, pkScript,
 		f.reservation.InitiationHeight,
 	)
 	if err != nil {
diff --git a/loopin.go b/loopin.go
@@ -702,8 +702,9 @@ func (s *loopInSwap) waitForHtlcConf(globalCtx context.Context) (
 			return nil, nil, nil
 		}
 
-		return notifier.RegisterConfirmationsNtfn(
-			ctx, s.htlcTxHash, htlc.PkScript, 1, s.InitiationHeight,
+		return utils.RegisterConfirmationsNtfnWithRetry(
+			ctx, notifier, s.htlcTxHash, htlc.PkScript, 1,
+			s.InitiationHeight,
 		)
 	}
 
@@ -867,8 +868,9 @@ func (s *loopInSwap) waitForSwapComplete(ctx context.Context,
 	// Register the htlc spend notification.
 	rpcCtx, cancel := context.WithCancel(ctx)
 	defer cancel()
-	spendChan, spendErr, err := s.lnd.ChainNotifier.RegisterSpendNtfn(
-		rpcCtx, htlcOutpoint, s.htlc.PkScript, s.InitiationHeight,
+	spendChan, spendErr, err := utils.RegisterSpendNtfnWithRetry(
+		rpcCtx, s.lnd.ChainNotifier, htlcOutpoint, s.htlc.PkScript,
+		s.InitiationHeight,
 	)
 	if err != nil {
 		return fmt.Errorf("register spend ntfn: %v", err)
diff --git a/loopout.go b/loopout.go
@@ -1012,9 +1012,10 @@ func (s *loopOutSwap) waitForConfirmedHtlc(globalCtx context.Context) (
 	ctx, cancel := context.WithCancel(globalCtx)
 	defer cancel()
 	htlcConfChan, htlcErrChan, err :=
-		s.lnd.ChainNotifier.RegisterConfirmationsNtfn(
-			ctx, s.htlcTxHash, s.htlc.PkScript,
-			int32(s.HtlcConfirmations), s.InitiationHeight,
+		utils.RegisterConfirmationsNtfnWithRetry(
+			ctx, s.lnd.ChainNotifier, s.htlcTxHash,
+			s.htlc.PkScript, int32(s.HtlcConfirmations),
+			s.InitiationHeight,
 		)
 	if err != nil {
 		return nil, err
diff --git a/staticaddr/deposit/actions.go b/staticaddr/deposit/actions.go
@@ -11,6 +11,7 @@ import (
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/loop/fsm"
 	"github.com/lightninglabs/loop/staticaddr/script"
+	"github.com/lightninglabs/loop/utils"
 	"github.com/lightningnetwork/lnd/lntypes"
 )
 
@@ -123,8 +124,9 @@ func (f *FSM) WaitForExpirySweepAction(ctx context.Context,
 		txID = &f.deposit.ExpirySweepTxid
 	}
 
-	spendChan, errSpendChan, err := f.cfg.ChainNotifier.RegisterConfirmationsNtfn( //nolint:lll
-		ctx, txID, f.deposit.TimeOutSweepPkScript, DefaultConfTarget,
+	spendChan, errSpendChan, err := utils.RegisterConfirmationsNtfnWithRetry( //nolint:lll
+		ctx, f.cfg.ChainNotifier, txID,
+		f.deposit.TimeOutSweepPkScript, DefaultConfTarget,
 		int32(f.deposit.ConfirmationHeight),
 	)
 	if err != nil {
diff --git a/staticaddr/deposit/manager.go b/staticaddr/deposit/manager.go
@@ -330,9 +330,10 @@ func (m *Manager) getBlockHeight(ctx context.Context,
 	}
 
 	notifChan, errChan, err :=
-		m.cfg.ChainNotifier.RegisterConfirmationsNtfn(
-			ctx, &utxo.OutPoint.Hash, addressParams.PkScript,
-			MinConfs, addressParams.InitiationHeight,
+		utils.RegisterConfirmationsNtfnWithRetry(
+			ctx, m.cfg.ChainNotifier, &utxo.OutPoint.Hash,
+			addressParams.PkScript, MinConfs,
+			addressParams.InitiationHeight,
 		)
 	if err != nil {
 		return 0, err
diff --git a/staticaddr/loopin/actions.go b/staticaddr/loopin/actions.go
@@ -482,9 +482,9 @@ func (f *FSM) MonitorInvoiceAndHtlcTxAction(ctx context.Context,
 	registerHtlcConf := func() (chan *chainntnfs.TxConfirmation, chan error,
 		error) {
 
-		return f.cfg.ChainNotifier.RegisterConfirmationsNtfn(
-			ctx, nil, htlc.PkScript, defaultConfTarget,
-			int32(f.loopIn.InitiationHeight),
+		return utils.RegisterConfirmationsNtfnWithRetry(
+			ctx, f.cfg.ChainNotifier, nil, htlc.PkScript,
+			defaultConfTarget, int32(f.loopIn.InitiationHeight),
 			lndclient.WithReOrgChan(reorgChan),
 		)
 	}
@@ -732,8 +732,8 @@ func (f *FSM) MonitorHtlcTimeoutSweepAction(ctx context.Context,
 	}
 
 	htlcTimeoutTxidChan, errChan, err :=
-		f.cfg.ChainNotifier.RegisterConfirmationsNtfn(
-			ctx, f.loopIn.HtlcTimeoutSweepTxHash,
+		utils.RegisterConfirmationsNtfnWithRetry(
+			ctx, f.cfg.ChainNotifier, f.loopIn.HtlcTimeoutSweepTxHash,
 			timeoutSweepPkScript, defaultConfTarget,
 			int32(f.loopIn.InitiationHeight),
 		)
diff --git a/staticaddr/withdraw/manager.go b/staticaddr/withdraw/manager.go
@@ -640,8 +640,8 @@ func (m *Manager) handleWithdrawal(ctx context.Context,
 	}
 
 	d := deposits[0]
-	spentChan, errChan, err := m.cfg.ChainNotifier.RegisterSpendNtfn(
-		ctx, &d.OutPoint, addrParams.PkScript,
+	spentChan, errChan, err := utils.RegisterSpendNtfnWithRetry(
+		ctx, m.cfg.ChainNotifier, &d.OutPoint, addrParams.PkScript,
 		int32(d.ConfirmationHeight),
 	)
 
@@ -654,8 +654,9 @@ func (m *Manager) handleWithdrawal(ctx context.Context,
 			// confirmations.
 			var confChan chan *chainntnfs.TxConfirmation
 			confChan, errChan, err =
-				m.cfg.ChainNotifier.RegisterConfirmationsNtfn(
-					ctx, spentTx.SpenderTxHash,
+				utils.RegisterConfirmationsNtfnWithRetry(
+					ctx, m.cfg.ChainNotifier,
+					spentTx.SpenderTxHash,
 					withdrawalPkscript, MinConfs,
 					int32(m.initiationHeight.Load()),
 				)
diff --git a/sweepbatcher/sweep_batch.go b/sweepbatcher/sweep_batch.go
@@ -1996,9 +1996,9 @@ func (b *batch) monitorSpend(ctx context.Context, primarySweep sweep) error {
 
 	reorgChan := make(chan struct{}, 1)
 
-	spendChan, spendErrChan, err := b.chainNotifier.RegisterSpendNtfn(
-		ctx, &primarySweep.outpoint, primarySweep.htlc.PkScript,
-		primarySweep.initiationHeight,
+	spendChan, spendErrChan, err := utils.RegisterSpendNtfnWithRetry(
+		ctx, b.chainNotifier, &primarySweep.outpoint,
+		primarySweep.htlc.PkScript, primarySweep.initiationHeight,
 		lndclient.WithReOrgChan(reorgChan),
 	)
 	if err != nil {
@@ -2030,9 +2030,9 @@ func (b *batch) monitorConfirmations(ctx context.Context) error {
 
 	confCtx, cancel := context.WithCancel(ctx)
 
-	confChan, errChan, err := b.chainNotifier.RegisterConfirmationsNtfn(
-		confCtx, b.batchTxid, b.batchPkScript, batchConfHeight,
-		primarySweep.initiationHeight,
+	confChan, errChan, err := utils.RegisterConfirmationsNtfnWithRetry(
+		confCtx, b.chainNotifier, b.batchTxid, b.batchPkScript,
+		batchConfHeight, primarySweep.initiationHeight,
 	)
 	if err != nil {
 		cancel()
diff --git a/sweepbatcher/sweep_batcher.go b/sweepbatcher/sweep_batcher.go
@@ -1284,8 +1284,8 @@ func (b *Batcher) monitorSpendAndNotify(ctx context.Context, sweeps []*sweep,
 
 	sweep := sweeps[0]
 
-	spendChan, spendErr, err := b.chainNotifier.RegisterSpendNtfn(
-		spendCtx, &sweep.outpoint, sweep.htlc.PkScript,
+	spendChan, spendErr, err := utils.RegisterSpendNtfnWithRetry(
+		spendCtx, b.chainNotifier, &sweep.outpoint, sweep.htlc.PkScript,
 		sweep.initiationHeight,
 	)
 	if err != nil {
@@ -1412,9 +1412,10 @@ func (b *Batcher) monitorConfAndNotify(ctx context.Context, sweep *sweep,
 
 	confCtx, cancel := context.WithCancel(ctx)
 
-	confChan, errChan, err := b.chainNotifier.RegisterConfirmationsNtfn(
-		confCtx, &batchTxid, batchPkScript, batchConfHeight,
-		sweep.initiationHeight, lndclient.WithReOrgChan(reorgChan),
+	confChan, errChan, err := utils.RegisterConfirmationsNtfnWithRetry(
+		confCtx, b.chainNotifier, &batchTxid, batchPkScript,
+		batchConfHeight, sweep.initiationHeight,
+		lndclient.WithReOrgChan(reorgChan),
 	)
 	if err != nil {
 		cancel()
diff --git a/utils/chainnotifier.go b/utils/chainnotifier.go
@@ -5,6 +5,10 @@ import (
 	"strings"
 	"time"
 
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightninglabs/lndclient"
+	"github.com/lightningnetwork/lnd/chainntnfs"
 	"google.golang.org/grpc/status"
 )
 
@@ -26,6 +30,23 @@ type BlockEpochRegistrar interface {
 		error)
 }
 
+// ConfirmationsRegistrar represents the ability to subscribe to confirmation
+// notifications.
+type ConfirmationsRegistrar interface {
+	RegisterConfirmationsNtfn(ctx context.Context, txid *chainhash.Hash,
+		pkScript []byte, numConfs, heightHint int32,
+		opts ...lndclient.NotifierOption) (chan *chainntnfs.TxConfirmation,
+		chan error, error)
+}
+
+// SpendRegistrar represents the ability to subscribe to spend notifications.
+type SpendRegistrar interface {
+	RegisterSpendNtfn(ctx context.Context,
+		outpoint *wire.OutPoint, pkScript []byte, heightHint int32,
+		optFuncs ...lndclient.NotifierOption) (chan *chainntnfs.SpendDetail,
+		chan error, error)
+}
+
 // RegisterBlockEpochNtfnWithRetry keeps retrying block epoch subscriptions as
 // long as lnd reports that the chain notifier sub-server is still starting.
 func RegisterBlockEpochNtfnWithRetry(ctx context.Context,
@@ -54,6 +75,70 @@ func RegisterBlockEpochNtfnWithRetry(ctx context.Context,
 	}
 }
 
+// RegisterConfirmationsNtfnWithRetry keeps retrying confirmation subscriptions
+// while lnd reports that the chain notifier sub-server is still starting.
+func RegisterConfirmationsNtfnWithRetry(ctx context.Context,
+	registrar ConfirmationsRegistrar, txid *chainhash.Hash, pkScript []byte,
+	numConfs, heightHint int32, opts ...lndclient.NotifierOption) (
+	chan *chainntnfs.TxConfirmation, chan error, error) {
+
+	for {
+		confChan, errChan, err := registrar.RegisterConfirmationsNtfn(
+			ctx, txid, pkScript, numConfs, heightHint, opts...,
+		)
+		if err == nil {
+			return confChan, errChan, nil
+		}
+
+		if !isChainNotifierStartingErr(err) {
+			return nil, nil, err
+		}
+
+		log.Warnf("Chain notifier RPC not ready yet, retrying: %v",
+			err)
+
+		select {
+		case <-time.After(chainNotifierRetryBackoff):
+			continue
+
+		case <-ctx.Done():
+			return nil, nil, ctx.Err()
+		}
+	}
+}
+
+// RegisterSpendNtfnWithRetry keeps retrying spend subscriptions while lnd
+// reports that the chain notifier sub-server is still starting.
+func RegisterSpendNtfnWithRetry(ctx context.Context,
+	registrar SpendRegistrar, outpoint *wire.OutPoint, pkScript []byte,
+	heightHint int32, optFuncs ...lndclient.NotifierOption) (
+	chan *chainntnfs.SpendDetail, chan error, error) {
+
+	for {
+		spendChan, errChan, err := registrar.RegisterSpendNtfn(
+			ctx, outpoint, pkScript, heightHint, optFuncs...,
+		)
+		if err == nil {
+			return spendChan, errChan, nil
+		}
+
+		if !isChainNotifierStartingErr(err) {
+			return nil, nil, err
+		}
+
+		log.Warnf("Chain notifier RPC not ready yet, retrying: %v",
+			err)
+
+		select {
+		case <-time.After(chainNotifierRetryBackoff):
+			continue
+
+		case <-ctx.Done():
+			return nil, nil, ctx.Err()
+		}
+	}
+}
+
 // isChainNotifierStartingErr checks whether an error indicates that lnd's chain
 // notifier has not started yet.
 func isChainNotifierStartingErr(err error) bool {
diff --git a/utils/chainnotifier_test.go b/utils/chainnotifier_test.go

Original file line number	Diff line number	Diff line change
`@@ -702,8 +702,9 @@ func (s *loopInSwap) waitForHtlcConf(globalCtx context.Context) (`
`702`	`702`	`return nil, nil, nil`
`703`	`703`	`}`
`704`	`704`
`705`		`- return notifier.RegisterConfirmationsNtfn(`
`706`		`- ctx, s.htlcTxHash, htlc.PkScript, 1, s.InitiationHeight,`
	`705`	`+ return utils.RegisterConfirmationsNtfnWithRetry(`
	`706`	`+ ctx, notifier, s.htlcTxHash, htlc.PkScript, 1,`
	`707`	`+ s.InitiationHeight,`
`707`	`708`	`)`
`708`	`709`	`}`
`709`	`710`
`@@ -867,8 +868,9 @@ func (s *loopInSwap) waitForSwapComplete(ctx context.Context,`
`867`	`868`	`// Register the htlc spend notification.`
`868`	`869`	`rpcCtx, cancel := context.WithCancel(ctx)`
`869`	`870`	`defer cancel()`
`870`		`- spendChan, spendErr, err := s.lnd.ChainNotifier.RegisterSpendNtfn(`
`871`		`- rpcCtx, htlcOutpoint, s.htlc.PkScript, s.InitiationHeight,`
	`871`	`+ spendChan, spendErr, err := utils.RegisterSpendNtfnWithRetry(`
	`872`	`+ rpcCtx, s.lnd.ChainNotifier, htlcOutpoint, s.htlc.PkScript,`
	`873`	`+ s.InitiationHeight,`
`872`	`874`	`)`
`873`	`875`	`if err != nil {`
`874`	`876`	`return fmt.Errorf("register spend ntfn: %v", err)`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ import (`
`11`	`11`	`"github.com/lightninglabs/lndclient"`
`12`	`12`	`"github.com/lightninglabs/loop/fsm"`
`13`	`13`	`"github.com/lightninglabs/loop/staticaddr/script"`
	`14`	`+ "github.com/lightninglabs/loop/utils"`
`14`	`15`	`"github.com/lightningnetwork/lnd/lntypes"`
`15`	`16`	`)`
`16`	`17`
`@@ -123,8 +124,9 @@ func (f *FSM) WaitForExpirySweepAction(ctx context.Context,`
`123`	`124`	`txID = &f.deposit.ExpirySweepTxid`
`124`	`125`	`}`
`125`	`126`
`126`		`- spendChan, errSpendChan, err := f.cfg.ChainNotifier.RegisterConfirmationsNtfn( //nolint:lll`
`127`		`- ctx, txID, f.deposit.TimeOutSweepPkScript, DefaultConfTarget,`
	`127`	`+ spendChan, errSpendChan, err := utils.RegisterConfirmationsNtfnWithRetry( //nolint:lll`
	`128`	`+ ctx, f.cfg.ChainNotifier, txID,`
	`129`	`+ f.deposit.TimeOutSweepPkScript, DefaultConfTarget,`
`128`	`130`	`int32(f.deposit.ConfirmationHeight),`
`129`	`131`	`)`
`130`	`132`	`if err != nil {`
Original file line number	Diff line number	Diff line change
`@@ -330,9 +330,10 @@ func (m *Manager) getBlockHeight(ctx context.Context,`
`330`	`330`	`}`
`331`	`331`
`332`	`332`	`notifChan, errChan, err :=`
`333`		`- m.cfg.ChainNotifier.RegisterConfirmationsNtfn(`
`334`		`- ctx, &utxo.OutPoint.Hash, addressParams.PkScript,`
`335`		`- MinConfs, addressParams.InitiationHeight,`
	`333`	`+ utils.RegisterConfirmationsNtfnWithRetry(`
	`334`	`+ ctx, m.cfg.ChainNotifier, &utxo.OutPoint.Hash,`
	`335`	`+ addressParams.PkScript, MinConfs,`
	`336`	`+ addressParams.InitiationHeight,`
`336`	`337`	`)`
`337`	`338`	`if err != nil {`
`338`	`339`	`return 0, err`
Original file line number	Diff line number	Diff line change
`@@ -482,9 +482,9 @@ func (f *FSM) MonitorInvoiceAndHtlcTxAction(ctx context.Context,`
`482`	`482`	`registerHtlcConf := func() (chan *chainntnfs.TxConfirmation, chan error,`
`483`	`483`	`error) {`
`484`	`484`
`485`		`- return f.cfg.ChainNotifier.RegisterConfirmationsNtfn(`
`486`		`- ctx, nil, htlc.PkScript, defaultConfTarget,`
`487`		`- int32(f.loopIn.InitiationHeight),`
	`485`	`+ return utils.RegisterConfirmationsNtfnWithRetry(`
	`486`	`+ ctx, f.cfg.ChainNotifier, nil, htlc.PkScript,`
	`487`	`+ defaultConfTarget, int32(f.loopIn.InitiationHeight),`
`488`	`488`	`lndclient.WithReOrgChan(reorgChan),`
`489`	`489`	`)`
`490`	`490`	`}`
`@@ -732,8 +732,8 @@ func (f *FSM) MonitorHtlcTimeoutSweepAction(ctx context.Context,`
`732`	`732`	`}`
`733`	`733`
`734`	`734`	`htlcTimeoutTxidChan, errChan, err :=`
`735`		`- f.cfg.ChainNotifier.RegisterConfirmationsNtfn(`
`736`		`- ctx, f.loopIn.HtlcTimeoutSweepTxHash,`
	`735`	`+ utils.RegisterConfirmationsNtfnWithRetry(`
	`736`	`+ ctx, f.cfg.ChainNotifier, f.loopIn.HtlcTimeoutSweepTxHash,`
`737`	`737`	`timeoutSweepPkScript, defaultConfTarget,`
`738`	`738`	`int32(f.loopIn.InitiationHeight),`
`739`	`739`	`)`