multi: loop in swap

cmd/loopd/daemon.go

@@ -43,11 +43,11 @@ func daemon(config *config) error {
 	// Before starting the client, build an in-memory view of all swaps.
 	// This view is used to update newly connected clients with the most
 	// recent swaps.
-	storedSwaps, err := swapClient.FetchLoopOutSwaps()
+	loopOutSwaps, err := swapClient.FetchLoopOutSwaps()
 	if err != nil {
 		return err
 	}
-	for _, swap := range storedSwaps {
+	for _, swap := range loopOutSwaps {
 		swaps[swap.Hash] = loop.SwapInfo{
 			SwapType:     loop.TypeOut,
 			SwapContract: swap.Contract.SwapContract,
@@ -57,6 +57,20 @@ func daemon(config *config) error {
 		}
 	}
 
+	loopInSwaps, err := swapClient.FetchLoopInSwaps()
+	if err != nil {
+		return err
+	}
+	for _, swap := range loopInSwaps {
+		swaps[swap.Hash] = loop.SwapInfo{
+			SwapType:     loop.TypeIn,
+			SwapContract: swap.Contract.SwapContract,
+			State:        swap.State(),
+			SwapHash:     swap.Hash,
+			LastUpdate:   swap.LastUpdateTime(),
+		}
+	}
+
 	// Instantiate the loopd gRPC server.
 	server := swapClientServer{
 		impl: swapClient,

cmd/loopd/swapclient_server.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"sort"
 
@@ -32,7 +33,7 @@ func (s *swapClientServer) LoopOut(ctx context.Context,
 	in *looprpc.LoopOutRequest) (
 	*looprpc.SwapResponse, error) {
 
-	logger.Infof("LoopOut request received")
+	logger.Infof("Loop out request received")
 
 	var sweepAddr btcutil.Address
 	if in.Dest == "" {
@@ -85,6 +86,8 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
 		state = looprpc.SwapState_INITIATED
 	case loopdb.StatePreimageRevealed:
 		state = looprpc.SwapState_PREIMAGE_REVEALED
+	case loopdb.StateHtlcPublished:
+		state = looprpc.SwapState_HTLC_PUBLISHED
 	case loopdb.StateSuccess:
 		state = looprpc.SwapState_SUCCESS
 	default:
@@ -105,6 +108,16 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
 		return nil, err
 	}
 
+	var swapType looprpc.SwapType
+	switch loopSwap.SwapType {
+	case loop.TypeIn:
+		swapType = looprpc.SwapType_LOOP_IN
+	case loop.TypeOut:
+		swapType = looprpc.SwapType_LOOP_OUT
+	default:
+		return nil, errors.New("unknown swap type")
+	}
+
 	return &looprpc.SwapStatus{
 		Amt:            int64(loopSwap.AmountRequested),
 		Id:             loopSwap.SwapHash.String(),
@@ -112,7 +125,7 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
 		InitiationTime: loopSwap.InitiationTime.UnixNano(),
 		LastUpdateTime: loopSwap.LastUpdate.UnixNano(),
 		HtlcAddress:    address.EncodeAddress(),
-		Type:           looprpc.SwapType_LOOP_OUT,
+		Type:           swapType,
 	}, nil
 }
 
@@ -214,7 +227,7 @@ func (s *swapClientServer) Monitor(in *looprpc.MonitorRequest,
 func (s *swapClientServer) LoopOutTerms(ctx context.Context,
 	req *looprpc.TermsRequest) (*looprpc.TermsResponse, error) {
 
-	logger.Infof("Terms request received")
+	logger.Infof("Loop out terms request received")
 
 	terms, err := s.impl.LoopOutTerms(ctx)
 	if err != nil {
@@ -250,3 +263,69 @@ func (s *swapClientServer) LoopOutQuote(ctx context.Context,
 		SwapFee:   int64(quote.SwapFee),
 	}, nil
 }
+
+// GetTerms returns the terms that the server enforces for swaps.
+func (s *swapClientServer) GetLoopInTerms(ctx context.Context, req *looprpc.TermsRequest) (
+	*looprpc.TermsResponse, error) {
+
+	logger.Infof("Loop in terms request received")
+
+	terms, err := s.impl.LoopInTerms(ctx)
+	if err != nil {
+		logger.Errorf("Terms request: %v", err)
+		return nil, err
+	}
+
+	return &looprpc.TermsResponse{
+		MinSwapAmount: int64(terms.MinSwapAmount),
+		MaxSwapAmount: int64(terms.MaxSwapAmount),
+		SwapFeeBase:   int64(terms.SwapFeeBase),
+		SwapFeeRate:   int64(terms.SwapFeeRate),
+		CltvDelta:     int32(terms.CltvDelta),
+	}, nil
+}
+
+// GetQuote returns a quote for a swap with the provided parameters.
+func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
+	req *looprpc.QuoteRequest) (*looprpc.QuoteResponse, error) {
+
+	logger.Infof("Loop in quote request received")
+
+	quote, err := s.impl.LoopInQuote(ctx, &loop.LoopInQuoteRequest{
+		Amount:         btcutil.Amount(req.Amt),
+		HtlcConfTarget: defaultConfTarget,
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &looprpc.QuoteResponse{
+		MinerFee: int64(quote.MinerFee),
+		SwapFee:  int64(quote.SwapFee),
+	}, nil
+}
+
+func (s *swapClientServer) LoopIn(ctx context.Context,
+	in *looprpc.LoopInRequest) (
+	*looprpc.SwapResponse, error) {
+
+	logger.Infof("Loop in request received")
+
+	req := &loop.LoopInRequest{
+		Amount:         btcutil.Amount(in.Amt),
+		MaxMinerFee:    btcutil.Amount(in.MaxMinerFee),
+		MaxSwapFee:     btcutil.Amount(in.MaxSwapFee),
+		HtlcConfTarget: defaultConfTarget,
+	}
+	if in.LoopInChannel != 0 {
+		req.LoopInChannel = &in.LoopInChannel
+	}
+	hash, err := s.impl.LoopIn(ctx, req)
+	if err != nil {
+		logger.Errorf("Loop in: %v", err)
+		return nil, err
+	}
+
+	return &looprpc.SwapResponse{
+		Id: hash.String(),
+	}, nil
+}