Merge pull request #101 from guggero/lsat-integration

LSAT aware client interceptor

Author: Roasbeef

client.go

@@ -12,6 +12,7 @@ import (
 	"github.com/btcsuite/btcutil"
 	"github.com/lightninglabs/loop/lndclient"
 	"github.com/lightninglabs/loop/loopdb"
+	"github.com/lightninglabs/loop/lsat"
 	"github.com/lightninglabs/loop/swap"
 	"github.com/lightninglabs/loop/sweep"
 	"github.com/lightningnetwork/lnd/lntypes"
@@ -48,8 +49,15 @@ var (
 	ErrSweepConfTargetTooFar = errors.New("sweep confirmation target is " +
 		"beyond swap expiration height")
 
+	// serverRPCTimeout is the maximum time a gRPC request to the server
+	// should be allowed to take.
 	serverRPCTimeout = 30 * time.Second
 
+	// globalCallTimeout is the maximum time any call of the client to the
+	// server is allowed to take, including the time it may take to get
+	// and pay for an LSAT token.
+	globalCallTimeout = serverRPCTimeout + lsat.PaymentTimeout
+
 	republishDelay = 10 * time.Second
 )
 
@@ -71,14 +79,21 @@ type Client struct {
 
 // NewClient returns a new instance to initiate swaps with.
 func NewClient(dbDir string, serverAddress string, insecure bool,
-	lnd *lndclient.LndServices) (*Client, func(), error) {
+	tlsPathServer string, lnd *lndclient.LndServices) (*Client, func(),
+	error) {
 
 	store, err := loopdb.NewBoltSwapStore(dbDir, lnd.ChainParams)
 	if err != nil {
 		return nil, nil, err
 	}
+	lsatStore, err := lsat.NewFileStore(dbDir)
+	if err != nil {
+		return nil, nil, err
+	}
 
-	swapServerClient, err := newSwapServerClient(serverAddress, insecure)
+	swapServerClient, err := newSwapServerClient(
+		serverAddress, insecure, tlsPathServer, lsatStore, lnd,
+	)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -87,6 +102,7 @@ func NewClient(dbDir string, serverAddress string, insecure bool,
 		LndServices: lnd,
 		Server:      swapServerClient,
 		Store:       store,
+		LsatStore:   lsatStore,
 		CreateExpiryTimer: func(d time.Duration) <-chan time.Time {
 			return time.NewTimer(d).C
 		},

cmd/loop/lsat.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/hex"
+	"fmt"
+	"time"
+
+	"github.com/lightninglabs/loop/looprpc"
+	"github.com/lightninglabs/loop/lsat"
+	"github.com/urfave/cli"
+	"gopkg.in/macaroon.v2"
+)
+
+type printableToken struct {
+	ID              string `json:"id"`
+	ValidUntil      string `json:"valid_until"`
+	BaseMacaroon    string `json:"base_macaroon"`
+	PaymentHash     string `json:"payment_hash"`
+	PaymentPreimage string `json:"payment_preimage"`
+	AmountPaid      int64  `json:"amount_paid_msat"`
+	RoutingFeePaid  int64  `json:"routing_fee_paid_msat"`
+	TimeCreated     string `json:"time_created"`
+	Expired         bool   `json:"expired"`
+	FileName        string `json:"file_name"`
+}
+
+var listAuthCommand = cli.Command{
+	Name:        "listauth",
+	Usage:       "list all LSAT tokens",
+	Description: "Shows a list of all LSAT tokens that loopd has paid for",
+	Action:      listAuth,
+}
+
+func listAuth(ctx *cli.Context) error {
+	client, cleanup, err := getClient(ctx)
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	resp, err := client.GetLsatTokens(
+		context.Background(), &looprpc.TokensRequest{},
+	)
+	if err != nil {
+		return err
+	}
+
+	tokens := make([]*printableToken, len(resp.Tokens))
+	for i, t := range resp.Tokens {
+
+		mac := &macaroon.Macaroon{}
+		err := mac.UnmarshalBinary(t.BaseMacaroon)
+		if err != nil {
+			return fmt.Errorf("unable to unmarshal macaroon: %v",
+				err)
+		}
+		id, err := lsat.DecodeIdentifier(bytes.NewReader(mac.Id()))
+		if err != nil {
+			return fmt.Errorf("unable to decode macaroon ID: %v",
+				err)
+		}
+		tokens[i] = &printableToken{
+			ID:              hex.EncodeToString(id.TokenID[:]),
+			ValidUntil:      "",
+			BaseMacaroon:    hex.EncodeToString(t.BaseMacaroon),
+			PaymentHash:     hex.EncodeToString(t.PaymentHash),
+			PaymentPreimage: hex.EncodeToString(t.PaymentPreimage),
+			AmountPaid:      t.AmountPaidMsat,
+			RoutingFeePaid:  t.RoutingFeePaidMsat,
+			TimeCreated: time.Unix(t.TimeCreated, 0).Format(
+				time.RFC3339,
+			),
+			Expired:  t.Expired,
+			FileName: t.StorageName,
+		}
+	}
+
+	printJSON(tokens)
+	return nil
+}

cmd/loop/main.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"bytes"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"os"
@@ -30,6 +32,21 @@ var (
 	defaultSwapWaitTime = 30 * time.Minute
 )
 
+func printJSON(resp interface{}) {
+	b, err := json.Marshal(resp)
+	if err != nil {
+		fatal(err)
+	}
+
+	var out bytes.Buffer
+	err = json.Indent(&out, b, "", "\t")
+	if err != nil {
+		fatal(err)
+	}
+	out.WriteString("\n")
+	_, _ = out.WriteTo(os.Stdout)
+}
+
 func printRespJSON(resp proto.Message) {
 	jsonMarshaler := &jsonpb.Marshaler{
 		EmitDefaults: true,
@@ -65,7 +82,7 @@ func main() {
 	}
 	app.Commands = []cli.Command{
 		loopOutCommand, loopInCommand, termsCommand,
-		monitorCommand, quoteCommand,
+		monitorCommand, quoteCommand, listAuthCommand,
 	}
 
 	err := app.Run(os.Args)

cmd/loopd/config.go

@@ -27,12 +27,13 @@ type lndConfig struct {
 type viewParameters struct{}
 
 type config struct {
-	ShowVersion bool   `short:"V" long:"version" description:"Display version information and exit"`
-	Insecure    bool   `long:"insecure" description:"disable tls"`
-	Network     string `long:"network" description:"network to run on" choice:"regtest" choice:"testnet" choice:"mainnet" choice:"simnet"`
-	SwapServer  string `long:"swapserver" description:"swap server address host:port"`
-	RPCListen   string `long:"rpclisten" description:"Address to listen on for gRPC clients"`
-	RESTListen  string `long:"restlisten" description:"Address to listen on for REST clients"`
+	ShowVersion    bool   `short:"V" long:"version" description:"Display version information and exit"`
+	Insecure       bool   `long:"insecure" description:"disable tls"`
+	Network        string `long:"network" description:"network to run on" choice:"regtest" choice:"testnet" choice:"mainnet" choice:"simnet"`
+	SwapServer     string `long:"swapserver" description:"swap server address host:port"`
+	TLSPathSwapSrv string `long:"tlspathswapserver" description:"Path to swap server tls certificate. Only needed if the swap server uses a self-signed certificate."`
+	RPCListen      string `long:"rpclisten" description:"Address to listen on for gRPC clients"`
+	RESTListen     string `long:"restlisten" description:"Address to listen on for REST clients"`
 
 	LogDir         string `long:"logdir" description:"Directory to log output."`
 	MaxLogFiles    int    `long:"maxlogfiles" description:"Maximum logfiles to keep (0 for no rotation)"`

cmd/loopd/daemon.go

@@ -45,7 +45,7 @@ func daemon(config *config) error {
 	// Create an instance of the loop client library.
 	swapClient, cleanup, err := getClient(
 		config.Network, config.SwapServer, config.Insecure,
-		&lnd.LndServices,
+		config.TLSPathSwapSrv, &lnd.LndServices,
 	)
 	if err != nil {
 		return err

cmd/loopd/log.go

@@ -5,6 +5,7 @@ import (
 	"github.com/lightninglabs/loop"
 	"github.com/lightninglabs/loop/lndclient"
 	"github.com/lightninglabs/loop/loopdb"
+	"github.com/lightninglabs/loop/lsat"
 	"github.com/lightningnetwork/lnd/build"
 )
 
@@ -19,6 +20,7 @@ func init() {
 	addSubLogger("LOOP", loop.UseLogger)
 	addSubLogger("LNDC", lndclient.UseLogger)
 	addSubLogger("STORE", loopdb.UseLogger)
+	addSubLogger(lsat.Subsystem, lsat.UseLogger)
 }
 
 // addSubLogger is a helper method to conveniently create and register the

cmd/loopd/swapclient_server.go

@@ -346,6 +346,40 @@ func (s *swapClientServer) LoopIn(ctx context.Context,
 	}, nil
 }
 
+// GetLsatTokens returns all tokens that are contained in the LSAT token store.
+func (s *swapClientServer) GetLsatTokens(ctx context.Context,
+	_ *looprpc.TokensRequest) (*looprpc.TokensResponse, error) {
+
+	log.Infof("Get LSAT tokens request received")
+
+	tokens, err := s.impl.LsatStore.AllTokens()
+	if err != nil {
+		return nil, err
+	}
+
+	rpcTokens := make([]*looprpc.LsatToken, len(tokens))
+	idx := 0
+	for key, token := range tokens {
+		macBytes, err := token.BaseMacaroon().MarshalBinary()
+		if err != nil {
+			return nil, err
+		}
+		rpcTokens[idx] = &looprpc.LsatToken{
+			BaseMacaroon:       macBytes,
+			PaymentHash:        token.PaymentHash[:],
+			PaymentPreimage:    token.Preimage[:],
+			AmountPaidMsat:     int64(token.AmountPaid),
+			RoutingFeePaidMsat: int64(token.RoutingFeePaid),
+			TimeCreated:        token.TimeCreated.Unix(),
+			Expired:            !token.IsValid(),
+			StorageName:        key,
+		}
+		idx++
+	}
+
+	return &looprpc.TokensResponse{Tokens: rpcTokens}, nil
+}
+
 // validateConfTarget ensures the given confirmation target is valid. If one
 // isn't specified (0 value), then the default target is used.
 func validateConfTarget(target, defaultTarget int32) (int32, error) {

cmd/loopd/utils.go

@@ -16,7 +16,7 @@ func getLnd(network string, cfg *lndConfig) (*lndclient.GrpcLndServices, error)
 }
 
 // getClient returns an instance of the swap client.
-func getClient(network, swapServer string, insecure bool,
+func getClient(network, swapServer string, insecure bool, tlsPathServer string,
 	lnd *lndclient.LndServices) (*loop.Client, func(), error) {
 
 	storeDir, err := getStoreDir(network)
@@ -25,7 +25,7 @@ func getClient(network, swapServer string, insecure bool,
 	}
 
 	swapClient, cleanUp, err := loop.NewClient(
-		storeDir, swapServer, insecure, lnd,
+		storeDir, swapServer, insecure, tlsPathServer, lnd,
 	)
 	if err != nil {
 		return nil, nil, err

cmd/loopd/view.go

@@ -24,7 +24,8 @@ func view(config *config) error {
 	defer lnd.Close()
 
 	swapClient, cleanup, err := getClient(
-		config.Network, config.SwapServer, config.Insecure, &lnd.LndServices,
+		config.Network, config.SwapServer, config.Insecure,
+		config.TLSPathSwapSrv, &lnd.LndServices,
 	)
 	if err != nil {
 		return err

config.go

@@ -5,12 +5,14 @@ import (
 
 	"github.com/lightninglabs/loop/lndclient"
 	"github.com/lightninglabs/loop/loopdb"
+	"github.com/lightninglabs/loop/lsat"
 )
 
 // clientConfig contains config items for the swap client.
 type clientConfig struct {
 	LndServices       *lndclient.LndServices
 	Server            swapServerClient
 	Store             loopdb.SwapStore
+	LsatStore         lsat.Store
 	CreateExpiryTimer func(expiry time.Duration) <-chan time.Time
 }