staticaddr: fetch deposits as part of swap retrieval

since deposits have been normalized in the db in the
context of a static address swap this commit now
retrieves the deposit information as part of
GetLoopInByHash and GetStaticAddressLoopInSwapsByStates.

Author: hieblmi

staticaddr/loopin/sql_store.go

@@ -83,6 +83,10 @@ type Querier interface {
 	// hash.
 	DepositIDsForSwapHash(ctx context.Context,
 		swapHash []byte) ([][]byte, error)
+
+	// DepositsForSwapHash retrieves all deposits for a given swap hash.
+	DepositsForSwapHash(ctx context.Context,
+		swapHash []byte) ([]sqlc.DepositsForSwapHashRow, error)
 }
 
 // BaseDB is the interface that contains all the queries generated by sqlc for
@@ -121,10 +125,15 @@ func (s *SqlStore) GetLoopInByHash(ctx context.Context,
 
 	var (
 		err     error
-		row     sqlc.GetStaticAddressLoopInSwapRow
+		swap    sqlc.GetStaticAddressLoopInSwapRow
 		updates []sqlc.StaticAddressSwapUpdate
 	)
-	row, err = s.baseDB.GetStaticAddressLoopInSwap(ctx, swapHash[:])
+	swap, err = s.baseDB.GetStaticAddressLoopInSwap(ctx, swapHash[:])
+	if err != nil {
+		return nil, err
+	}
+
+	deposits, err := s.baseDB.DepositsForSwapHash(ctx, swapHash[:])
 	if err != nil {
 		return nil, err
 	}
@@ -134,9 +143,7 @@ func (s *SqlStore) GetLoopInByHash(ctx context.Context,
 		return nil, err
 	}
 
-	return toStaticAddressLoopIn(
-		ctx, s.network, row, updates,
-	)
+	return toStaticAddressLoopIn(ctx, s.network, swap, deposits, updates)
 }
 
 // GetStaticAddressLoopInSwapsByStates returns all static address loop-ins from
@@ -164,6 +171,11 @@ func (s *SqlStore) GetStaticAddressLoopInSwapsByStates(ctx context.Context,
 
 	loopIns := make([]*StaticAddressLoopIn, 0, len(rows))
 	for _, row := range rows {
+		deposits, err := s.baseDB.DepositsForSwapHash(ctx, row.SwapHash)
+		if err != nil {
+			return nil, err
+		}
+
 		updates, err = s.baseDB.GetLoopInSwapUpdates(
 			ctx, row.SwapHash,
 		)
@@ -173,7 +185,7 @@ func (s *SqlStore) GetStaticAddressLoopInSwapsByStates(ctx context.Context,
 
 		loopIn, err = toStaticAddressLoopIn(
 			ctx, s.network, sqlc.GetStaticAddressLoopInSwapRow(row),
-			updates,
+			deposits, updates,
 		)
 		if err != nil {
 			return nil, err
@@ -205,6 +217,14 @@ func toStrings(states []fsm.StateType) []string {
 func (s *SqlStore) CreateLoopIn(ctx context.Context,
 	loopIn *StaticAddressLoopIn) error {
 
+	if loopIn == nil {
+		return errors.New("loop-in cannot be nil")
+	}
+
+	if len(loopIn.Deposits) == 0 {
+		return errors.New("loop-in must have at least one deposit")
+	}
+
 	swapArgs := sqlc.InsertSwapParams{
 		SwapHash:         loopIn.SwapHash[:],
 		Preimage:         loopIn.SwapPreimage[:],
@@ -273,8 +293,24 @@ func (s *SqlStore) CreateLoopIn(ctx context.Context,
 				return err
 			}
 
+			// Map each deposit to the swap hash in the
+			// deposit_to_swap table. This allows us to track which
+			// deposits are used for which swaps.
+			for _, d := range loopIn.Deposits {
+				err = q.MapDepositToSwap(
+					ctx, sqlc.MapDepositToSwapParams{
+						DepositID: d.ID[:],
+						SwapHash:  loopIn.SwapHash[:],
+					},
+				)
+				if err != nil {
+					return err
+				}
+			}
+
 			return q.InsertStaticAddressMetaUpdate(ctx, updateArgs)
-		})
+		},
+	)
 }
 
 // UpdateLoopIn updates the loop-in in the database.
@@ -412,44 +448,45 @@ func (s *SqlStore) DepositIDsForSwapHash(ctx context.Context,
 
 // toStaticAddressLoopIn converts sql rows to an instant out struct.
 func toStaticAddressLoopIn(_ context.Context, network *chaincfg.Params,
-	row sqlc.GetStaticAddressLoopInSwapRow,
+	swap sqlc.GetStaticAddressLoopInSwapRow,
+	deposits []sqlc.DepositsForSwapHashRow,
 	updates []sqlc.StaticAddressSwapUpdate) (*StaticAddressLoopIn, error) {
 
-	swapHash, err := lntypes.MakeHash(row.SwapHash)
+	swapHash, err := lntypes.MakeHash(swap.SwapHash)
 	if err != nil {
 		return nil, err
 	}
 
-	swapPreImage, err := lntypes.MakePreimage(row.Preimage)
+	swapPreImage, err := lntypes.MakePreimage(swap.Preimage)
 	if err != nil {
 		return nil, err
 	}
 
-	clientKey, err := btcec.ParsePubKey(row.SenderScriptPubkey)
+	clientKey, err := btcec.ParsePubKey(swap.SenderScriptPubkey)
 	if err != nil {
 		return nil, err
 	}
 
-	serverKey, err := btcec.ParsePubKey(row.ReceiverScriptPubkey)
+	serverKey, err := btcec.ParsePubKey(swap.ReceiverScriptPubkey)
 	if err != nil {
 		return nil, err
 	}
 
 	var htlcTimeoutSweepTxHash *chainhash.Hash
-	if row.HtlcTimeoutSweepTxID.Valid {
+	if swap.HtlcTimeoutSweepTxID.Valid {
 		htlcTimeoutSweepTxHash, err = chainhash.NewHashFromStr(
-			row.HtlcTimeoutSweepTxID.String,
+			swap.HtlcTimeoutSweepTxID.String,
 		)
 		if err != nil {
 			return nil, err
 		}
 	}
 
 	depositOutpoints := strings.Split(
-		row.DepositOutpoints, outpointSeparator,
+		swap.DepositOutpoints, outpointSeparator,
 	)
 
-	timeoutAddressString := row.HtlcTimeoutSweepAddress
+	timeoutAddressString := swap.HtlcTimeoutSweepAddress
 	var timeoutAddress btcutil.Address
 	if timeoutAddressString != "" {
 		timeoutAddress, err = btcutil.DecodeAddress(
@@ -460,33 +497,68 @@ func toStaticAddressLoopIn(_ context.Context, network *chaincfg.Params,
 		}
 	}
 
+	depositList := make([]*deposit.Deposit, 0, len(deposits))
+	for _, d := range deposits {
+		id := deposit.ID{}
+		err = id.FromByteSlice(d.DepositID)
+		if err != nil {
+			return nil, err
+		}
+
+		sqlcDeposit := sqlc.Deposit{
+			DepositID:             id[:],
+			TxHash:                d.TxHash,
+			Amount:                d.Amount,
+			OutIndex:              d.OutIndex,
+			ConfirmationHeight:    d.ConfirmationHeight,
+			TimeoutSweepPkScript:  d.TimeoutSweepPkScript,
+			ExpirySweepTxid:       d.ExpirySweepTxid,
+			FinalizedWithdrawalTx: d.FinalizedWithdrawalTx,
+		}
+
+		sqlcDepositUpdate := sqlc.DepositUpdate{
+			DepositID:       id[:],
+			UpdateState:     d.UpdateState.String,
+			UpdateTimestamp: d.UpdateTimestamp.Time,
+		}
+		deposit, err := deposit.ToDeposit(
+			sqlcDeposit, sqlcDepositUpdate,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		depositList = append(depositList, deposit)
+	}
+
 	loopIn := &StaticAddressLoopIn{
 		SwapHash:         swapHash,
 		SwapPreimage:     swapPreImage,
-		HtlcCltvExpiry:   row.CltvExpiry,
-		MaxSwapFee:       btcutil.Amount(row.MaxSwapFee),
-		InitiationHeight: uint32(row.InitiationHeight),
-		InitiationTime:   row.InitiationTime,
+		HtlcCltvExpiry:   swap.CltvExpiry,
+		MaxSwapFee:       btcutil.Amount(swap.MaxSwapFee),
+		InitiationHeight: uint32(swap.InitiationHeight),
+		InitiationTime:   swap.InitiationTime,
 		ProtocolVersion: version.AddressProtocolVersion(
-			row.ProtocolVersion,
+			swap.ProtocolVersion,
 		),
-		Label:        row.Label,
+		Label:        swap.Label,
 		ClientPubkey: clientKey,
 		ServerPubkey: serverKey,
 		HtlcKeyLocator: keychain.KeyLocator{
-			Family: keychain.KeyFamily(row.ClientKeyFamily),
-			Index:  uint32(row.ClientKeyIndex),
+			Family: keychain.KeyFamily(swap.ClientKeyFamily),
+			Index:  uint32(swap.ClientKeyIndex),
 		},
-		SwapInvoice:           row.SwapInvoice,
-		PaymentTimeoutSeconds: uint32(row.PaymentTimeoutSeconds),
-		LastHop:               row.LastHop,
-		QuotedSwapFee:         btcutil.Amount(row.QuotedSwapFeeSatoshis),
+		SwapInvoice:           swap.SwapInvoice,
+		PaymentTimeoutSeconds: uint32(swap.PaymentTimeoutSeconds),
+		LastHop:               swap.LastHop,
+		QuotedSwapFee:         btcutil.Amount(swap.QuotedSwapFeeSatoshis),
 		DepositOutpoints:      depositOutpoints,
 		HtlcTxFeeRate: chainfee.SatPerKWeight(
-			row.HtlcTxFeeRateSatKw,
+			swap.HtlcTxFeeRateSatKw,
 		),
 		HtlcTimeoutSweepAddress: timeoutAddress,
 		HtlcTimeoutSweepTxHash:  htlcTimeoutSweepTxHash,
+		Deposits:                depositList,
 	}
 
 	if len(updates) > 0 {