2017-11-28 03:12:09 +03:00
|
|
|
// Copyright (c) 2013-2017 The btcsuite developers
|
|
|
|
// Copyright (c) 2015-2016 The Decred developers
|
|
|
|
// Copyright (C) 2015-2017 The Lightning Network Developers
|
|
|
|
|
2015-12-30 05:31:03 +03:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
2017-08-18 04:51:33 +03:00
|
|
|
"io/ioutil"
|
2015-12-30 05:31:03 +03:00
|
|
|
"os"
|
2018-02-26 06:41:44 +03:00
|
|
|
"os/user"
|
2017-07-26 02:22:06 +03:00
|
|
|
"path/filepath"
|
|
|
|
"strings"
|
2017-08-18 04:51:33 +03:00
|
|
|
|
2018-01-16 19:18:41 +03:00
|
|
|
macaroon "gopkg.in/macaroon.v2"
|
2015-12-30 05:31:03 +03:00
|
|
|
|
2018-07-31 10:17:17 +03:00
|
|
|
"github.com/btcsuite/btcutil"
|
2018-09-20 13:26:38 +03:00
|
|
|
"github.com/lightningnetwork/lnd/build"
|
2018-05-23 16:41:36 +03:00
|
|
|
"github.com/lightningnetwork/lnd/lncfg"
|
2016-01-16 21:45:54 +03:00
|
|
|
"github.com/lightningnetwork/lnd/lnrpc"
|
2017-08-18 04:51:33 +03:00
|
|
|
"github.com/lightningnetwork/lnd/macaroons"
|
2016-07-26 20:42:35 +03:00
|
|
|
"github.com/urfave/cli"
|
2015-12-30 05:31:03 +03:00
|
|
|
|
|
|
|
"google.golang.org/grpc"
|
2017-07-26 02:22:06 +03:00
|
|
|
"google.golang.org/grpc/credentials"
|
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
2018-08-22 22:31:47 +03:00
|
|
|
defaultDataDir = "data"
|
|
|
|
defaultChainSubDir = "chain"
|
2017-08-18 04:51:33 +03:00
|
|
|
defaultTLSCertFilename = "tls.cert"
|
|
|
|
defaultMacaroonFilename = "admin.macaroon"
|
2018-07-31 11:29:12 +03:00
|
|
|
defaultRPCPort = "10009"
|
|
|
|
defaultRPCHostPort = "localhost:" + defaultRPCPort
|
2017-07-26 02:22:06 +03:00
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
2018-08-22 22:31:47 +03:00
|
|
|
defaultLndDir = btcutil.AppDataDir("lnd", false)
|
|
|
|
defaultTLSCertPath = filepath.Join(defaultLndDir, defaultTLSCertFilename)
|
2018-12-25 22:09:34 +03:00
|
|
|
|
|
|
|
// maxMsgRecvSize is the largest message our client will receive. We
|
|
|
|
// set this to ~50Mb atm.
|
|
|
|
maxMsgRecvSize = grpc.MaxCallRecvMsgSize(1 * 1024 * 1024 * 50)
|
2015-12-30 05:31:03 +03:00
|
|
|
)
|
|
|
|
|
|
|
|
func fatal(err error) {
|
|
|
|
fmt.Fprintf(os.Stderr, "[lncli] %v\n", err)
|
|
|
|
os.Exit(1)
|
|
|
|
}
|
|
|
|
|
2017-10-12 12:42:06 +03:00
|
|
|
func getWalletUnlockerClient(ctx *cli.Context) (lnrpc.WalletUnlockerClient, func()) {
|
2018-02-01 03:04:56 +03:00
|
|
|
conn := getClientConn(ctx, true)
|
2017-10-12 12:42:06 +03:00
|
|
|
|
|
|
|
cleanUp := func() {
|
|
|
|
conn.Close()
|
|
|
|
}
|
|
|
|
|
|
|
|
return lnrpc.NewWalletUnlockerClient(conn), cleanUp
|
|
|
|
}
|
|
|
|
|
2017-01-30 01:51:30 +03:00
|
|
|
func getClient(ctx *cli.Context) (lnrpc.LightningClient, func()) {
|
2018-02-01 03:04:56 +03:00
|
|
|
conn := getClientConn(ctx, false)
|
2017-01-30 01:51:30 +03:00
|
|
|
|
|
|
|
cleanUp := func() {
|
|
|
|
conn.Close()
|
|
|
|
}
|
|
|
|
|
|
|
|
return lnrpc.NewLightningClient(conn), cleanUp
|
2015-12-30 05:31:03 +03:00
|
|
|
}
|
|
|
|
|
2018-02-01 03:04:56 +03:00
|
|
|
func getClientConn(ctx *cli.Context, skipMacaroons bool) *grpc.ClientConn {
|
2018-08-22 22:31:47 +03:00
|
|
|
// First, we'll parse the args from the command.
|
2018-08-24 03:48:41 +03:00
|
|
|
tlsCertPath, macPath, err := extractPathArgs(ctx)
|
|
|
|
if err != nil {
|
|
|
|
fatal(err)
|
|
|
|
}
|
2018-02-24 23:59:22 +03:00
|
|
|
|
2017-08-18 04:51:33 +03:00
|
|
|
// Load the specified TLS certificate and build transport credentials
|
|
|
|
// with it.
|
|
|
|
creds, err := credentials.NewClientTLSFromFile(tlsCertPath, "")
|
|
|
|
if err != nil {
|
2017-07-26 02:22:06 +03:00
|
|
|
fatal(err)
|
|
|
|
}
|
2017-08-18 04:51:33 +03:00
|
|
|
|
|
|
|
// Create a dial options array.
|
|
|
|
opts := []grpc.DialOption{
|
|
|
|
grpc.WithTransportCredentials(creds),
|
2017-07-26 02:22:06 +03:00
|
|
|
}
|
2017-08-18 04:51:33 +03:00
|
|
|
|
2018-02-01 03:04:56 +03:00
|
|
|
// Only process macaroon credentials if --no-macaroons isn't set and
|
|
|
|
// if we're not skipping macaroon processing.
|
|
|
|
if !ctx.GlobalBool("no-macaroons") && !skipMacaroons {
|
2017-08-18 04:51:33 +03:00
|
|
|
// Load the specified macaroon file.
|
|
|
|
macBytes, err := ioutil.ReadFile(macPath)
|
|
|
|
if err != nil {
|
2018-08-24 03:48:41 +03:00
|
|
|
fatal(fmt.Errorf("unable to read macaroon path (check "+
|
|
|
|
"the network setting!): %v", err))
|
2017-08-18 04:51:33 +03:00
|
|
|
}
|
2018-08-24 03:48:41 +03:00
|
|
|
|
2017-08-18 04:51:33 +03:00
|
|
|
mac := &macaroon.Macaroon{}
|
|
|
|
if err = mac.UnmarshalBinary(macBytes); err != nil {
|
2018-08-24 03:48:41 +03:00
|
|
|
fatal(fmt.Errorf("unable to decode macaroon: %v", err))
|
2017-08-18 04:51:33 +03:00
|
|
|
}
|
|
|
|
|
2017-09-02 03:45:14 +03:00
|
|
|
macConstraints := []macaroons.Constraint{
|
|
|
|
// We add a time-based constraint to prevent replay of the
|
|
|
|
// macaroon. It's good for 60 seconds by default to make up for
|
|
|
|
// any discrepancy between client and server clocks, but leaking
|
|
|
|
// the macaroon before it becomes invalid makes it possible for
|
|
|
|
// an attacker to reuse the macaroon. In addition, the validity
|
|
|
|
// time of the macaroon is extended by the time the server clock
|
|
|
|
// is behind the client clock, or shortened by the time the
|
|
|
|
// server clock is ahead of the client clock (or invalid
|
|
|
|
// altogether if, in the latter case, this time is more than 60
|
|
|
|
// seconds).
|
|
|
|
// TODO(aakselrod): add better anti-replay protection.
|
|
|
|
macaroons.TimeoutConstraint(ctx.GlobalInt64("macaroontimeout")),
|
|
|
|
|
2017-09-02 03:46:27 +03:00
|
|
|
// Lock macaroon down to a specific IP address.
|
|
|
|
macaroons.IPLockConstraint(ctx.GlobalString("macaroonip")),
|
|
|
|
|
2017-09-02 03:45:14 +03:00
|
|
|
// ... Add more constraints if needed.
|
|
|
|
}
|
|
|
|
|
|
|
|
// Apply constraints to the macaroon.
|
2017-09-13 23:44:05 +03:00
|
|
|
constrainedMac, err := macaroons.AddConstraints(mac, macConstraints...)
|
|
|
|
if err != nil {
|
|
|
|
fatal(err)
|
|
|
|
}
|
2017-08-18 04:51:33 +03:00
|
|
|
|
|
|
|
// Now we append the macaroon credentials to the dial options.
|
2017-09-02 03:45:14 +03:00
|
|
|
cred := macaroons.NewMacaroonCredential(constrainedMac)
|
|
|
|
opts = append(opts, grpc.WithPerRPCCredentials(cred))
|
2017-07-26 02:22:06 +03:00
|
|
|
}
|
2015-12-30 05:31:03 +03:00
|
|
|
|
2018-05-23 16:41:36 +03:00
|
|
|
// We need to use a custom dialer so we can also connect to unix sockets
|
|
|
|
// and not just TCP addresses.
|
2018-12-25 22:09:34 +03:00
|
|
|
genericDialer := lncfg.ClientAddressDialer(defaultRPCPort)
|
|
|
|
opts = append(opts, grpc.WithDialer(genericDialer))
|
|
|
|
opts = append(opts, grpc.WithDefaultCallOptions(maxMsgRecvSize))
|
|
|
|
|
2015-12-30 05:31:03 +03:00
|
|
|
conn, err := grpc.Dial(ctx.GlobalString("rpcserver"), opts...)
|
|
|
|
if err != nil {
|
2018-08-24 03:48:41 +03:00
|
|
|
fatal(fmt.Errorf("unable to connect to RPC server: %v", err))
|
2015-12-30 05:31:03 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return conn
|
|
|
|
}
|
|
|
|
|
2018-08-24 03:48:41 +03:00
|
|
|
// extractPathArgs parses the TLS certificate and macaroon paths from the
|
|
|
|
// command.
|
|
|
|
func extractPathArgs(ctx *cli.Context) (string, string, error) {
|
2018-08-22 22:31:47 +03:00
|
|
|
// We'll start off by parsing the active chain and network. These are
|
|
|
|
// needed to determine the correct path to the macaroon when not
|
|
|
|
// specified.
|
|
|
|
chain := strings.ToLower(ctx.GlobalString("chain"))
|
|
|
|
switch chain {
|
|
|
|
case "bitcoin", "litecoin":
|
|
|
|
default:
|
2018-08-24 03:48:41 +03:00
|
|
|
return "", "", fmt.Errorf("unknown chain: %v", chain)
|
2018-08-22 22:31:47 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
network := strings.ToLower(ctx.GlobalString("network"))
|
|
|
|
switch network {
|
|
|
|
case "mainnet", "testnet", "regtest", "simnet":
|
|
|
|
default:
|
2018-08-24 03:48:41 +03:00
|
|
|
return "", "", fmt.Errorf("unknown network: %v", network)
|
2018-08-22 22:31:47 +03:00
|
|
|
}
|
|
|
|
|
2018-08-24 03:48:00 +03:00
|
|
|
// We'll now fetch the lnddir so we can make a decision on how to
|
|
|
|
// properly read the macaroons (if needed) and also the cert. This will
|
|
|
|
// either be the default, or will have been overwritten by the end
|
|
|
|
// user.
|
2018-08-22 22:31:47 +03:00
|
|
|
lndDir := cleanAndExpandPath(ctx.GlobalString("lnddir"))
|
|
|
|
|
2018-08-24 03:48:00 +03:00
|
|
|
// If the macaroon path as been manually provided, then we'll only
|
|
|
|
// target the specified file.
|
|
|
|
var macPath string
|
|
|
|
if ctx.GlobalString("macaroonpath") != "" {
|
2018-08-22 22:31:47 +03:00
|
|
|
macPath = cleanAndExpandPath(ctx.GlobalString("macaroonpath"))
|
2018-08-24 03:48:00 +03:00
|
|
|
} else {
|
|
|
|
// Otherwise, we'll go into the path:
|
|
|
|
// lnddir/data/chain/<chain>/<network> in order to fetch the
|
|
|
|
// macaroon that we need.
|
|
|
|
macPath = filepath.Join(
|
|
|
|
lndDir, defaultDataDir, defaultChainSubDir, chain,
|
|
|
|
network, defaultMacaroonFilename,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
tlsCertPath := cleanAndExpandPath(ctx.GlobalString("tlscertpath"))
|
|
|
|
|
|
|
|
// If a custom lnd directory was set, we'll also check if custom paths
|
|
|
|
// for the TLS cert and macaroon file were set as well. If not, we'll
|
|
|
|
// override their paths so they can be found within the custom lnd
|
|
|
|
// directory set. This allows us to set a custom lnd directory, along
|
|
|
|
// with custom paths to the TLS cert and macaroon file.
|
|
|
|
if lndDir != defaultLndDir {
|
|
|
|
tlsCertPath = filepath.Join(lndDir, defaultTLSCertFilename)
|
2018-08-22 22:31:47 +03:00
|
|
|
}
|
|
|
|
|
2018-08-24 03:48:41 +03:00
|
|
|
return tlsCertPath, macPath, nil
|
2018-08-22 22:31:47 +03:00
|
|
|
}
|
|
|
|
|
2015-12-30 05:31:03 +03:00
|
|
|
func main() {
|
|
|
|
app := cli.NewApp()
|
|
|
|
app.Name = "lncli"
|
2018-09-20 13:26:38 +03:00
|
|
|
app.Version = build.Version()
|
2016-12-28 02:45:10 +03:00
|
|
|
app.Usage = "control plane for your Lightning Network Daemon (lnd)"
|
2015-12-30 05:31:03 +03:00
|
|
|
app.Flags = []cli.Flag{
|
|
|
|
cli.StringFlag{
|
|
|
|
Name: "rpcserver",
|
2018-07-31 11:29:12 +03:00
|
|
|
Value: defaultRPCHostPort,
|
2016-01-16 21:45:54 +03:00
|
|
|
Usage: "host:port of ln daemon",
|
2015-12-30 05:31:03 +03:00
|
|
|
},
|
2018-02-24 23:59:22 +03:00
|
|
|
cli.StringFlag{
|
|
|
|
Name: "lnddir",
|
|
|
|
Value: defaultLndDir,
|
|
|
|
Usage: "path to lnd's base directory",
|
|
|
|
},
|
2017-07-26 02:22:06 +03:00
|
|
|
cli.StringFlag{
|
|
|
|
Name: "tlscertpath",
|
|
|
|
Value: defaultTLSCertPath,
|
|
|
|
Usage: "path to TLS certificate",
|
|
|
|
},
|
2018-08-22 22:31:14 +03:00
|
|
|
cli.StringFlag{
|
|
|
|
Name: "chain, c",
|
|
|
|
Usage: "the chain lnd is running on e.g. bitcoin",
|
|
|
|
Value: "bitcoin",
|
|
|
|
},
|
|
|
|
cli.StringFlag{
|
|
|
|
Name: "network, n",
|
|
|
|
Usage: "the network lnd is running on e.g. mainnet, " +
|
|
|
|
"testnet, etc.",
|
|
|
|
Value: "mainnet",
|
|
|
|
},
|
2017-08-18 04:51:33 +03:00
|
|
|
cli.BoolFlag{
|
|
|
|
Name: "no-macaroons",
|
|
|
|
Usage: "disable macaroon authentication",
|
|
|
|
},
|
|
|
|
cli.StringFlag{
|
|
|
|
Name: "macaroonpath",
|
|
|
|
Usage: "path to macaroon file",
|
|
|
|
},
|
|
|
|
cli.Int64Flag{
|
|
|
|
Name: "macaroontimeout",
|
|
|
|
Value: 60,
|
|
|
|
Usage: "anti-replay macaroon validity time in seconds",
|
|
|
|
},
|
2017-09-02 03:46:27 +03:00
|
|
|
cli.StringFlag{
|
|
|
|
Name: "macaroonip",
|
|
|
|
Usage: "if set, lock macaroon to specific IP address",
|
|
|
|
},
|
2015-12-30 05:31:03 +03:00
|
|
|
}
|
|
|
|
app.Commands = []cli.Command{
|
2017-10-12 12:42:06 +03:00
|
|
|
createCommand,
|
|
|
|
unlockCommand,
|
2018-04-20 10:14:51 +03:00
|
|
|
changePasswordCommand,
|
2017-02-24 16:32:33 +03:00
|
|
|
newAddressCommand,
|
2019-03-05 16:22:30 +03:00
|
|
|
estimateFeeCommand,
|
2017-02-24 16:32:33 +03:00
|
|
|
sendManyCommand,
|
|
|
|
sendCoinsCommand,
|
2018-09-27 16:49:44 +03:00
|
|
|
listUnspentCommand,
|
2017-02-24 16:32:33 +03:00
|
|
|
connectCommand,
|
2017-05-06 01:54:25 +03:00
|
|
|
disconnectCommand,
|
2017-02-24 16:32:33 +03:00
|
|
|
openChannelCommand,
|
|
|
|
closeChannelCommand,
|
2018-01-24 05:34:29 +03:00
|
|
|
closeAllChannelsCommand,
|
2018-05-29 12:26:47 +03:00
|
|
|
abandonChannelCommand,
|
2017-02-24 16:32:33 +03:00
|
|
|
listPeersCommand,
|
|
|
|
walletBalanceCommand,
|
|
|
|
channelBalanceCommand,
|
|
|
|
getInfoCommand,
|
|
|
|
pendingChannelsCommand,
|
|
|
|
sendPaymentCommand,
|
2017-10-28 01:39:54 +03:00
|
|
|
payInvoiceCommand,
|
2018-01-25 07:19:40 +03:00
|
|
|
sendToRouteCommand,
|
2017-02-24 16:32:33 +03:00
|
|
|
addInvoiceCommand,
|
|
|
|
lookupInvoiceCommand,
|
|
|
|
listInvoicesCommand,
|
|
|
|
listChannelsCommand,
|
2018-05-24 12:35:53 +03:00
|
|
|
closedChannelsCommand,
|
2017-02-24 16:32:33 +03:00
|
|
|
listPaymentsCommand,
|
|
|
|
describeGraphCommand,
|
|
|
|
getChanInfoCommand,
|
|
|
|
getNodeInfoCommand,
|
2017-03-21 05:01:57 +03:00
|
|
|
queryRoutesCommand,
|
2017-02-24 16:32:33 +03:00
|
|
|
getNetworkInfoCommand,
|
|
|
|
debugLevelCommand,
|
2018-02-07 06:11:11 +03:00
|
|
|
decodePayReqCommand,
|
2017-03-09 07:44:32 +03:00
|
|
|
listChainTxnsCommand,
|
2017-05-12 00:55:56 +03:00
|
|
|
stopCommand,
|
2017-04-20 05:33:09 +03:00
|
|
|
signMessageCommand,
|
|
|
|
verifyMessageCommand,
|
2017-08-22 10:29:08 +03:00
|
|
|
feeReportCommand,
|
2017-12-17 01:13:17 +03:00
|
|
|
updateChannelPolicyCommand,
|
2018-02-28 09:24:37 +03:00
|
|
|
forwardingHistoryCommand,
|
2018-12-10 07:16:11 +03:00
|
|
|
exportChanBackupCommand,
|
2019-03-11 03:55:12 +03:00
|
|
|
verifyChanBackupCommand,
|
2018-12-10 07:16:11 +03:00
|
|
|
restoreChanBackupCommand,
|
2015-12-30 05:31:03 +03:00
|
|
|
}
|
2016-01-17 06:10:29 +03:00
|
|
|
|
2018-12-13 14:26:30 +03:00
|
|
|
// Add any extra autopilot commands determined by build flags.
|
|
|
|
app.Commands = append(app.Commands, autopilotCommands()...)
|
2018-11-26 16:19:43 +03:00
|
|
|
app.Commands = append(app.Commands, invoicesCommands()...)
|
2019-05-10 11:39:16 +03:00
|
|
|
app.Commands = append(app.Commands, routerCommands()...)
|
2018-12-13 14:26:30 +03:00
|
|
|
|
2015-12-30 05:31:03 +03:00
|
|
|
if err := app.Run(os.Args); err != nil {
|
|
|
|
fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2017-07-26 02:22:06 +03:00
|
|
|
|
|
|
|
// cleanAndExpandPath expands environment variables and leading ~ in the
|
|
|
|
// passed path, cleans the result, and returns it.
|
|
|
|
// This function is taken from https://github.com/btcsuite/btcd
|
|
|
|
func cleanAndExpandPath(path string) string {
|
2018-08-22 22:25:55 +03:00
|
|
|
if path == "" {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
2017-07-26 02:22:06 +03:00
|
|
|
// Expand initial ~ to OS specific home directory.
|
|
|
|
if strings.HasPrefix(path, "~") {
|
2018-02-26 06:41:44 +03:00
|
|
|
var homeDir string
|
|
|
|
user, err := user.Current()
|
|
|
|
if err == nil {
|
|
|
|
homeDir = user.HomeDir
|
|
|
|
} else {
|
|
|
|
homeDir = os.Getenv("HOME")
|
|
|
|
}
|
|
|
|
|
2017-07-26 02:22:06 +03:00
|
|
|
path = strings.Replace(path, "~", homeDir, 1)
|
|
|
|
}
|
|
|
|
|
|
|
|
// NOTE: The os.ExpandEnv doesn't work with Windows-style %VARIABLE%,
|
|
|
|
// but the variables can still be expanded via POSIX-style $VARIABLE.
|
|
|
|
return filepath.Clean(os.ExpandEnv(path))
|
|
|
|
}
|