loop: add stubs and CLI commands for the asset deposit subserver

This commit adds a placeholder asset deposit subserver along with the
corresponding CLI commands to the Loop daemon and CLI.

Author: bhandras

assets/deposit/log.go

@@ -0,0 +1,26 @@
+package deposit
+
+import (
+	"github.com/btcsuite/btclog/v2"
+	"github.com/lightningnetwork/lnd/build"
+)
+
+// Subsystem defines the sub system name of this package.
+const Subsystem = "ADEP"
+
+// log is a logger that is initialized with no output filters.  This
+// means the package will not perform any logging by default until the caller
+// requests it.
+var log btclog.Logger
+
+// The default amount of logging is none.
+func init() {
+	UseLogger(build.NewSubLogger(Subsystem, nil))
+}
+
+// UseLogger uses a specified Logger to output package logging info.
+// This should be used in preference to SetLogWriter if the caller is also
+// using btclog.
+func UseLogger(logger btclog.Logger) {
+	log = logger
+}

assets/deposit/server.go

@@ -0,0 +1,63 @@
+package deposit
+
+import (
+	"context"
+
+	"github.com/lightninglabs/loop/looprpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+// Server is the grpc server that serves the reservation service.
+type Server struct {
+	looprpc.UnimplementedAssetDepositClientServer
+}
+
+func NewServer() *Server {
+	return &Server{}
+}
+
+// NewAssetDeposit is the rpc endpoint for loop clients to request a new asset
+// deposit.
+func (s *Server) NewAssetDeposit(ctx context.Context,
+	in *looprpc.NewAssetDepositRequest) (*looprpc.NewAssetDepositResponse,
+	error) {
+
+	return nil, status.Error(codes.Unimplemented, "unimplemented")
+}
+
+// ListAssetDeposits is the rpc endpoint for loop clients to list their asset
+// deposits.
+func (s *Server) ListAssetDeposits(ctx context.Context,
+	in *looprpc.ListAssetDepositsRequest) (
+	*looprpc.ListAssetDepositsResponse, error) {
+
+	return nil, status.Error(codes.Unimplemented, "unimplemented")
+}
+
+// RevealAssetDepositKey is the rpc endpoint for loop clients to reveal the
+// asset deposit key for a specific asset deposit.
+func (s *Server) RevealAssetDepositKey(ctx context.Context,
+	in *looprpc.RevealAssetDepositKeyRequest) (
+	*looprpc.RevealAssetDepositKeyResponse, error) {
+
+	return nil, status.Error(codes.Unimplemented, "unimplemented")
+}
+
+// WithdrawAssetDeposits is the rpc endpoint for loop clients to withdraw their
+// asset deposits.
+func (s *Server) WithdrawAssetDeposits(ctx context.Context,
+	in *looprpc.WithdrawAssetDepositsRequest) (
+	*looprpc.WithdrawAssetDepositsResponse, error) {
+
+	return nil, status.Error(codes.Unimplemented, "unimplemented")
+}
+
+// TestCoSignAssetDepositHTLC is the rpc endpoint for loop clients to test
+// co-signing an asset deposit HTLC.
+func (s *Server) TestCoSignAssetDepositHTLC(ctx context.Context,
+	in *looprpc.TestCoSignAssetDepositHTLCRequest) (
+	*looprpc.TestCoSignAssetDepositHTLCResponse, error) {
+
+	return nil, status.Error(codes.Unimplemented, "unimplemented")
+}

cmd/loop/asset_deposits.go

@@ -0,0 +1,255 @@
+package main
+
+import (
+	"context"
+
+	"github.com/lightninglabs/loop/looprpc"
+	"github.com/urfave/cli"
+)
+
+var (
+	assetDepositsCommands = cli.Command{
+		Name:      "asset deposits",
+		ShortName: "ad",
+		Usage:     "TAP asset deposit commands.",
+		Subcommands: []cli.Command{
+			newAssetDepositCommand,
+			listAssetDepositsCommand,
+			withdrawAssetDepositCommand,
+			testCoSignCommand,
+			testKeyRevealCommand,
+		},
+	}
+
+	newAssetDepositCommand = cli.Command{
+		Name:        "new",
+		ShortName:   "n",
+		Usage:       "Create a new TAP asset deposit.",
+		Description: "Create a new TAP asset deposit.",
+		Action:      newAssetDeposit,
+		Flags: []cli.Flag{
+			cli.StringFlag{
+				Name:  "asset_id",
+				Usage: "The asset id of the asset to deposit.",
+			},
+			cli.Uint64Flag{
+				Name: "amt",
+				Usage: "the amount to deposit (in asset " +
+					"units).",
+			},
+			cli.UintFlag{
+				Name:  "expiry",
+				Usage: "the deposit expiry in blocks.",
+			},
+		},
+	}
+
+	listAssetDepositsCommand = cli.Command{
+		Name:        "list",
+		ShortName:   "l",
+		Usage:       "List TAP asset deposits.",
+		Description: "List TAP asset deposits.",
+		Flags: []cli.Flag{
+			cli.UintFlag{
+				Name: "min_confs",
+				Usage: "The minimum amount of confirmations " +
+					"an anchor output should have to be " +
+					"listed.",
+			},
+			cli.UintFlag{
+				Name: "max_confs",
+				Usage: "The maximum number of confirmations " +
+					"an anchor output could have to be " +
+					"listed.",
+			},
+		},
+		Action: listAssetDeposits,
+	}
+
+	withdrawAssetDepositCommand = cli.Command{
+		Name:        "withdraw",
+		ShortName:   "w",
+		Usage:       "Withdraw TAP asset deposits.",
+		Description: "Withdraw TAP asset deposits.",
+		Action:      withdrawAssetDeposit,
+		Flags: []cli.Flag{
+			cli.StringSliceFlag{
+				Name: "deposit_ids",
+				Usage: "The deposit ids of the asset " +
+					"deposits to withdraw.",
+			},
+		},
+	}
+
+	testKeyRevealCommand = cli.Command{
+		Name:      "testkeyreveal",
+		ShortName: "tkr",
+		Usage:     "Test revealing the key of a deposit to the server.",
+		Action:    testKeyReveal,
+		Flags: []cli.Flag{
+			cli.StringFlag{
+				Name:  "deposit_id",
+				Usage: "The deposit id of the asset deposit.",
+			},
+		},
+	}
+
+	testCoSignCommand = cli.Command{
+		Name:      "testcosign",
+		ShortName: "tcs",
+		Usage:     "Test co-signing a deposit to spend to an HTLC.",
+		Action:    testCoSign,
+		Flags: []cli.Flag{
+			cli.StringFlag{
+				Name:  "deposit_id",
+				Usage: "The deposit id of the asset deposit.",
+			},
+		},
+	}
+)
+
+func init() {
+	commands = append(commands, assetDepositsCommands)
+}
+
+func newAssetDeposit(ctx *cli.Context) error {
+	ctxb := context.Background()
+	if ctx.NArg() > 0 {
+		return cli.ShowCommandHelp(ctx, "newdeposit")
+	}
+
+	client, cleanup, err := getAssetDepositsClient(ctx)
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	assetID := ctx.String("asset_id")
+	amt := ctx.Uint64("amt")
+	expiry := int32(ctx.Uint("expiry"))
+
+	resp, err := client.NewAssetDeposit(
+		ctxb, &looprpc.NewAssetDepositRequest{
+			AssetId:   assetID,
+			Amount:    amt,
+			CsvExpiry: expiry,
+		},
+	)
+	if err != nil {
+		return err
+	}
+
+	printJSON(resp)
+
+	return nil
+}
+
+func listAssetDeposits(ctx *cli.Context) error {
+	ctxb := context.Background()
+	if ctx.NArg() > 0 {
+		return cli.ShowCommandHelp(ctx, "list")
+	}
+
+	client, cleanup, err := getAssetDepositsClient(ctx)
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	resp, err := client.ListAssetDeposits(
+		ctxb, &looprpc.ListAssetDepositsRequest{
+			MinConfs: uint32(ctx.Int("min_confs")),
+			MaxConfs: uint32(ctx.Int("max_confs")),
+		})
+	if err != nil {
+		return err
+	}
+
+	printRespJSON(resp)
+
+	return nil
+}
+
+func withdrawAssetDeposit(ctx *cli.Context) error {
+	ctxb := context.Background()
+	if ctx.NArg() > 0 {
+		return cli.ShowCommandHelp(ctx, "withdraw")
+	}
+
+	client, cleanup, err := getAssetDepositsClient(ctx)
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	depositIDs := ctx.StringSlice("deposit_ids")
+
+	resp, err := client.WithdrawAssetDeposits(
+		ctxb, &looprpc.WithdrawAssetDepositsRequest{
+			DepositIds: depositIDs,
+		},
+	)
+	if err != nil {
+		return err
+	}
+
+	printRespJSON(resp)
+
+	return nil
+}
+
+func testKeyReveal(ctx *cli.Context) error {
+	ctxb := context.Background()
+	if ctx.NArg() > 0 {
+		return cli.ShowCommandHelp(ctx, "testkeyreveal")
+	}
+
+	client, cleanup, err := getAssetDepositsClient(ctx)
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	depositID := ctx.String("deposit_id")
+
+	resp, err := client.RevealAssetDepositKey(
+		ctxb, &looprpc.RevealAssetDepositKeyRequest{
+			DepositId: depositID,
+		},
+	)
+	if err != nil {
+		return err
+	}
+
+	printRespJSON(resp)
+
+	return nil
+}
+
+func testCoSign(ctx *cli.Context) error {
+	ctxb := context.Background()
+	if ctx.NArg() > 0 {
+		return cli.ShowCommandHelp(ctx, "testcosign")
+	}
+
+	client, cleanup, err := getAssetDepositsClient(ctx)
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	depositID := ctx.String("deposit_id")
+
+	resp, err := client.TestCoSignAssetDepositHTLC(
+		ctxb, &looprpc.TestCoSignAssetDepositHTLCRequest{
+			DepositId: depositID,
+		},
+	)
+	if err != nil {
+		return err
+	}
+
+	printRespJSON(resp)
+
+	return nil
+}

cmd/loop/main.go

@@ -185,22 +185,44 @@ func main() {
 	}
 }
 
-func getClient(ctx *cli.Context) (looprpc.SwapClientClient, func(), error) {
+func getConn(ctx *cli.Context) (*grpc.ClientConn, func(), error) {
 	rpcServer := ctx.GlobalString("rpcserver")
 	tlsCertPath, macaroonPath, err := extractPathArgs(ctx)
 	if err != nil {
 		return nil, nil, err
 	}
+
 	conn, err := getClientConn(rpcServer, tlsCertPath, macaroonPath)
 	if err != nil {
 		return nil, nil, err
 	}
 	cleanup := func() { conn.Close() }
 
+	return conn, cleanup, nil
+}
+
+func getClient(ctx *cli.Context) (looprpc.SwapClientClient, func(), error) {
+	conn, cleanup, err := getConn(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+
 	loopClient := looprpc.NewSwapClientClient(conn)
 	return loopClient, cleanup, nil
 }
 
+func getAssetDepositsClient(ctx *cli.Context) (
+	looprpc.AssetDepositClientClient, func(), error) {
+
+	conn, cleanup, err := getConn(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	assetDepositsClient := looprpc.NewAssetDepositClientClient(conn)
+	return assetDepositsClient, cleanup, nil
+}
+
 func getMaxRoutingFee(amt btcutil.Amount) btcutil.Amount {
 	return swap.CalcFee(amt, maxRoutingFeeBase, maxRoutingFeeRate)
 }