wip with sub manager

Author: sputn1ck

hyperloop/actions.go

@@ -13,9 +13,9 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/loop/fsm"
-	"github.com/lightninglabs/loop/loopdb"
 	"github.com/lightninglabs/loop/swap"
 	looprpc "github.com/lightninglabs/loop/swapserverrpc"
+	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
@@ -36,11 +36,10 @@ var (
 
 // initHyperloopContext contains the request parameters for a hyperloop.
 type initHyperloopContext struct {
-	hyperloopID     ID
-	swapAmt         btcutil.Amount
-	outgoingChanSet *loopdb.ChannelSet
-	publishTime     time.Time
-	sweepAddr       btcutil.Address
+	hyperloopID ID
+	swapAmt     btcutil.Amount
+	publishTime time.Time
+	sweepAddr   btcutil.Address
 }
 
 // initHyperloopAction is the action that initializes the hyperloop.
@@ -340,13 +339,25 @@ func (f *FSM) waitForHtlcSig(ctx context.Context,
 		bool, error) {
 		return res.FinalHtlcSig != nil, nil
 	}
-	res, err := f.waitForState(ctx, checkFunc)
-	if err != nil {
+
+	resChan, errChan := f.waitForStateChan(ctx, checkFunc)
+	var res *looprpc.HyperloopNotificationStreamResponse
+	select {
+	case <-ctx.Done():
+		return fsm.NoOp
+
+	case err := <-errChan:
 		return f.HandleError(err)
+
+	case res = <-resChan:
+
+	// We'll also need to check if the hyperloop has been spent.
+	case spend := <-f.spendChan:
+		return f.getHyperloopSpendingEvent(spend)
 	}
 
 	// Try to register the htlc sig, this will verify the sig is valid.
-	err = f.hyperloop.registerHtlcSig(f.cfg.ChainParams, res.FinalHtlcSig)
+	err := f.hyperloop.registerHtlcSig(f.cfg.ChainParams, res.FinalHtlcSig)
 	if err != nil {
 		return f.HandleError(err)
 	}
@@ -390,9 +401,22 @@ func (f *FSM) waitForReadyForSweepAction(ctx context.Context,
 		bool, error) {
 		return len(res.Participants) == len(res.SweeplessSweepNonces), nil
 	}
-	res, err := f.waitForState(ctx, checkFunc)
-	if err != nil {
+
+	resChan, errChan := f.waitForStateChan(ctx, checkFunc)
+	var res *looprpc.HyperloopNotificationStreamResponse
+
+	select {
+	case <-ctx.Done():
+		return fsm.NoOp
+
+	case err := <-errChan:
 		return f.HandleError(err)
+
+	case res = <-resChan:
+
+	// We'll also need to check if the hyperloop has been spent.
+	case spend := <-f.spendChan:
+		return f.getHyperloopSpendingEvent(spend)
 	}
 
 	var nonces [][66]byte
@@ -404,7 +428,7 @@ func (f *FSM) waitForReadyForSweepAction(ctx context.Context,
 		nonces = append(nonces, nonce)
 	}
 
-	err = f.hyperloop.registerSweeplessSweepNonces(ctx, f.cfg.Signer, nonces)
+	err := f.hyperloop.registerSweeplessSweepNonces(ctx, f.cfg.Signer, nonces)
 	if err != nil {
 		return f.HandleError(err)
 	}
@@ -442,6 +466,18 @@ func (f *FSM) pushSweepSigAction(ctx context.Context,
 	return OnPushedSweeplessSweepSig
 }
 
+func (f *FSM) waitForSweepPublishAction(ctx context.Context,
+	_ fsm.EventContext) fsm.EventType {
+
+	select {
+	case <-ctx.Done():
+		return fsm.NoOp
+
+	case spend := <-f.spendChan:
+		return f.getHyperloopSpendingEvent(spend)
+	}
+}
+
 // waitForSweeplessSweepConfirmationAction is the action that waits for the
 // sweepless sweep to be confirmed.
 func (f *FSM) waitForSweeplessSweepConfirmationAction(ctx context.Context,
@@ -621,3 +657,35 @@ func rpcParticipantToHyperloopParticipant(rpcParticipant []*looprpc.
 
 	return participants, nil
 }
+
+// getHyperloopSpendingEvent returns the event that should be triggered when the
+// hyperloop output is spent. It returns an error if the spending transaction is
+// unexpected.
+func (f *FSM) getHyperloopSpendingEvent(spendDetails *chainntnfs.SpendDetail,
+) fsm.EventType {
+
+	spendingTxHash := spendDetails.SpendingTx.TxHash()
+
+	htlcTx, err := f.hyperloop.getHyperLoopHtlcTx(f.cfg.ChainParams)
+	if err != nil {
+		return f.HandleError(err)
+	}
+	htlcTxHash := htlcTx.TxHash()
+
+	if bytes.Equal(spendingTxHash[:], htlcTxHash[:]) {
+		return OnHtlcPublished
+	}
+
+	sweeplessSweepTx, err := f.hyperloop.getHyperLoopSweeplessSweepTx()
+	if err != nil {
+		return f.HandleError(err)
+	}
+
+	sweeplessSweepTxHash := sweeplessSweepTx.TxHash()
+
+	if bytes.Equal(spendingTxHash[:], sweeplessSweepTxHash[:]) {
+		return OnSweeplessSweepPublish
+	}
+
+	return f.HandleError(errors.New("unexpected tx spent"))
+}