NAV Navbar
shell python javascript

LND gRPC API Reference

Welcome to the gRPC API reference documentation for LND, the Lightning Network Daemon.

This site features the API documentation for lncli (CLI), Python, and JavaScript in order to communicate with a local lnd instance through gRPC. It is intended for those who already understand how to work with LND. If this is your first time or you need a refresher, you may consider perusing our LND developer site featuring a tutorial, resources and guides at dev.lightning.community.

The examples to the right assume that the there is a local lnd instance running and listening for gRPC connections on port 10009. LND_DIR will be used as a placeholder to denote the base directory of the lnd instance. By default, this is ~/.lnd on Linux and ~/Library/Application Support/Lnd on macOS.

At the time of writing this documentation, two things are needed in order to make a gRPC request to an lnd instance: a TLS/SSL connection and a macaroon used for RPC authentication. The examples to the right will show how these can be used in order to make a successful, secure, and authenticated gRPC request.

The original *.proto files from which the gRPC documentation was generated can be found here:

This is the reference for the gRPC API. Alternatively, there is also a REST API which is documented here.

This documentation was generated automatically against commit 3190437188a5f78bc2730bd0d437f9c42a6b8477.

Experimental services

The following RPCs/services are currently considered to be experimental. This means they are subject to change in the future. They also need to be enabled with a compile-time flag to be active (they are active in the official release binaries).

Service Autopilot

ModifyStatus

Unary RPC

ModifyStatus is used to modify the status of the autopilot agent, like enabling or disabling it.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/autopilotrpc/autopilot.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import autopilot_pb2 as autopilotrpc, autopilot_pb2_grpc as autopilotstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = autopilotstub.AutopilotStub(channel)
>>> request = autopilotrpc.ModifyStatusRequest(
        enable=<bool>,
    )
>>> response = stub.ModifyStatus(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync(['rpc.proto', 'autopilotrpc/autopilot.proto'], loaderOptions);
const autopilotrpc = grpc.loadPackageDefinition(packageDefinition).autopilotrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let autopilot = new autopilotrpc.Autopilot('localhost:10009', creds);
let request = { 
  enable: <bool>, 
}; 
autopilot.modifyStatus(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//  }

gRPC Request: autopilotrpc.ModifyStatusRequest

Parameter Type Description
enable bool Whether the autopilot agent should be enabled or not.

gRPC Response: autopilotrpc.ModifyStatusResponse

This response has no parameters.

QueryScores

Unary RPC

QueryScores queries all available autopilot heuristics, in addition to any active combination of these heruristics, for the scores they would give to the given nodes.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/autopilotrpc/autopilot.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import autopilot_pb2 as autopilotrpc, autopilot_pb2_grpc as autopilotstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = autopilotstub.AutopilotStub(channel)
>>> request = autopilotrpc.QueryScoresRequest(
        pubkeys=<array string>,
        ignore_local_state=<bool>,
    )
>>> response = stub.QueryScores(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "results": <array HeuristicResult>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync(['rpc.proto', 'autopilotrpc/autopilot.proto'], loaderOptions);
const autopilotrpc = grpc.loadPackageDefinition(packageDefinition).autopilotrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let autopilot = new autopilotrpc.Autopilot('localhost:10009', creds);
let request = { 
  pubkeys: <array string>, 
  ignore_local_state: <bool>, 
}; 
autopilot.queryScores(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "results": <array HeuristicResult>,
//  }

gRPC Request: autopilotrpc.QueryScoresRequest

Parameter Type Description
pubkeys array string
ignore_local_state bool If set, we will ignore the local channel state when calculating scores.

gRPC Response: autopilotrpc.QueryScoresResponse

Parameter Type Description
results array HeuristicResult

SetScores

Unary RPC

SetScores attempts to set the scores used by the running autopilot agent, if the external scoring heuristic is enabled.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/autopilotrpc/autopilot.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import autopilot_pb2 as autopilotrpc, autopilot_pb2_grpc as autopilotstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = autopilotstub.AutopilotStub(channel)
>>> request = autopilotrpc.SetScoresRequest(
        heuristic=<string>,
        scores=<array ScoresEntry>,
    )
>>> response = stub.SetScores(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync(['rpc.proto', 'autopilotrpc/autopilot.proto'], loaderOptions);
const autopilotrpc = grpc.loadPackageDefinition(packageDefinition).autopilotrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let autopilot = new autopilotrpc.Autopilot('localhost:10009', creds);
let request = { 
  heuristic: <string>, 
  scores: <array ScoresEntry>, 
}; 
autopilot.setScores(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//  }

gRPC Request: autopilotrpc.SetScoresRequest

Parameter Type Description
heuristic string The name of the heuristic to provide scores to.
scores array ScoresEntry A map from hex-encoded public keys to scores. Scores must be in the range [0.0, 1.0].

gRPC Response: autopilotrpc.SetScoresResponse

This response has no parameters.

Status

Unary RPC

Status returns whether the daemon's autopilot agent is active.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/autopilotrpc/autopilot.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import autopilot_pb2 as autopilotrpc, autopilot_pb2_grpc as autopilotstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = autopilotstub.AutopilotStub(channel)
>>> request = autopilotrpc.StatusRequest()
>>> response = stub.Status(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "active": <bool>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync(['rpc.proto', 'autopilotrpc/autopilot.proto'], loaderOptions);
const autopilotrpc = grpc.loadPackageDefinition(packageDefinition).autopilotrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let autopilot = new autopilotrpc.Autopilot('localhost:10009', creds);
let request = {}; 
autopilot.status(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "active": <bool>,
//  }

gRPC Request: autopilotrpc.StatusRequest

This request has no parameters.

gRPC Response: autopilotrpc.StatusResponse

Parameter Type Description
active bool Indicates whether the autopilot is active or not.

Service ChainNotifier

RegisterBlockEpochNtfn

Server-streaming RPC

RegisterBlockEpochNtfn is a synchronous response-streaming RPC that registers an intent for a client to be notified of blocks in the chain. The stream will return a hash and height tuple of a block for each new/stale block in the chain. It is the client's responsibility to determine whether the tuple returned is for a new or stale block in the chain. A client can also request a historical backlog of blocks from a particular point. This allows clients to be idempotent by ensuring that they do not missing processing a single block within the chain.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/chainrpc/chainnotifier.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import chainnotifier_pb2 as chainrpc, chainnotifier_pb2_grpc as chainnotifierstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = chainnotifierstub.ChainNotifierStub(channel)
>>> request = chainrpc.BlockEpoch(
        hash=<bytes>,
        height=<uint32>,
    )
>>> for response in stub.RegisterBlockEpochNtfn(request, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "hash": <bytes>,
    "height": <uint32>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync(['rpc.proto', 'chainrpc/chainnotifier.proto'], loaderOptions);
const chainrpc = grpc.loadPackageDefinition(packageDefinition).chainrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let chainNotifier = new chainrpc.ChainNotifier('localhost:10009', creds);
let request = { 
  hash: <bytes>, 
  height: <uint32>, 
}; 
let call = chainNotifier.registerBlockEpochNtfn(request);
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
// Console output:
//  { 
//      "hash": <bytes>,
//      "height": <uint32>,
//  }

gRPC Request: chainrpc.BlockEpoch

Parameter Type Description
hash bytes The hash of the block.
height uint32 The height of the block.

gRPC Response: chainrpc.BlockEpoch (Streaming)

Parameter Type Description
hash bytes The hash of the block.
height uint32 The height of the block.

RegisterConfirmationsNtfn

Server-streaming RPC

RegisterConfirmationsNtfn is a synchronous response-streaming RPC that registers an intent for a client to be notified once a confirmation request has reached its required number of confirmations on-chain. A client can specify whether the confirmation request should be for a particular transaction by its hash or for an output script by specifying a zero hash.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/chainrpc/chainnotifier.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import chainnotifier_pb2 as chainrpc, chainnotifier_pb2_grpc as chainnotifierstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = chainnotifierstub.ChainNotifierStub(channel)
>>> request = chainrpc.ConfRequest(
        txid=<bytes>,
        script=<bytes>,
        num_confs=<uint32>,
        height_hint=<uint32>,
    )
>>> for response in stub.RegisterConfirmationsNtfn(request, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "conf": <ConfDetails>,
    "reorg": <Reorg>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync(['rpc.proto', 'chainrpc/chainnotifier.proto'], loaderOptions);
const chainrpc = grpc.loadPackageDefinition(packageDefinition).chainrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let chainNotifier = new chainrpc.ChainNotifier('localhost:10009', creds);
let request = { 
  txid: <bytes>, 
  script: <bytes>, 
  num_confs: <uint32>, 
  height_hint: <uint32>, 
}; 
let call = chainNotifier.registerConfirmationsNtfn(request);
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
// Console output:
//  { 
//      "conf": <ConfDetails>,
//      "reorg": <Reorg>,
//  }

gRPC Request: chainrpc.ConfRequest

Parameter Type Description
txid bytes The transaction hash for which we should request a confirmation notification for. If set to a hash of all zeros, then the confirmation notification will be requested for the script instead.
script bytes An output script within a transaction with the hash above which will be used by light clients to match block filters. If the transaction hash is set to a hash of all zeros, then a confirmation notification will be requested for this script instead.
num_confs uint32 The number of desired confirmations the transaction/output script should reach before dispatching a confirmation notification.
height_hint uint32 The earliest height in the chain for which the transaction/output script could have been included in a block. This should in most cases be set to the broadcast height of the transaction/output script.

gRPC Response: chainrpc.ConfEvent (Streaming)

Parameter Type Description
conf ConfDetails An event that includes the confirmation details of the request (txid/ouput script).
reorg Reorg An event send when the transaction of the request is reorged out of the chain.

RegisterSpendNtfn

Server-streaming RPC

RegisterSpendNtfn is a synchronous response-streaming RPC that registers an intent for a client to be notification once a spend request has been spent by a transaction that has confirmed on-chain. A client can specify whether the spend request should be for a particular outpoint or for an output script by specifying a zero outpoint.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/chainrpc/chainnotifier.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import chainnotifier_pb2 as chainrpc, chainnotifier_pb2_grpc as chainnotifierstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = chainnotifierstub.ChainNotifierStub(channel)
>>> request = chainrpc.SpendRequest(
        outpoint=<Outpoint>,
        script=<bytes>,
        height_hint=<uint32>,
    )
>>> for response in stub.RegisterSpendNtfn(request, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "spend": <SpendDetails>,
    "reorg": <Reorg>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync(['rpc.proto', 'chainrpc/chainnotifier.proto'], loaderOptions);
const chainrpc = grpc.loadPackageDefinition(packageDefinition).chainrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let chainNotifier = new chainrpc.ChainNotifier('localhost:10009', creds);
let request = { 
  outpoint: <Outpoint>, 
  script: <bytes>, 
  height_hint: <uint32>, 
}; 
let call = chainNotifier.registerSpendNtfn(request);
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
// Console output:
//  { 
//      "spend": <SpendDetails>,
//      "reorg": <Reorg>,
//  }

gRPC Request: chainrpc.SpendRequest

Parameter Type Description
outpoint Outpoint The outpoint for which we should request a spend notification for. If set to a zero outpoint, then the spend notification will be requested for the script instead.
script bytes The output script for the outpoint above. This will be used by light clients to match block filters. If the outpoint is set to a zero outpoint, then a spend notification will be requested for this script instead.
height_hint uint32 The earliest height in the chain for which the outpoint/output script could have been spent. This should in most cases be set to the broadcast height of the outpoint/output script.

gRPC Response: chainrpc.SpendEvent (Streaming)

Parameter Type Description
spend SpendDetails An event that includes the details of the spending transaction of the request (outpoint/output script).
reorg Reorg An event sent when the spending transaction of the request was reorged out of the chain.

Service Invoices

AddHoldInvoice

Unary RPC

AddHoldInvoice creates a hold invoice. It ties the invoice to the hash supplied in the request.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/invoicesrpc/invoices.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import invoices_pb2 as invoicesrpc, invoices_pb2_grpc as invoicesstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = invoicesstub.InvoicesStub(channel)
>>> request = invoicesrpc.AddHoldInvoiceRequest(
        memo=<string>,
        hash=<bytes>,
        value=<int64>,
        value_msat=<int64>,
        description_hash=<bytes>,
        expiry=<int64>,
        fallback_addr=<string>,
        cltv_expiry=<uint64>,
        route_hints=<array RouteHint>,
        private=<bool>,
    )
>>> response = stub.AddHoldInvoice(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "payment_request": <string>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync(['rpc.proto', 'invoicesrpc/invoices.proto'], loaderOptions);
const invoicesrpc = grpc.loadPackageDefinition(packageDefinition).invoicesrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let invoices = new invoicesrpc.Invoices('localhost:10009', creds);
let request = { 
  memo: <string>, 
  hash: <bytes>, 
  value: <int64>, 
  value_msat: <int64>, 
  description_hash: <bytes>, 
  expiry: <int64>, 
  fallback_addr: <string>, 
  cltv_expiry: <uint64>, 
  route_hints: <array RouteHint>, 
  private: <bool>, 
}; 
invoices.addHoldInvoice(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "payment_request": <string>,
//  }

gRPC Request: invoicesrpc.AddHoldInvoiceRequest

Parameter Type Description
memo string An optional memo to attach along with the invoice. Used for record keeping purposes for the invoice's creator, and will also be set in the description field of the encoded payment request if the description_hash field is not being used.
hash bytes The hash of the preimage
value int64 The value of this invoice in satoshis The fields value and value_msat are mutually exclusive.
value_msat int64 The value of this invoice in millisatoshis The fields value and value_msat are mutually exclusive.
description_hash bytes Hash (SHA-256) of a description of the payment. Used if the description of payment (memo) is too long to naturally fit within the description field of an encoded payment request.
expiry int64 Payment request expiry time in seconds. Default is 3600 (1 hour).
fallback_addr string Fallback on-chain address.
cltv_expiry uint64 Delta to use for the time-lock of the CLTV extended to the final hop.
route_hints array RouteHint Route hints that can each be individually used to assist in reaching the invoice's destination.
private bool Whether this invoice should include routing hints for private channels.

gRPC Response: invoicesrpc.AddHoldInvoiceResp

Parameter Type Description
payment_request string A bare-bones invoice for a payment within the Lightning Network. With the details of the invoice, the sender has all the data necessary to send a payment to the recipient.

CancelInvoice

Unary RPC

CancelInvoice cancels a currently open invoice. If the invoice is already canceled, this call will succeed. If the invoice is already settled, it will fail.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/invoicesrpc/invoices.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import invoices_pb2 as invoicesrpc, invoices_pb2_grpc as invoicesstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = invoicesstub.InvoicesStub(channel)
>>> request = invoicesrpc.CancelInvoiceMsg(
        payment_hash=<bytes>,
    )
>>> response = stub.CancelInvoice(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync(['rpc.proto', 'invoicesrpc/invoices.proto'], loaderOptions);
const invoicesrpc = grpc.loadPackageDefinition(packageDefinition).invoicesrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let invoices = new invoicesrpc.Invoices('localhost:10009', creds);
let request = { 
  payment_hash: <bytes>, 
}; 
invoices.cancelInvoice(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//  }

gRPC Request: invoicesrpc.CancelInvoiceMsg

Parameter Type Description
payment_hash bytes Hash corresponding to the (hold) invoice to cancel.

gRPC Response: invoicesrpc.CancelInvoiceResp

This response has no parameters.

SettleInvoice

Unary RPC

SettleInvoice settles an accepted invoice. If the invoice is already settled, this call will succeed.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/invoicesrpc/invoices.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import invoices_pb2 as invoicesrpc, invoices_pb2_grpc as invoicesstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = invoicesstub.InvoicesStub(channel)
>>> request = invoicesrpc.SettleInvoiceMsg(
        preimage=<bytes>,
    )
>>> response = stub.SettleInvoice(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync(['rpc.proto', 'invoicesrpc/invoices.proto'], loaderOptions);
const invoicesrpc = grpc.loadPackageDefinition(packageDefinition).invoicesrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let invoices = new invoicesrpc.Invoices('localhost:10009', creds);
let request = { 
  preimage: <bytes>, 
}; 
invoices.settleInvoice(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//  }

gRPC Request: invoicesrpc.SettleInvoiceMsg

Parameter Type Description
preimage bytes Externally discovered pre-image that should be used to settle the hold / invoice.

gRPC Response: invoicesrpc.SettleInvoiceResp

This response has no parameters.

SubscribeSingleInvoice

Server-streaming RPC

SubscribeSingleInvoice returns a uni-directional stream (server -> client) to notify the client of state transitions of the specified invoice. Initially the current invoice state is always sent out.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/invoicesrpc/invoices.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import invoices_pb2 as invoicesrpc, invoices_pb2_grpc as invoicesstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = invoicesstub.InvoicesStub(channel)
>>> request = invoicesrpc.SubscribeSingleInvoiceRequest(
        r_hash=<bytes>,
    )
>>> for response in stub.SubscribeSingleInvoice(request, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "memo": <string>,
    "r_preimage": <bytes>,
    "r_hash": <bytes>,
    "value": <int64>,
    "value_msat": <int64>,
    "settled": <bool>,
    "creation_date": <int64>,
    "settle_date": <int64>,
    "payment_request": <string>,
    "description_hash": <bytes>,
    "expiry": <int64>,
    "fallback_addr": <string>,
    "cltv_expiry": <uint64>,
    "route_hints": <array RouteHint>,
    "private": <bool>,
    "add_index": <uint64>,
    "settle_index": <uint64>,
    "amt_paid": <int64>,
    "amt_paid_sat": <int64>,
    "amt_paid_msat": <int64>,
    "state": <InvoiceState>,
    "htlcs": <array InvoiceHTLC>,
    "features": <array FeaturesEntry>,
    "is_keysend": <bool>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync(['rpc.proto', 'invoicesrpc/invoices.proto'], loaderOptions);
const invoicesrpc = grpc.loadPackageDefinition(packageDefinition).invoicesrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let invoices = new invoicesrpc.Invoices('localhost:10009', creds);
let request = { 
  r_hash: <bytes>, 
}; 
let call = invoices.subscribeSingleInvoice(request);
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
// Console output:
//  { 
//      "memo": <string>,
//      "r_preimage": <bytes>,
//      "r_hash": <bytes>,
//      "value": <int64>,
//      "value_msat": <int64>,
//      "settled": <bool>,
//      "creation_date": <int64>,
//      "settle_date": <int64>,
//      "payment_request": <string>,
//      "description_hash": <bytes>,
//      "expiry": <int64>,
//      "fallback_addr": <string>,
//      "cltv_expiry": <uint64>,
//      "route_hints": <array RouteHint>,
//      "private": <bool>,
//      "add_index": <uint64>,
//      "settle_index": <uint64>,
//      "amt_paid": <int64>,
//      "amt_paid_sat": <int64>,
//      "amt_paid_msat": <int64>,
//      "state": <InvoiceState>,
//      "htlcs": <array InvoiceHTLC>,
//      "features": <array FeaturesEntry>,
//      "is_keysend": <bool>,
//  }

gRPC Request: invoicesrpc.SubscribeSingleInvoiceRequest

Parameter Type Description
r_hash bytes Hash corresponding to the (hold) invoice to subscribe to.

gRPC Response: lnrpc.Invoice (Streaming)

Parameter Type Description
memo string An optional memo to attach along with the invoice. Used for record keeping purposes for the invoice's creator, and will also be set in the description field of the encoded payment request if the description_hash field is not being used.
r_preimage bytes The hex-encoded preimage (32 byte) which will allow settling an incoming HTLC payable to this preimage. When using REST, this field must be encoded as base64.
r_hash bytes The hash of the preimage. When using REST, this field must be encoded as base64.
value int64 The value of this invoice in satoshis The fields value and value_msat are mutually exclusive.
value_msat int64 The value of this invoice in millisatoshis The fields value and value_msat are mutually exclusive.
settled bool Whether this invoice has been fulfilled
creation_date int64 When this invoice was created
settle_date int64 When this invoice was settled
payment_request string A bare-bones invoice for a payment within the Lightning Network. With the details of the invoice, the sender has all the data necessary to send a payment to the recipient.
description_hash bytes Hash (SHA-256) of a description of the payment. Used if the description of payment (memo) is too long to naturally fit within the description field of an encoded payment request. When using REST, this field must be encoded as base64.
expiry int64 Payment request expiry time in seconds. Default is 3600 (1 hour).
fallback_addr string Fallback on-chain address.
cltv_expiry uint64 Delta to use for the time-lock of the CLTV extended to the final hop.
route_hints array RouteHint Route hints that can each be individually used to assist in reaching the invoice's destination.
private bool Whether this invoice should include routing hints for private channels.
add_index uint64 The "add" index of this invoice. Each newly created invoice will increment this index making it monotonically increasing. Callers to the SubscribeInvoices call can use this to instantly get notified of all added invoices with an add_index greater than this one.
settle_index uint64 The "settle" index of this invoice. Each newly settled invoice will increment this index making it monotonically increasing. Callers to the SubscribeInvoices call can use this to instantly get notified of all settled invoices with an settle_index greater than this one.
amt_paid int64 Deprecated, use amt_paid_sat or amt_paid_msat.
amt_paid_sat int64 The amount that was accepted for this invoice, in satoshis. This will ONLY be set if this invoice has been settled. We provide this field as if the invoice was created with a zero value, then we need to record what amount was ultimately accepted. Additionally, it's possible that the sender paid MORE that was specified in the original invoice. So we'll record that here as well.
amt_paid_msat int64 The amount that was accepted for this invoice, in millisatoshis. This will ONLY be set if this invoice has been settled. We provide this field as if the invoice was created with a zero value, then we need to record what amount was ultimately accepted. Additionally, it's possible that the sender paid MORE that was specified in the original invoice. So we'll record that here as well.
state InvoiceState The state the invoice is in.
htlcs array InvoiceHTLC List of HTLCs paying to this invoice [EXPERIMENTAL].
features array FeaturesEntry List of features advertised on the invoice.
is_keysend bool Indicates if this invoice was a spontaneous payment that arrived via keysend [EXPERIMENTAL].

Service Lightning

AbandonChannel

Unary RPC

AbandonChannel removes all channel state from the database except for a close summary. This method can be used to get rid of permanently unusable channels due to bugs fixed in newer versions of lnd. Only available when in debug builds of lnd.


# Removes all channel state from the database except for a close
# summary. This method can be used to get rid of permanently unusable
# channels due to bugs fixed in newer versions of lnd.
# Only available when lnd is built in debug mode.
# To view which funding_txids/output_indexes can be used for this command,
# see the channel_point values within the listchannels command output.
# The format for a channel_point is 'funding_txid:output_index'.

$ lncli abandonchannel [command options] funding_txid [output_index]

# --funding_txid value  the txid of the channel's funding transaction
# --output_index value  the output index for the funding output of the funding transaction (default: 0)
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.AbandonChannelRequest(
        channel_point=<ChannelPoint>,
    )
>>> response = stub.AbandonChannel(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  channel_point: <ChannelPoint>, 
}; 
lightning.abandonChannel(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//  }

gRPC Request: lnrpc.AbandonChannelRequest

Parameter Type Description
channel_point ChannelPoint

gRPC Response: lnrpc.AbandonChannelResponse

This response has no parameters.

AddInvoice

Unary RPC

AddInvoice attempts to add a new invoice to the invoice database. Any duplicated invoices are rejected, therefore all invoices must have a unique payment preimage.


# Add a new invoice, expressing intent for a future payment.
# Invoices without an amount can be created by not supplying any
# parameters or providing an amount of 0. These invoices allow the payee
# to specify the amount of satoshis they wish to send.

$ lncli addinvoice [command options] value preimage

# --memo value              a description of the payment to attach along with the invoice (default="")
# --preimage value          the hex-encoded preimage (32 byte) which will allow settling an incoming HTLC payable to this preimage. If not set, a random preimage will be created.
# --amt value               the amt of satoshis in this invoice (default: 0)
# --description_hash value  SHA-256 hash of the description of the payment. Used if the purpose of payment cannot naturally fit within the memo. If provided this will be used instead of the description(memo) field in the encoded invoice.
# --fallback_addr value     fallback on-chain address that can be used in case the lightning payment fails
# --expiry value            the invoice's expiry time in seconds. If not specified an expiry of 3600 seconds (1 hour) is implied. (default: 0)
# --private                 encode routing hints in the invoice with private channels in order to assist the payer in reaching you
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.Invoice(
        memo=<string>,
        r_preimage=<bytes>,
        r_hash=<bytes>,
        value=<int64>,
        value_msat=<int64>,
        settled=<bool>,
        creation_date=<int64>,
        settle_date=<int64>,
        payment_request=<string>,
        description_hash=<bytes>,
        expiry=<int64>,
        fallback_addr=<string>,
        cltv_expiry=<uint64>,
        route_hints=<array RouteHint>,
        private=<bool>,
        add_index=<uint64>,
        settle_index=<uint64>,
        amt_paid=<int64>,
        amt_paid_sat=<int64>,
        amt_paid_msat=<int64>,
        state=<InvoiceState>,
        htlcs=<array InvoiceHTLC>,
        features=<array FeaturesEntry>,
        is_keysend=<bool>,
    )
>>> response = stub.AddInvoice(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "r_hash": <bytes>,
    "payment_request": <string>,
    "add_index": <uint64>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  memo: <string>, 
  r_preimage: <bytes>, 
  r_hash: <bytes>, 
  value: <int64>, 
  value_msat: <int64>, 
  settled: <bool>, 
  creation_date: <int64>, 
  settle_date: <int64>, 
  payment_request: <string>, 
  description_hash: <bytes>, 
  expiry: <int64>, 
  fallback_addr: <string>, 
  cltv_expiry: <uint64>, 
  route_hints: <array RouteHint>, 
  private: <bool>, 
  add_index: <uint64>, 
  settle_index: <uint64>, 
  amt_paid: <int64>, 
  amt_paid_sat: <int64>, 
  amt_paid_msat: <int64>, 
  state: <InvoiceState>, 
  htlcs: <array InvoiceHTLC>, 
  features: <array FeaturesEntry>, 
  is_keysend: <bool>, 
}; 
lightning.addInvoice(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "r_hash": <bytes>,
//      "payment_request": <string>,
//      "add_index": <uint64>,
//  }

gRPC Request: lnrpc.Invoice

Parameter Type Description
memo string An optional memo to attach along with the invoice. Used for record keeping purposes for the invoice's creator, and will also be set in the description field of the encoded payment request if the description_hash field is not being used.
r_preimage bytes The hex-encoded preimage (32 byte) which will allow settling an incoming HTLC payable to this preimage. When using REST, this field must be encoded as base64.
r_hash bytes The hash of the preimage. When using REST, this field must be encoded as base64.
value int64 The value of this invoice in satoshis The fields value and value_msat are mutually exclusive.
value_msat int64 The value of this invoice in millisatoshis The fields value and value_msat are mutually exclusive.
settled bool Whether this invoice has been fulfilled
creation_date int64 When this invoice was created
settle_date int64 When this invoice was settled
payment_request string A bare-bones invoice for a payment within the Lightning Network. With the details of the invoice, the sender has all the data necessary to send a payment to the recipient.
description_hash bytes Hash (SHA-256) of a description of the payment. Used if the description of payment (memo) is too long to naturally fit within the description field of an encoded payment request. When using REST, this field must be encoded as base64.
expiry int64 Payment request expiry time in seconds. Default is 3600 (1 hour).
fallback_addr string Fallback on-chain address.
cltv_expiry uint64 Delta to use for the time-lock of the CLTV extended to the final hop.
route_hints array RouteHint Route hints that can each be individually used to assist in reaching the invoice's destination.
private bool Whether this invoice should include routing hints for private channels.
add_index uint64 The "add" index of this invoice. Each newly created invoice will increment this index making it monotonically increasing. Callers to the SubscribeInvoices call can use this to instantly get notified of all added invoices with an add_index greater than this one.
settle_index uint64 The "settle" index of this invoice. Each newly settled invoice will increment this index making it monotonically increasing. Callers to the SubscribeInvoices call can use this to instantly get notified of all settled invoices with an settle_index greater than this one.
amt_paid int64 Deprecated, use amt_paid_sat or amt_paid_msat.
amt_paid_sat int64 The amount that was accepted for this invoice, in satoshis. This will ONLY be set if this invoice has been settled. We provide this field as if the invoice was created with a zero value, then we need to record what amount was ultimately accepted. Additionally, it's possible that the sender paid MORE that was specified in the original invoice. So we'll record that here as well.
amt_paid_msat int64 The amount that was accepted for this invoice, in millisatoshis. This will ONLY be set if this invoice has been settled. We provide this field as if the invoice was created with a zero value, then we need to record what amount was ultimately accepted. Additionally, it's possible that the sender paid MORE that was specified in the original invoice. So we'll record that here as well.
state InvoiceState The state the invoice is in.
htlcs array InvoiceHTLC List of HTLCs paying to this invoice [EXPERIMENTAL].
features array FeaturesEntry List of features advertised on the invoice.
is_keysend bool Indicates if this invoice was a spontaneous payment that arrived via keysend [EXPERIMENTAL].

gRPC Response: lnrpc.AddInvoiceResponse

Parameter Type Description
r_hash bytes
payment_request string A bare-bones invoice for a payment within the Lightning Network. With the details of the invoice, the sender has all the data necessary to send a payment to the recipient.
add_index uint64 The "add" index of this invoice. Each newly created invoice will increment this index making it monotonically increasing. Callers to the SubscribeInvoices call can use this to instantly get notified of all added invoices with an add_index greater than this one.

BakeMacaroon

Unary RPC

BakeMacaroon allows the creation of a new macaroon with custom read and write permissions. No first-party caveats are added since this can be done offline.


# Bake a new macaroon that grants the provided permissions and
# optionally adds restrictions (timeout, IP address) to it.
# The new macaroon can either be shown on command line in hex serialized
# format or it can be saved directly to a file using the --save_to
# argument.
# A permission is a tuple of an entity and an action, separated by a
# colon. Multiple operations can be added as arguments, for example:
# lncli bakemacaroon info:read invoices:write foo:bar

$ lncli bakemacaroon [command options] [--save_to=] [--timeout=] [--ip_address=] permissions...

# --save_to value     save the created macaroon to this file using the default binary format
# --timeout value     the number of seconds the macaroon will be valid before it times out (default: 0)
# --ip_address value  the IP address the macaroon will be bound to
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.BakeMacaroonRequest(
        permissions=<array MacaroonPermission>,
    )
>>> response = stub.BakeMacaroon(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "macaroon": <string>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  permissions: <array MacaroonPermission>, 
}; 
lightning.bakeMacaroon(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "macaroon": <string>,
//  }

gRPC Request: lnrpc.BakeMacaroonRequest

Parameter Type Description
permissions array MacaroonPermission The list of permissions the new macaroon should grant.

gRPC Response: lnrpc.BakeMacaroonResponse

Parameter Type Description
macaroon string The hex encoded macaroon, serialized in binary format.

ChannelAcceptor

Bidirectional-streaming RPC

ChannelAcceptor dispatches a bi-directional streaming RPC in which OpenChannel requests are sent to the client and the client responds with a boolean that tells LND whether or not to accept the channel. This allows node operators to specify their own criteria for accepting inbound channels through a single persistent connection.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
# Define a generator that returns an Iterable of lnrpc.ChannelAcceptResponse objects.
>>> def request_generator():
        # Initialization code here.
        while True:
            # Parameters here can be set as arguments to the generator.
            request = lnrpc.ChannelAcceptResponse(
                accept=<bool>,
                pending_chan_id=<bytes>,
            )
            yield request
            # Do things between iterations here.
>>> request_iterable = request_generator()
>>> for response in stub.ChannelAcceptor(request_iterable, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "node_pubkey": <bytes>,
    "chain_hash": <bytes>,
    "pending_chan_id": <bytes>,
    "funding_amt": <uint64>,
    "push_amt": <uint64>,
    "dust_limit": <uint64>,
    "max_value_in_flight": <uint64>,
    "channel_reserve": <uint64>,
    "min_htlc": <uint64>,
    "fee_per_kw": <uint64>,
    "csv_delay": <uint32>,
    "max_accepted_htlcs": <uint32>,
    "channel_flags": <uint32>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  accept: <bool>, 
  pending_chan_id: <bytes>, 
}; 
let call = lightning.channelAcceptor({});
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
call.write(request);
// Console output:
//  { 
//      "node_pubkey": <bytes>,
//      "chain_hash": <bytes>,
//      "pending_chan_id": <bytes>,
//      "funding_amt": <uint64>,
//      "push_amt": <uint64>,
//      "dust_limit": <uint64>,
//      "max_value_in_flight": <uint64>,
//      "channel_reserve": <uint64>,
//      "min_htlc": <uint64>,
//      "fee_per_kw": <uint64>,
//      "csv_delay": <uint32>,
//      "max_accepted_htlcs": <uint32>,
//      "channel_flags": <uint32>,
//  }

gRPC Request: lnrpc.ChannelAcceptResponse (Streaming)

Parameter Type Description
accept bool Whether or not the client accepts the channel.
pending_chan_id bytes The pending channel id to which this response applies.

gRPC Response: lnrpc.ChannelAcceptRequest (Streaming)

Parameter Type Description
node_pubkey bytes The pubkey of the node that wishes to open an inbound channel.
chain_hash bytes The hash of the genesis block that the proposed channel resides in.
pending_chan_id bytes The pending channel id.
funding_amt uint64 The funding amount in satoshis that initiator wishes to use in the / channel.
push_amt uint64 The push amount of the proposed channel in millisatoshis.
dust_limit uint64 The dust limit of the initiator's commitment tx.
max_value_in_flight uint64 The maximum amount of coins in millisatoshis that can be pending in this / channel.
channel_reserve uint64 The minimum amount of satoshis the initiator requires us to have at all / times.
min_htlc uint64 The smallest HTLC in millisatoshis that the initiator will accept.
fee_per_kw uint64 The initial fee rate that the initiator suggests for both commitment / transactions.
csv_delay uint32 The number of blocks to use for the relative time lock in the pay-to-self output of both commitment transactions.
max_accepted_htlcs uint32 The total number of incoming HTLC's that the initiator will accept.
channel_flags uint32 A bit-field which the initiator uses to specify proposed channel / behavior.

ChannelBalance

Unary RPC

ChannelBalance returns the total funds available across all open channels in satoshis.


# Returns the sum of the total available channel balance across all open channels.

$ lncli channelbalance [arguments...]

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ChannelBalanceRequest()
>>> response = stub.ChannelBalance(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "balance": <int64>,
    "pending_open_balance": <int64>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = {}; 
lightning.channelBalance(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "balance": <int64>,
//      "pending_open_balance": <int64>,
//  }

gRPC Request: lnrpc.ChannelBalanceRequest

This request has no parameters.

gRPC Response: lnrpc.ChannelBalanceResponse

Parameter Type Description
balance int64 Sum of channels balances denominated in satoshis
pending_open_balance int64 Sum of channels pending balances denominated in satoshis

CloseChannel

Server-streaming RPC

CloseChannel attempts to close an active channel identified by its channel outpoint (ChannelPoint). The actions of this method can additionally be augmented to attempt a force close after a timeout period in the case of an inactive peer. If a non-force close (cooperative closure) is requested, then the user can specify either a target number of blocks until the closure transaction is confirmed, or a manual fee rate. If neither are specified, then a default lax, block confirmation target is used.


# Close an existing channel. The channel can be closed either cooperatively,
# or unilaterally (--force).
# A unilateral channel closure means that the latest commitment
# transaction will be broadcast to the network. As a result, any settled
# funds will be time locked for a few blocks before they can be spent.
# In the case of a cooperative closure, one can manually set the fee to
# be used for the closing transaction via either the --conf_target or
# --sat_per_byte arguments. This will be the starting value used during
# fee negotiation. This is optional.
# In the case of a cooperative closure, one can manually set the address
# to deliver funds to upon closure. This is optional, and may only be used
# if an upfront shutdown address has not already been set. If neither are
# set the funds will be delivered to a new wallet address.
# To view which funding_txids/output_indexes can be used for a channel close,
# see the channel_point values within the listchannels command output.
# The format for a channel_point is 'funding_txid:output_index'.

$ lncli closechannel [command options] funding_txid [output_index]

# --funding_txid value   the txid of the channel's funding transaction
# --output_index value   the output index for the funding output of the funding transaction (default: 0)
# --force                attempt an uncooperative closure
# --block                block until the channel is closed
# --conf_target value    (optional) the number of blocks that the transaction *should* confirm in, will be used for fee estimation (default: 0)
# --sat_per_byte value   (optional) a manual fee expressed in sat/byte that should be used when crafting the transaction (default: 0)
# --delivery_addr value  (optional) an address to deliver funds upon cooperative channel closing, may only be used if an upfront shutdown addresss is notalready set
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.CloseChannelRequest(
        channel_point=<ChannelPoint>,
        force=<bool>,
        target_conf=<int32>,
        sat_per_byte=<int64>,
        delivery_address=<string>,
    )
>>> for response in stub.CloseChannel(request, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "close_pending": <PendingUpdate>,
    "chan_close": <ChannelCloseUpdate>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  channel_point: <ChannelPoint>, 
  force: <bool>, 
  target_conf: <int32>, 
  sat_per_byte: <int64>, 
  delivery_address: <string>, 
}; 
let call = lightning.closeChannel(request);
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
// Console output:
//  { 
//      "close_pending": <PendingUpdate>,
//      "chan_close": <ChannelCloseUpdate>,
//  }

gRPC Request: lnrpc.CloseChannelRequest

Parameter Type Description
channel_point ChannelPoint The outpoint (txid:index) of the funding transaction. With this value, Bob will be able to generate a signature for Alice's version of the commitment transaction.
force bool If true, then the channel will be closed forcibly. This means the / current commitment transaction will be signed and broadcast.
target_conf int32 The target number of blocks that the closure transaction should be / confirmed by.
sat_per_byte int64 A manual fee rate set in sat/byte that should be used when crafting the / closure transaction.
delivery_address string An optional address to send funds to in the case of a cooperative close. If the channel was opened with an upfront shutdown script and this field is set, the request to close will fail because the channel must pay out to the upfront shutdown addresss.

gRPC Response: lnrpc.CloseStatusUpdate (Streaming)

Parameter Type Description
close_pending PendingUpdate
chan_close ChannelCloseUpdate

ClosedChannels

Unary RPC

ClosedChannels returns a description of all the closed channels that this node was a participant in.


# List all closed channels.

$ lncli closedchannels [command options] [arguments...]

# --cooperative       list channels that were closed cooperatively
# --local_force       list channels that were force-closed by the local node
# --remote_force      list channels that were force-closed by the remote node
# --breach            list channels for which the remote node attempted to broadcast a prior revoked channel state
# --funding_canceled  list channels that were never fully opened
# --abandoned         list channels that were abandoned by the local node
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ClosedChannelsRequest(
        cooperative=<bool>,
        local_force=<bool>,
        remote_force=<bool>,
        breach=<bool>,
        funding_canceled=<bool>,
        abandoned=<bool>,
    )
>>> response = stub.ClosedChannels(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "channels": <array ChannelCloseSummary>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  cooperative: <bool>, 
  local_force: <bool>, 
  remote_force: <bool>, 
  breach: <bool>, 
  funding_canceled: <bool>, 
  abandoned: <bool>, 
}; 
lightning.closedChannels(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "channels": <array ChannelCloseSummary>,
//  }

gRPC Request: lnrpc.ClosedChannelsRequest

Parameter Type Description
cooperative bool
local_force bool
remote_force bool
breach bool
funding_canceled bool
abandoned bool

gRPC Response: lnrpc.ClosedChannelsResponse

Parameter Type Description
channels array ChannelCloseSummary

ConnectPeer

Unary RPC

ConnectPeer attempts to establish a connection to a remote peer. This is at the networking level, and is used for communication between nodes. This is distinct from establishing a channel with a peer.


# Connect to a remote lnd peer.

$ lncli connect [command options] <pubkey>@host

# --perm  If set, the daemon will attempt to persistently connect to the target peer.
# If not, the call will be synchronous.
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ConnectPeerRequest(
        addr=<LightningAddress>,
        perm=<bool>,
    )
>>> response = stub.ConnectPeer(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  addr: <LightningAddress>, 
  perm: <bool>, 
}; 
lightning.connectPeer(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//  }

gRPC Request: lnrpc.ConnectPeerRequest

Parameter Type Description
addr LightningAddress Lightning address of the peer, in the format <pubkey>@host
perm bool If set, the daemon will attempt to persistently connect to the target peer. Otherwise, the call will be synchronous.

gRPC Response: lnrpc.ConnectPeerResponse

This response has no parameters.

DebugLevel

Unary RPC

DebugLevel allows a caller to programmatically set the logging verbosity of lnd. The logging can be targeted according to a coarse daemon-wide logging level, or in a granular fashion to specify the logging for a target sub-system.


# Logging level for all subsystems {trace, debug, info, warn, error, critical, off}
# You may also specify <subsystem>=<level>,<subsystem2>=<level>,... to set the log level for individual subsystems
# Use show to list available subsystems

$ lncli debuglevel [command options] [arguments...]

# --show         if true, then the list of available sub-systems will be printed out
# --level value  the level specification to target either a coarse logging level, or granular set of specific sub-systems with logging levels for each
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.DebugLevelRequest(
        show=<bool>,
        level_spec=<string>,
    )
>>> response = stub.DebugLevel(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "sub_systems": <string>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  show: <bool>, 
  level_spec: <string>, 
}; 
lightning.debugLevel(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "sub_systems": <string>,
//  }

gRPC Request: lnrpc.DebugLevelRequest

Parameter Type Description
show bool
level_spec string

gRPC Response: lnrpc.DebugLevelResponse

Parameter Type Description
sub_systems string

DecodePayReq

Unary RPC

DecodePayReq takes an encoded payment request string and attempts to decode it, returning a full description of the conditions encoded within the payment request.


# Decode the passed payment request revealing the destination, payment hash and value of the payment request

$ lncli decodepayreq [command options] pay_req

# --pay_req value  the bech32 encoded payment request
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.PayReqString(
        pay_req=<string>,
    )
>>> response = stub.DecodePayReq(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "destination": <string>,
    "payment_hash": <string>,
    "num_satoshis": <int64>,
    "timestamp": <int64>,
    "expiry": <int64>,
    "description": <string>,
    "description_hash": <string>,
    "fallback_addr": <string>,
    "cltv_expiry": <int64>,
    "route_hints": <array RouteHint>,
    "payment_addr": <bytes>,
    "num_msat": <int64>,
    "features": <array FeaturesEntry>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  pay_req: <string>, 
}; 
lightning.decodePayReq(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "destination": <string>,
//      "payment_hash": <string>,
//      "num_satoshis": <int64>,
//      "timestamp": <int64>,
//      "expiry": <int64>,
//      "description": <string>,
//      "description_hash": <string>,
//      "fallback_addr": <string>,
//      "cltv_expiry": <int64>,
//      "route_hints": <array RouteHint>,
//      "payment_addr": <bytes>,
//      "num_msat": <int64>,
//      "features": <array FeaturesEntry>,
//  }

gRPC Request: lnrpc.PayReqString

Parameter Type Description
pay_req string The payment request string to be decoded

gRPC Response: lnrpc.PayReq

Parameter Type Description
destination string
payment_hash string
num_satoshis int64
timestamp int64
expiry int64
description string
description_hash string
fallback_addr string
cltv_expiry int64
route_hints array RouteHint
payment_addr bytes
num_msat int64
features array FeaturesEntry

DeleteAllPayments

Unary RPC

DeleteAllPayments deletes all outgoing payments from DB.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.DeleteAllPaymentsRequest()
>>> response = stub.DeleteAllPayments(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = {}; 
lightning.deleteAllPayments(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//  }

gRPC Request: lnrpc.DeleteAllPaymentsRequest

This request has no parameters.

gRPC Response: lnrpc.DeleteAllPaymentsResponse

This response has no parameters.

DescribeGraph

Unary RPC

DescribeGraph returns a description of the latest graph state from the point of view of the node. The graph information is partitioned into two components: all the nodes/vertexes, and all the edges that connect the vertexes themselves. As this is a directed graph, the edges also contain the node directional specific routing policy which includes: the time lock delta, fee information, etc.


# Prints a human readable version of the known channel graph from the PoV of the node

$ lncli describegraph [command options] [arguments...]

# --include_unannounced  If set, unannounced channels will be included in the graph. Unannounced channels are both private channels, and public channels that are not yet announced to the network.
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ChannelGraphRequest(
        include_unannounced=<bool>,
    )
>>> response = stub.DescribeGraph(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "nodes": <array LightningNode>,
    "edges": <array ChannelEdge>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  include_unannounced: <bool>, 
}; 
lightning.describeGraph(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "nodes": <array LightningNode>,
//      "edges": <array ChannelEdge>,
//  }

gRPC Request: lnrpc.ChannelGraphRequest

Parameter Type Description
include_unannounced bool Whether unannounced channels are included in the response or not. If set, unannounced channels are included. Unannounced channels are both private channels, and public channels that are not yet announced to the network.

gRPC Response: lnrpc.ChannelGraph

Parameter Type Description
nodes array LightningNode The list of LightningNodes in this channel graph
edges array ChannelEdge The list of ChannelEdges in this channel graph

DisconnectPeer

Unary RPC

DisconnectPeer attempts to disconnect one peer from another identified by a given pubKey. In the case that we currently have a pending or active channel with the target peer, then this action will be not be allowed.


# Disconnect a remote lnd peer identified by public key.

$ lncli disconnect [command options] <pubkey>

# --node_key value  The hex-encoded compressed public key of the peer to disconnect from
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.DisconnectPeerRequest(
        pub_key=<string>,
    )
>>> response = stub.DisconnectPeer(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  pub_key: <string>, 
}; 
lightning.disconnectPeer(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//  }

gRPC Request: lnrpc.DisconnectPeerRequest

Parameter Type Description
pub_key string The pubkey of the node to disconnect from

gRPC Response: lnrpc.DisconnectPeerResponse

This response has no parameters.

EstimateFee

Unary RPC

EstimateFee asks the chain backend to estimate the fee rate and total fees for a transaction that pays to multiple specified outputs.


# Get fee estimates for sending a transaction paying the specified amount(s) to the passed address(es).
# The send-json-string' param decodes addresses and the amount to send respectively in the following format:
# '{"ExampleAddr": NumCoinsInSatoshis, "SecondAddr": NumCoins}'

$ lncli estimatefee [command options] send-json-string [--conf_target=N]

# --conf_target value  (optional) the number of blocks that the transaction *should* confirm in (default: 0)
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.EstimateFeeRequest(
        AddrToAmount=<array AddrToAmountEntry>,
        target_conf=<int32>,
    )
>>> response = stub.EstimateFee(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "fee_sat": <int64>,
    "feerate_sat_per_byte": <int64>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  AddrToAmount: <array AddrToAmountEntry>, 
  target_conf: <int32>, 
}; 
lightning.estimateFee(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "fee_sat": <int64>,
//      "feerate_sat_per_byte": <int64>,
//  }

gRPC Request: lnrpc.EstimateFeeRequest

Parameter Type Description
AddrToAmount array AddrToAmountEntry The map from addresses to amounts for the transaction.
target_conf int32 The target number of blocks that this transaction should be confirmed / by.

gRPC Response: lnrpc.EstimateFeeResponse

Parameter Type Description
fee_sat int64 The total fee in satoshis.
feerate_sat_per_byte int64 The fee rate in satoshi/byte.

ExportAllChannelBackups

Unary RPC

ExportAllChannelBackups returns static channel backups for all existing channels known to lnd. A set of regular singular static channel backups for each channel are returned. Additionally, a multi-channel backup is returned as well, which contains a single encrypted blob containing the backups of each channel.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ChanBackupExportRequest()
>>> response = stub.ExportAllChannelBackups(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "single_chan_backups": <ChannelBackups>,
    "multi_chan_backup": <MultiChanBackup>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = {}; 
lightning.exportAllChannelBackups(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "single_chan_backups": <ChannelBackups>,
//      "multi_chan_backup": <MultiChanBackup>,
//  }

gRPC Request: lnrpc.ChanBackupExportRequest

This request has no parameters.

gRPC Response: lnrpc.ChanBackupSnapshot

Parameter Type Description
single_chan_backups ChannelBackups The set of new channels that have been added since the last channel backup snapshot was requested.
multi_chan_backup MultiChanBackup A multi-channel backup that covers all open channels currently known to lnd.

ExportChannelBackup

Unary RPC

ExportChannelBackup attempts to return an encrypted static channel backup for the target channel identified by it channel point. The backup is encrypted with a key generated from the aezeed seed of the user. The returned backup can either be restored using the RestoreChannelBackup method once lnd is running, or via the InitWallet and UnlockWallet methods from the WalletUnlocker service.


# This command allows a user to export a Static Channel Backup (SCB) for
# a selected channel. SCB's are encrypted backups of a channel's initial
# state that are encrypted with a key derived from the seed of a user. In
# the case of partial or complete data loss, the SCB will allow the user
# to reclaim settled funds in the channel at its final state. The
# exported channel backups can be restored at a later time using the
# restorechanbackup command.
# This command will return one of two types of channel backups depending
# on the set of passed arguments:
# * If a target channel point is specified, then a single channel
# backup containing only the information for that channel will be
# returned.
# * If the --all flag is passed, then a multi-channel backup will be
# returned. A multi backup is a single encrypted blob (displayed in
# hex encoding) that contains several channels in a single cipher
# text.
# Both of the backup types can be restored using the restorechanbackup
# command.

$ lncli exportchanbackup [command options] [chan_point] [--all] [--output_file]

# --chan_point value   the target channel to obtain an SCB for
# --all                if specified, then a multi backup of all active channels will be returned
# --output_file value  if specified, then rather than printing a JSON output
# of the static channel backup, a serialized version of
# the backup (either Single or Multi) will be written to
# the target file, this is the same format used by lnd in
# its channels.backup file
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ExportChannelBackupRequest(
        chan_point=<ChannelPoint>,
    )
>>> response = stub.ExportChannelBackup(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "chan_point": <ChannelPoint>,
    "chan_backup": <bytes>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  chan_point: <ChannelPoint>, 
}; 
lightning.exportChannelBackup(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "chan_point": <ChannelPoint>,
//      "chan_backup": <bytes>,
//  }

gRPC Request: lnrpc.ExportChannelBackupRequest

Parameter Type Description
chan_point ChannelPoint The target channel point to obtain a back up for.

gRPC Response: lnrpc.ChannelBackup

Parameter Type Description
chan_point ChannelPoint Identifies the channel that this backup belongs to.
chan_backup bytes Is an encrypted single-chan backup. this can be passed to RestoreChannelBackups, or the WalletUnlocker Init and Unlock methods in order to trigger the recovery protocol. When using REST, this field must be encoded as base64.

FeeReport

Unary RPC

FeeReport allows the caller to obtain a report detailing the current fee schedule enforced by the node globally for each channel.


# Returns the current fee policies of all active channels.
# Fee policies can be updated using the updatechanpolicy command.

$ lncli feereport [arguments...]

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.FeeReportRequest()
>>> response = stub.FeeReport(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "channel_fees": <array ChannelFeeReport>,
    "day_fee_sum": <uint64>,
    "week_fee_sum": <uint64>,
    "month_fee_sum": <uint64>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = {}; 
lightning.feeReport(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "channel_fees": <array ChannelFeeReport>,
//      "day_fee_sum": <uint64>,
//      "week_fee_sum": <uint64>,
//      "month_fee_sum": <uint64>,
//  }

gRPC Request: lnrpc.FeeReportRequest

This request has no parameters.

gRPC Response: lnrpc.FeeReportResponse

Parameter Type Description
channel_fees array ChannelFeeReport An array of channel fee reports which describes the current fee schedule / for each channel.
day_fee_sum uint64 The total amount of fee revenue (in satoshis) the switch has collected / over the past 24 hrs.
week_fee_sum uint64 The total amount of fee revenue (in satoshis) the switch has collected / over the past 1 week.
month_fee_sum uint64 The total amount of fee revenue (in satoshis) the switch has collected / over the past 1 month.

ForwardingHistory

Unary RPC

ForwardingHistory allows the caller to query the htlcswitch for a record of all HTLCs forwarded within the target time range, and integer offset within that time range. If no time-range is specified, then the first chunk of the past 24 hrs of forwarding history are returned. A list of forwarding events are returned. The size of each forwarding event is 40 bytes, and the max message size able to be returned in gRPC is 4 MiB. As a result each message can only contain 50k entries. Each response has the index offset of the last entry. The index offset can be provided to the request to allow the caller to skip a series of records.


# Query the HTLC switch's internal forwarding log for all completed
# payment circuits (HTLCs) over a particular time range (--start_time and
# --end_time). The start and end times are meant to be expressed in
# seconds since the Unix epoch. If --start_time isn't provided,
# then 24 hours ago is used.  If --end_time isn't provided,
# then the current time is used.
# The max number of events returned is 50k. The default number is 100,
# callers can use the --max_events param to modify this value.
# Finally, callers can skip a series of events using the --index_offset
# parameter. Each response will contain the offset index of the last
# entry. Using this callers can manually paginate within a time slice.

$ lncli fwdinghistory [command options] start_time [end_time] [index_offset] [max_events]

# --start_time value    the starting time for the query, expressed in seconds since the unix epoch (default: 0)
# --end_time value      the end time for the query, expressed in seconds since the unix epoch (default: 0)
# --index_offset value  the number of events to skip (default: 0)
# --max_events value    the max number of events to return (default: 0)
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ForwardingHistoryRequest(
        start_time=<uint64>,
        end_time=<uint64>,
        index_offset=<uint32>,
        num_max_events=<uint32>,
    )
>>> response = stub.ForwardingHistory(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "forwarding_events": <array ForwardingEvent>,
    "last_offset_index": <uint32>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  start_time: <uint64>, 
  end_time: <uint64>, 
  index_offset: <uint32>, 
  num_max_events: <uint32>, 
}; 
lightning.forwardingHistory(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "forwarding_events": <array ForwardingEvent>,
//      "last_offset_index": <uint32>,
//  }

gRPC Request: lnrpc.ForwardingHistoryRequest

Parameter Type Description
start_time uint64 Start time is the starting point of the forwarding history request. All / records beyond this point will be included, respecting the end time, and / the index offset.
end_time uint64 End time is the end point of the forwarding history request. The / response will carry at most 50k records between the start time and the / end time. The index offset can be used to implement pagination.
index_offset uint32 Index offset is the offset in the time series to start at. As each / response can only contain 50k records, callers can use this to skip / around within a packed time series.
num_max_events uint32 The max number of events to return in the response to this query.

gRPC Response: lnrpc.ForwardingHistoryResponse

Parameter Type Description
forwarding_events array ForwardingEvent A list of forwarding events from the time slice of the time series / specified in the request.
last_offset_index uint32 The index of the last time in the set of returned forwarding events. Can / be used to seek further, pagination style.

FundingStateStep

Unary RPC

FundingStateStep is an advanced funding related call that allows the caller to either execute some preparatory steps for a funding workflow, or manually progress a funding workflow. The primary way a funding flow is identified is via its pending channel ID. As an example, this method can be used to specify that we're expecting a funding flow for a particular pending channel ID, for which we need to use specific parameters. Alternatively, this can be used to interactively drive PSBT signing for funding for partially complete funding transactions.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.FundingTransitionMsg(
        shim_register=<FundingShim>,
        shim_cancel=<FundingShimCancel>,
        psbt_verify=<FundingPsbtVerify>,
        psbt_finalize=<FundingPsbtFinalize>,
    )
>>> response = stub.FundingStateStep(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  shim_register: <FundingShim>, 
  shim_cancel: <FundingShimCancel>, 
  psbt_verify: <FundingPsbtVerify>, 
  psbt_finalize: <FundingPsbtFinalize>, 
}; 
lightning.fundingStateStep(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//  }

gRPC Request: lnrpc.FundingTransitionMsg

Parameter Type Description
shim_register FundingShim The funding shim to register. This should be used before any channel funding has began by the remote party, as it is intended as a preparatory step for the full channel funding.
shim_cancel FundingShimCancel Used to cancel an existing registered funding shim.
psbt_verify FundingPsbtVerify Used to continue a funding flow that was initiated to be executed through a PSBT. This step verifies that the PSBT contains the correct outputs to fund the channel.
psbt_finalize FundingPsbtFinalize Used to continue a funding flow that was initiated to be executed through a PSBT. This step finalizes the funded and signed PSBT, finishes negotiation with the peer and finally publishes the resulting funding transaction.

gRPC Response: lnrpc.FundingStateStepResp

This response has no parameters.

GetChanInfo

Unary RPC

GetChanInfo returns the latest authenticated network announcement for the given channel identified by its channel ID: an 8-byte integer which uniquely identifies the location of transaction's funding output within the blockchain.


# Prints out the latest authenticated state for a particular channel

$ lncli getchaninfo [command options] chan_id

# --chan_id value  the 8-byte compact channel ID to query for (default: 0)
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ChanInfoRequest(
        chan_id=<uint64>,
    )
>>> response = stub.GetChanInfo(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "channel_id": <uint64>,
    "chan_point": <string>,
    "last_update": <uint32>,
    "node1_pub": <string>,
    "node2_pub": <string>,
    "capacity": <int64>,
    "node1_policy": <RoutingPolicy>,
    "node2_policy": <RoutingPolicy>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  chan_id: <uint64>, 
}; 
lightning.getChanInfo(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "channel_id": <uint64>,
//      "chan_point": <string>,
//      "last_update": <uint32>,
//      "node1_pub": <string>,
//      "node2_pub": <string>,
//      "capacity": <int64>,
//      "node1_policy": <RoutingPolicy>,
//      "node2_policy": <RoutingPolicy>,
//  }

gRPC Request: lnrpc.ChanInfoRequest

Parameter Type Description
chan_id uint64 The unique channel ID for the channel. The first 3 bytes are the block height, the next 3 the index within the block, and the last 2 bytes are the output index for the channel.

gRPC Response: lnrpc.ChannelEdge

Parameter Type Description
channel_id uint64 The unique channel ID for the channel. The first 3 bytes are the block height, the next 3 the index within the block, and the last 2 bytes are the output index for the channel.
chan_point string
last_update uint32
node1_pub string
node2_pub string
capacity int64
node1_policy RoutingPolicy
node2_policy RoutingPolicy

GetInfo

Unary RPC

GetInfo returns general information concerning the lightning node including it's identity pubkey, alias, the chains it is connected to, and information concerning the number of open+pending channels.


# Returns basic information related to the active daemon.

$ lncli getinfo [arguments...]

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.GetInfoRequest()
>>> response = stub.GetInfo(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "version": <string>,
    "commit_hash": <string>,
    "identity_pubkey": <string>,
    "alias": <string>,
    "color": <string>,
    "num_pending_channels": <uint32>,
    "num_active_channels": <uint32>,
    "num_inactive_channels": <uint32>,
    "num_peers": <uint32>,
    "block_height": <uint32>,
    "block_hash": <string>,
    "best_header_timestamp": <int64>,
    "synced_to_chain": <bool>,
    "synced_to_graph": <bool>,
    "testnet": <bool>,
    "chains": <array Chain>,
    "uris": <array string>,
    "features": <array FeaturesEntry>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = {}; 
lightning.getInfo(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "version": <string>,
//      "commit_hash": <string>,
//      "identity_pubkey": <string>,
//      "alias": <string>,
//      "color": <string>,
//      "num_pending_channels": <uint32>,
//      "num_active_channels": <uint32>,
//      "num_inactive_channels": <uint32>,
//      "num_peers": <uint32>,
//      "block_height": <uint32>,
//      "block_hash": <string>,
//      "best_header_timestamp": <int64>,
//      "synced_to_chain": <bool>,
//      "synced_to_graph": <bool>,
//      "testnet": <bool>,
//      "chains": <array Chain>,
//      "uris": <array string>,
//      "features": <array FeaturesEntry>,
//  }

gRPC Request: lnrpc.GetInfoRequest

This request has no parameters.

gRPC Response: lnrpc.GetInfoResponse

Parameter Type Description
version string The version of the LND software that the node is running.
commit_hash string The SHA1 commit hash that the daemon is compiled with.
identity_pubkey string The identity pubkey of the current node.
alias string If applicable, the alias of the current node, e.g. "bob"
color string The color of the current node in hex code format
num_pending_channels uint32 Number of pending channels
num_active_channels uint32 Number of active channels
num_inactive_channels uint32 Number of inactive channels
num_peers uint32 Number of peers
block_height uint32 The node's current view of the height of the best block
block_hash string The node's current view of the hash of the best block
best_header_timestamp int64 Timestamp of the block best known to the wallet
synced_to_chain bool Whether the wallet's view is synced to the main chain
synced_to_graph bool Whether we consider ourselves synced with the public channel graph.
testnet bool Whether the current node is connected to testnet. This field is deprecated and the network field should be used instead
chains array Chain A list of active chains the node is connected to
uris array string The URIs of the current node.
features array FeaturesEntry Features that our node has advertised in our init message, node announcements and invoices.

GetNetworkInfo

Unary RPC

GetNetworkInfo returns some basic stats about the known channel graph from the point of view of the node.


# Returns a set of statistics pertaining to the known channel graph

$ lncli getnetworkinfo [arguments...]

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.NetworkInfoRequest()
>>> response = stub.GetNetworkInfo(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "graph_diameter": <uint32>,
    "avg_out_degree": <double>,
    "max_out_degree": <uint32>,
    "num_nodes": <uint32>,
    "num_channels": <uint32>,
    "total_network_capacity": <int64>,
    "avg_channel_size": <double>,
    "min_channel_size": <int64>,
    "max_channel_size": <int64>,
    "median_channel_size_sat": <int64>,
    "num_zombie_chans": <uint64>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = {}; 
lightning.getNetworkInfo(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "graph_diameter": <uint32>,
//      "avg_out_degree": <double>,
//      "max_out_degree": <uint32>,
//      "num_nodes": <uint32>,
//      "num_channels": <uint32>,
//      "total_network_capacity": <int64>,
//      "avg_channel_size": <double>,
//      "min_channel_size": <int64>,
//      "max_channel_size": <int64>,
//      "median_channel_size_sat": <int64>,
//      "num_zombie_chans": <uint64>,
//  }

gRPC Request: lnrpc.NetworkInfoRequest

This request has no parameters.

gRPC Response: lnrpc.NetworkInfo

Parameter Type Description
graph_diameter uint32
avg_out_degree double
max_out_degree uint32
num_nodes uint32
num_channels uint32
total_network_capacity int64
avg_channel_size double
min_channel_size int64
max_channel_size int64
median_channel_size_sat int64
num_zombie_chans uint64 The number of edges marked as zombies.

GetNodeInfo

Unary RPC

GetNodeInfo returns the latest advertised, aggregated, and authenticated channel information for the specified node identified by its public key.


# Prints out the latest authenticated node state for an advertised node

$ lncli getnodeinfo [command options] [arguments...]

# --pub_key value     the 33-byte hex-encoded compressed public of the target node
# --include_channels  if true, will return all known channels associated with the node
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.NodeInfoRequest(
        pub_key=<string>,
        include_channels=<bool>,
    )
>>> response = stub.GetNodeInfo(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "node": <LightningNode>,
    "num_channels": <uint32>,
    "total_capacity": <int64>,
    "channels": <array ChannelEdge>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  pub_key: <string>, 
  include_channels: <bool>, 
}; 
lightning.getNodeInfo(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "node": <LightningNode>,
//      "num_channels": <uint32>,
//      "total_capacity": <int64>,
//      "channels": <array ChannelEdge>,
//  }

gRPC Request: lnrpc.NodeInfoRequest

Parameter Type Description
pub_key string The 33-byte hex-encoded compressed public of the target node
include_channels bool If true, will include all known channels associated with the node.

gRPC Response: lnrpc.NodeInfo

Parameter Type Description
node LightningNode An individual vertex/node within the channel graph. A node is connected to other nodes by one or more channel edges emanating from it. As the graph is directed, a node will also have an incoming edge attached to it for each outgoing edge.
num_channels uint32 The total number of channels for the node.
total_capacity int64 The sum of all channels capacity for the node, denominated in satoshis.
channels array ChannelEdge A list of all public channels for the node.

GetNodeMetrics

Unary RPC

GetNodeMetrics returns node metrics calculated from the graph. Currently the only supported metric is betweenness centrality of individual nodes.


# Prints out node metrics calculated from the current graph

$ lncli getnodemetrics [arguments...]

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.NodeMetricsRequest(
        types=<array NodeMetricType>,
    )
>>> response = stub.GetNodeMetrics(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "betweenness_centrality": <array BetweennessCentralityEntry>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  types: <array NodeMetricType>, 
}; 
lightning.getNodeMetrics(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "betweenness_centrality": <array BetweennessCentralityEntry>,
//  }

gRPC Request: lnrpc.NodeMetricsRequest

Parameter Type Description
types array NodeMetricType The requested node metrics.

gRPC Response: lnrpc.NodeMetricsResponse

Parameter Type Description
betweenness_centrality array BetweennessCentralityEntry Betweenness centrality is the sum of the ratio of shortest paths that pass through the node for each pair of nodes in the graph (not counting paths starting or ending at this node). Map of node pubkey to betweenness centrality of the node. Normalized values are in the [0,1] closed interval.

GetTransactions

Unary RPC

GetTransactions returns a list describing all the known transactions relevant to the wallet.


# List all transactions an address of the wallet was involved in.
# This call will return a list of wallet related transactions that paid
# to an address our wallet controls, or spent utxos that we held. The
# start_height and end_height flags can be used to specify an inclusive
# block range over which to query for transactions. If the end_height is
# less than the start_height, transactions will be queried in reverse.
# To get all transactions until the chain tip, including unconfirmed
# transactions (identifiable with BlockHeight=0), set end_height to -1.
# By default, this call will get all transactions our wallet was involved
# in, including unconfirmed transactions.

$ lncli listchaintxns [command options] [arguments...]

# --start_height value  the block height from which to list transactions, inclusive (default: 0)
# --end_height value    the block height until which to list transactions, inclusive, to get transactions until the chain tip, including unconfirmed, set this value to -1 (default: 0)
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.GetTransactionsRequest(
        start_height=<int32>,
        end_height=<int32>,
    )
>>> response = stub.GetTransactions(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "transactions": <array Transaction>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  start_height: <int32>, 
  end_height: <int32>, 
}; 
lightning.getTransactions(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "transactions": <array Transaction>,
//  }

gRPC Request: lnrpc.GetTransactionsRequest

Parameter Type Description
start_height int32 The height from which to list transactions, inclusive. If this value is greater than end_height, transactions will be read in reverse.
end_height int32 The height until which to list transactions, inclusive. To include unconfirmed transactions, this value should be set to -1, which will return transactions from start_height until the current chain tip and unconfirmed transactions. If no end_height is provided, the call will default to this option.

gRPC Response: lnrpc.TransactionDetails

Parameter Type Description
transactions array Transaction The list of transactions relevant to the wallet.

ListChannels

Unary RPC

ListChannels returns a description of all the open channels that this node is a participant in.


# List all open channels.

$ lncli listchannels [command options] [arguments...]

# --active_only    only list channels which are currently active
# --inactive_only  only list channels which are currently inactive
# --public_only    only list channels which are currently public
# --private_only   only list channels which are currently private
# --peer value     (optional) only display channels with a particular peer, accepts 66-byte, hex-encoded pubkeys
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ListChannelsRequest(
        active_only=<bool>,
        inactive_only=<bool>,
        public_only=<bool>,
        private_only=<bool>,
        peer=<bytes>,
    )
>>> response = stub.ListChannels(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "channels": <array Channel>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  active_only: <bool>, 
  inactive_only: <bool>, 
  public_only: <bool>, 
  private_only: <bool>, 
  peer: <bytes>, 
}; 
lightning.listChannels(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "channels": <array Channel>,
//  }

gRPC Request: lnrpc.ListChannelsRequest

Parameter Type Description
active_only bool
inactive_only bool
public_only bool
private_only bool
peer bytes Filters the response for channels with a target peer's pubkey. If peer is empty, all channels will be returned.

gRPC Response: lnrpc.ListChannelsResponse

Parameter Type Description
channels array Channel The list of active channels

ListInvoices

Unary RPC

ListInvoices returns a list of all the invoices currently stored within the database. Any active debug invoices are ignored. It has full support for paginated responses, allowing users to query for specific invoices through their add_index. This can be done by using either the first_index_offset or last_index_offset fields included in the response as the index_offset of the next request. By default, the first 100 invoices created will be returned. Backwards pagination is also supported through the Reversed flag.


# This command enables the retrieval of all invoices currently stored
# within the database. It has full support for paginationed responses,
# allowing users to query for specific invoices through their add_index.
# This can be done by using either the first_index_offset or
# last_index_offset fields included in the response as the index_offset of
# the next request. Backward pagination is enabled by default to receive
# current invoices first. If you wish to paginate forwards, set the
# paginate-forwards flag.  If none of the parameters are specified, then
# the last 100 invoices will be returned.
# For example: if you have 200 invoices, "lncli listinvoices" will return
# the last 100 created. If you wish to retrieve the previous 100, the
# first_offset_index of the response can be used as the index_offset of
# the next listinvoices request.

$ lncli listinvoices [command options] [arguments...]

# --pending_only        toggles if all invoices should be returned, or only those that are currently unsettled
# --index_offset value  the index of an invoice that will be used as either the start or end of a query to determine which invoices should be returned in the response (default: 0)
# --max_invoices value  the max number of invoices to return (default: 0)
# --paginate-forwards   if set, invoices succeeding the index_offset will be returned
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ListInvoiceRequest(
        pending_only=<bool>,
        index_offset=<uint64>,
        num_max_invoices=<uint64>,
        reversed=<bool>,
    )
>>> response = stub.ListInvoices(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "invoices": <array Invoice>,
    "last_index_offset": <uint64>,
    "first_index_offset": <uint64>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  pending_only: <bool>, 
  index_offset: <uint64>, 
  num_max_invoices: <uint64>, 
  reversed: <bool>, 
}; 
lightning.listInvoices(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "invoices": <array Invoice>,
//      "last_index_offset": <uint64>,
//      "first_index_offset": <uint64>,
//  }

gRPC Request: lnrpc.ListInvoiceRequest

Parameter Type Description
pending_only bool If set, only invoices that are not settled and not canceled will be returned in the response.
index_offset uint64 The index of an invoice that will be used as either the start or end of a query to determine which invoices should be returned in the response.
num_max_invoices uint64 The max number of invoices to return in the response to this query.
reversed bool If set, the invoices returned will result from seeking backwards from the specified index offset. This can be used to paginate backwards.

gRPC Response: lnrpc.ListInvoiceResponse

Parameter Type Description
invoices array Invoice A list of invoices from the time slice of the time series specified in the request.
last_index_offset uint64 The index of the last item in the set of returned invoices. This can be used to seek further, pagination style.
first_index_offset uint64 The index of the last item in the set of returned invoices. This can be used to seek backwards, pagination style.

ListPayments

Unary RPC

ListPayments returns a list of all outgoing payments.


# This command enables the retrieval of payments stored in the database. Pagination is supported by the usage of index_offset in combination with the paginate_forwards flag. Reversed pagination is enabled by default to receive current payments first. Pagination can be resumed by using the returned last_index_offset (for forwards order), or first_index_offset (for reversed order) as the offset_index.

$ lncli listpayments [command options] [arguments...]

# --include_incomplete  if set to true, payments still in flight (or failed) will be returned as well, keepingindices for payments the same as without the flag
# --index_offset value  The index of a payment that will be used as either the start (in forwards mode) or end (in reverse mode) of a query to determine which payments should be returned in the response, where the index_offset is excluded. If index_offset is set to zero in reversed mode, the query will end with the last payment made. (default: 0)
# --max_payments value  the max number of payments to return, by default, all completed payments are returned (default: 0)
# --paginate_forwards   if set, payments succeeding the index_offset will be returned, allowing forwards pagination
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ListPaymentsRequest(
        include_incomplete=<bool>,
        index_offset=<uint64>,
        max_payments=<uint64>,
        reversed=<bool>,
    )
>>> response = stub.ListPayments(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "payments": <array Payment>,
    "first_index_offset": <uint64>,
    "last_index_offset": <uint64>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  include_incomplete: <bool>, 
  index_offset: <uint64>, 
  max_payments: <uint64>, 
  reversed: <bool>, 
}; 
lightning.listPayments(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "payments": <array Payment>,
//      "first_index_offset": <uint64>,
//      "last_index_offset": <uint64>,
//  }

gRPC Request: lnrpc.ListPaymentsRequest

Parameter Type Description
include_incomplete bool If true, then return payments that have not yet fully completed. This means that pending payments, as well as failed payments will show up if this field is set to true. This flag doesn't change the meaning of the indices, which are tied to individual payments.
index_offset uint64 The index of a payment that will be used as either the start or end of a query to determine which payments should be returned in the response. The index_offset is exclusive. In the case of a zero index_offset, the query will start with the oldest payment when paginating forwards, or will end with the most recent payment when paginating backwards.
max_payments uint64 The maximal number of payments returned in the response to this query.
reversed bool If set, the payments returned will result from seeking backwards from the specified index offset. This can be used to paginate backwards. The order of the returned payments is always oldest first (ascending index order).

gRPC Response: lnrpc.ListPaymentsResponse

Parameter Type Description
payments array Payment The list of payments
first_index_offset uint64 The index of the first item in the set of returned payments. This can be used as the index_offset to continue seeking backwards in the next request.
last_index_offset uint64 The index of the last item in the set of returned payments. This can be used as the index_offset to continue seeking forwards in the next request.

ListPeers

Unary RPC

ListPeers returns a verbose listing of all currently active peers.


# List all active, currently connected peers.

$ lncli listpeers [command options] [arguments...]

# --list_errors  list a full set of most recent errors for the peer
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ListPeersRequest(
        latest_error=<bool>,
    )
>>> response = stub.ListPeers(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "peers": <array Peer>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  latest_error: <bool>, 
}; 
lightning.listPeers(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "peers": <array Peer>,
//  }

gRPC Request: lnrpc.ListPeersRequest

Parameter Type Description
latest_error bool If true, only the last error that our peer sent us will be returned with the peer's information, rather than the full set of historic errors we have stored.

gRPC Response: lnrpc.ListPeersResponse

Parameter Type Description
peers array Peer The list of currently connected peers

ListUnspent

Unary RPC

ListUnspent returns a list of all utxos spendable by the wallet with a number of confirmations between the specified minimum and maximum.


# For each spendable utxo currently in the wallet, with at least min_confs
# confirmations, and at most max_confs confirmations, lists the txid,
# index, amount, address, address type, scriptPubkey and number of
# confirmations.  Use --min_confs=0 to include unconfirmed coins. To list
# all coins with at least min_confs confirmations, omit the second
# argument or flag '--max_confs'. To list all confirmed and unconfirmed
# coins, no arguments are required. To see only unconfirmed coins, use
# '--unconfirmed_only' with '--min_confs' and '--max_confs' set to zero or
# not present.

$ lncli listunspent [command options] [min-confs [max-confs]] [--unconfirmed_only]

# --min_confs value   the minimum number of confirmations for a utxo (default: 0)
# --max_confs value   the maximum number of confirmations for a utxo (default: 0)
# --unconfirmed_only  when min_confs and max_confs are zero, setting false implicitly overrides max_confs to be MaxInt32, otherwise max_confs remains zero. An error is returned if the value is true and both min_confs and max_confs are non-zero. (default: false)
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ListUnspentRequest(
        min_confs=<int32>,
        max_confs=<int32>,
    )
>>> response = stub.ListUnspent(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "utxos": <array Utxo>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  min_confs: <int32>, 
  max_confs: <int32>, 
}; 
lightning.listUnspent(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "utxos": <array Utxo>,
//  }

gRPC Request: lnrpc.ListUnspentRequest

Parameter Type Description
min_confs int32 The minimum number of confirmations to be included.
max_confs int32 The maximum number of confirmations to be included.

gRPC Response: lnrpc.ListUnspentResponse

Parameter Type Description
utxos array Utxo A list of utxos

LookupInvoice

Unary RPC

LookupInvoice attempts to look up an invoice according to its payment hash. The passed payment hash must be exactly 32 bytes, if not, an error is returned.


# Lookup an existing invoice by its payment hash.

$ lncli lookupinvoice [command options] rhash

# --rhash value  the 32 byte payment hash of the invoice to query for, the hash should be a hex-encoded string
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.PaymentHash(
        r_hash_str=<string>,
        r_hash=<bytes>,
    )
>>> response = stub.LookupInvoice(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "memo": <string>,
    "r_preimage": <bytes>,
    "r_hash": <bytes>,
    "value": <int64>,
    "value_msat": <int64>,
    "settled": <bool>,
    "creation_date": <int64>,
    "settle_date": <int64>,
    "payment_request": <string>,
    "description_hash": <bytes>,
    "expiry": <int64>,
    "fallback_addr": <string>,
    "cltv_expiry": <uint64>,
    "route_hints": <array RouteHint>,
    "private": <bool>,
    "add_index": <uint64>,
    "settle_index": <uint64>,
    "amt_paid": <int64>,
    "amt_paid_sat": <int64>,
    "amt_paid_msat": <int64>,
    "state": <InvoiceState>,
    "htlcs": <array InvoiceHTLC>,
    "features": <array FeaturesEntry>,
    "is_keysend": <bool>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  r_hash_str: <string>, 
  r_hash: <bytes>, 
}; 
lightning.lookupInvoice(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "memo": <string>,
//      "r_preimage": <bytes>,
//      "r_hash": <bytes>,
//      "value": <int64>,
//      "value_msat": <int64>,
//      "settled": <bool>,
//      "creation_date": <int64>,
//      "settle_date": <int64>,
//      "payment_request": <string>,
//      "description_hash": <bytes>,
//      "expiry": <int64>,
//      "fallback_addr": <string>,
//      "cltv_expiry": <uint64>,
//      "route_hints": <array RouteHint>,
//      "private": <bool>,
//      "add_index": <uint64>,
//      "settle_index": <uint64>,
//      "amt_paid": <int64>,
//      "amt_paid_sat": <int64>,
//      "amt_paid_msat": <int64>,
//      "state": <InvoiceState>,
//      "htlcs": <array InvoiceHTLC>,
//      "features": <array FeaturesEntry>,
//      "is_keysend": <bool>,
//  }

gRPC Request: lnrpc.PaymentHash

Parameter Type Description
r_hash_str string The hex-encoded payment hash of the invoice to be looked up. The passed payment hash must be exactly 32 bytes, otherwise an error is returned. Deprecated now that the REST gateway supports base64 encoding of bytes fields.
r_hash bytes The payment hash of the invoice to be looked up. When using REST, this field must be encoded as base64.

gRPC Response: lnrpc.Invoice

Parameter Type Description
memo string An optional memo to attach along with the invoice. Used for record keeping purposes for the invoice's creator, and will also be set in the description field of the encoded payment request if the description_hash field is not being used.
r_preimage bytes The hex-encoded preimage (32 byte) which will allow settling an incoming HTLC payable to this preimage. When using REST, this field must be encoded as base64.
r_hash bytes The hash of the preimage. When using REST, this field must be encoded as base64.
value int64 The value of this invoice in satoshis The fields value and value_msat are mutually exclusive.
value_msat int64 The value of this invoice in millisatoshis The fields value and value_msat are mutually exclusive.
settled bool Whether this invoice has been fulfilled
creation_date int64 When this invoice was created
settle_date int64 When this invoice was settled
payment_request string A bare-bones invoice for a payment within the Lightning Network. With the details of the invoice, the sender has all the data necessary to send a payment to the recipient.
description_hash bytes Hash (SHA-256) of a description of the payment. Used if the description of payment (memo) is too long to naturally fit within the description field of an encoded payment request. When using REST, this field must be encoded as base64.
expiry int64 Payment request expiry time in seconds. Default is 3600 (1 hour).
fallback_addr string Fallback on-chain address.
cltv_expiry uint64 Delta to use for the time-lock of the CLTV extended to the final hop.
route_hints array RouteHint Route hints that can each be individually used to assist in reaching the invoice's destination.
private bool Whether this invoice should include routing hints for private channels.
add_index uint64 The "add" index of this invoice. Each newly created invoice will increment this index making it monotonically increasing. Callers to the SubscribeInvoices call can use this to instantly get notified of all added invoices with an add_index greater than this one.
settle_index uint64 The "settle" index of this invoice. Each newly settled invoice will increment this index making it monotonically increasing. Callers to the SubscribeInvoices call can use this to instantly get notified of all settled invoices with an settle_index greater than this one.
amt_paid int64 Deprecated, use amt_paid_sat or amt_paid_msat.
amt_paid_sat int64 The amount that was accepted for this invoice, in satoshis. This will ONLY be set if this invoice has been settled. We provide this field as if the invoice was created with a zero value, then we need to record what amount was ultimately accepted. Additionally, it's possible that the sender paid MORE that was specified in the original invoice. So we'll record that here as well.
amt_paid_msat int64 The amount that was accepted for this invoice, in millisatoshis. This will ONLY be set if this invoice has been settled. We provide this field as if the invoice was created with a zero value, then we need to record what amount was ultimately accepted. Additionally, it's possible that the sender paid MORE that was specified in the original invoice. So we'll record that here as well.
state InvoiceState The state the invoice is in.
htlcs array InvoiceHTLC List of HTLCs paying to this invoice [EXPERIMENTAL].
features array FeaturesEntry List of features advertised on the invoice.
is_keysend bool Indicates if this invoice was a spontaneous payment that arrived via keysend [EXPERIMENTAL].

NewAddress

Unary RPC

NewAddress creates a new address under control of the local wallet.


# Generate a wallet new address. Address-types has to be one of:
# - p2wkh:  Pay to witness key hash
# - np2wkh: Pay to nested witness key hash

$ lncli newaddress address-type

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.NewAddressRequest(
        type=<AddressType>,
    )
>>> response = stub.NewAddress(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "address": <string>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  type: <AddressType>, 
}; 
lightning.newAddress(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "address": <string>,
//  }

gRPC Request: lnrpc.NewAddressRequest

Parameter Type Description
type AddressType The address type

gRPC Response: lnrpc.NewAddressResponse

Parameter Type Description
address string The newly generated wallet address

OpenChannel

Server-streaming RPC

OpenChannel attempts to open a singly funded channel specified in the request to a remote peer. Users are able to specify a target number of blocks that the funding transaction should be confirmed in, or a manual fee rate to us for the funding transaction. If neither are specified, then a lax block confirmation target is used. Each OpenStatusUpdate will return the pending channel ID of the in-progress channel. Depending on the arguments specified in the OpenChannelRequest, this pending channel ID can then be used to manually progress the channel funding flow.


# Attempt to open a new channel to an existing peer with the key node-key
# optionally blocking until the channel is 'open'.
# One can also connect to a node before opening a new channel to it by
# setting its host:port via the --connect argument. For this to work,
# the node_key must be provided, rather than the peer_id. This is optional.
# The channel will be initialized with local-amt satoshis local and push-amt
# satoshis for the remote node. Note that specifying push-amt means you give that
# amount to the remote node as part of the channel opening. Once the channel is open,
# a channelPoint (txid:vout) of the funding output is returned.
# If the remote peer supports the option upfront shutdown feature bit (query
# listpeers to see their supported feature bits), an address to enforce
# payout of funds on cooperative close can optionally be provided. Note that
# if you set this value, you will not be able to cooperatively close out to
# another address.
# One can manually set the fee to be used for the funding transaction via either
# the --conf_target or --sat_per_byte arguments. This is optional.

$ lncli openchannel [command options] node-key local-amt push-amt

# --node_key value          the identity public key of the target node/peer serialized in compressed format
# --connect value           (optional) the host:port of the target node
# --local_amt value         the number of satoshis the wallet should commit to the channel (default: 0)
# --push_amt value          the number of satoshis to give the remote side as part of the initial commitment state, this is equivalent to first opening a channel and sending the remote party funds, but done all in one step (default: 0)
# --block                   block and wait until the channel is fully open
# --conf_target value       (optional) the number of blocks that the transaction *should* confirm in, will be used for fee estimation (default: 0)
# --sat_per_byte value      (optional) a manual fee expressed in sat/byte that should be used when crafting the transaction (default: 0)
# --private                 make the channel private, such that it won't be announced to the greater network, and nodes other than the two channel endpoints must be explicitly told about it to be able to route through it
# --min_htlc_msat value     (optional) the minimum value we will require for incoming HTLCs on the channel (default: 0)
# --remote_csv_delay value  (optional) the number of blocks we will require our channel counterparty to wait before accessing its funds in case of unilateral close. If this is not set, we will scale the value according to the channel size (default: 0)
# --min_confs value         (optional) the minimum number of confirmations each one of your outputs used for the funding transaction must satisfy (default: 1)
# --close_address value     (optional) an address to enforce payout of our funds to on cooperative close. Note that if this value is set on channel open, you will *not* be able to cooperatively close to a different address.
# --psbt                    start an interactive mode that initiates funding through a partially signed bitcoin transaction (PSBT), allowing the channel funds to be added and signed from a hardware or other offline device.
# --base_psbt value         when using the interactive PSBT mode to open a new channel, use this base64 encoded PSBT as a base and add the new channel output to it instead of creating a new, empty one.
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.OpenChannelRequest(
        node_pubkey=<bytes>,
        node_pubkey_string=<string>,
        local_funding_amount=<int64>,
        push_sat=<int64>,
        target_conf=<int32>,
        sat_per_byte=<int64>,
        private=<bool>,
        min_htlc_msat=<int64>,
        remote_csv_delay=<uint32>,
        min_confs=<int32>,
        spend_unconfirmed=<bool>,
        close_address=<string>,
        funding_shim=<FundingShim>,
    )
>>> for response in stub.OpenChannel(request, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "chan_pending": <PendingUpdate>,
    "chan_open": <ChannelOpenUpdate>,
    "psbt_fund": <ReadyForPsbtFunding>,
    "pending_chan_id": <bytes>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  node_pubkey: <bytes>, 
  node_pubkey_string: <string>, 
  local_funding_amount: <int64>, 
  push_sat: <int64>, 
  target_conf: <int32>, 
  sat_per_byte: <int64>, 
  private: <bool>, 
  min_htlc_msat: <int64>, 
  remote_csv_delay: <uint32>, 
  min_confs: <int32>, 
  spend_unconfirmed: <bool>, 
  close_address: <string>, 
  funding_shim: <FundingShim>, 
}; 
let call = lightning.openChannel(request);
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
// Console output:
//  { 
//      "chan_pending": <PendingUpdate>,
//      "chan_open": <ChannelOpenUpdate>,
//      "psbt_fund": <ReadyForPsbtFunding>,
//      "pending_chan_id": <bytes>,
//  }

gRPC Request: lnrpc.OpenChannelRequest

Parameter Type Description
node_pubkey bytes The pubkey of the node to open a channel with. When using REST, this field must be encoded as base64.
node_pubkey_string string The hex encoded pubkey of the node to open a channel with. Deprecated now that the REST gateway supports base64 encoding of bytes fields.
local_funding_amount int64 The number of satoshis the wallet should commit to the channel
push_sat int64 The number of satoshis to push to the remote side as part of the initial / commitment state
target_conf int32 The target number of blocks that the funding transaction should be / confirmed by.
sat_per_byte int64 A manual fee rate set in sat/byte that should be used when crafting the / funding transaction.
private bool Whether this channel should be private, not announced to the greater / network.
min_htlc_msat int64 The minimum value in millisatoshi we will require for incoming HTLCs on / the channel.
remote_csv_delay uint32 The delay we require on the remote's commitment transaction. If this is / not set, it will be scaled automatically with the channel size.
min_confs int32 The minimum number of confirmations each one of your outputs used for / the funding transaction must satisfy.
spend_unconfirmed bool Whether unconfirmed outputs should be used as inputs for the funding / transaction.
close_address string Close address is an optional address which specifies the address to which funds should be paid out to upon cooperative close. This field may only be set if the peer supports the option upfront feature bit (call listpeers to check). The remote peer will only accept cooperative closes to this address if it is set. Note: If this value is set on channel creation, you will not be able to cooperatively close out to a different address.
funding_shim FundingShim Funding shims are an optional argument that allow the caller to intercept certain funding functionality. For example, a shim can be provided to use a particular key for the commitment key (ideally cold) rather than use one that is generated by the wallet as normal, or signal that signing will be carried out in an interactive manner (PSBT based).

gRPC Response: lnrpc.OpenStatusUpdate (Streaming)

Parameter Type Description
chan_pending PendingUpdate Signals that the channel is now fully negotiated and the funding transaction published.
chan_open ChannelOpenUpdate Signals that the channel's funding transaction has now reached the required number of confirmations on chain and can be used.
psbt_fund ReadyForPsbtFunding Signals that the funding process has been suspended and the construction of a PSBT that funds the channel PK script is now required.
pending_chan_id bytes The pending channel ID of the created channel. This value may be used to further the funding flow manually via the FundingStateStep method.

OpenChannelSync

Unary RPC

OpenChannelSync is a synchronous version of the OpenChannel RPC call. This call is meant to be consumed by clients to the REST proxy. As with all other sync calls, all byte slices are intended to be populated as hex encoded strings.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.OpenChannelRequest(
        node_pubkey=<bytes>,
        node_pubkey_string=<string>,
        local_funding_amount=<int64>,
        push_sat=<int64>,
        target_conf=<int32>,
        sat_per_byte=<int64>,
        private=<bool>,
        min_htlc_msat=<int64>,
        remote_csv_delay=<uint32>,
        min_confs=<int32>,
        spend_unconfirmed=<bool>,
        close_address=<string>,
        funding_shim=<FundingShim>,
    )
>>> response = stub.OpenChannelSync(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "funding_txid_bytes": <bytes>,
    "funding_txid_str": <string>,
    "output_index": <uint32>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  node_pubkey: <bytes>, 
  node_pubkey_string: <string>, 
  local_funding_amount: <int64>, 
  push_sat: <int64>, 
  target_conf: <int32>, 
  sat_per_byte: <int64>, 
  private: <bool>, 
  min_htlc_msat: <int64>, 
  remote_csv_delay: <uint32>, 
  min_confs: <int32>, 
  spend_unconfirmed: <bool>, 
  close_address: <string>, 
  funding_shim: <FundingShim>, 
}; 
lightning.openChannelSync(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "funding_txid_bytes": <bytes>,
//      "funding_txid_str": <string>,
//      "output_index": <uint32>,
//  }

gRPC Request: lnrpc.OpenChannelRequest

Parameter Type Description
node_pubkey bytes The pubkey of the node to open a channel with. When using REST, this field must be encoded as base64.
node_pubkey_string string The hex encoded pubkey of the node to open a channel with. Deprecated now that the REST gateway supports base64 encoding of bytes fields.
local_funding_amount int64 The number of satoshis the wallet should commit to the channel
push_sat int64 The number of satoshis to push to the remote side as part of the initial / commitment state
target_conf int32 The target number of blocks that the funding transaction should be / confirmed by.
sat_per_byte int64 A manual fee rate set in sat/byte that should be used when crafting the / funding transaction.
private bool Whether this channel should be private, not announced to the greater / network.
min_htlc_msat int64 The minimum value in millisatoshi we will require for incoming HTLCs on / the channel.
remote_csv_delay uint32 The delay we require on the remote's commitment transaction. If this is / not set, it will be scaled automatically with the channel size.
min_confs int32 The minimum number of confirmations each one of your outputs used for / the funding transaction must satisfy.
spend_unconfirmed bool Whether unconfirmed outputs should be used as inputs for the funding / transaction.
close_address string Close address is an optional address which specifies the address to which funds should be paid out to upon cooperative close. This field may only be set if the peer supports the option upfront feature bit (call listpeers to check). The remote peer will only accept cooperative closes to this address if it is set. Note: If this value is set on channel creation, you will not be able to cooperatively close out to a different address.
funding_shim FundingShim Funding shims are an optional argument that allow the caller to intercept certain funding functionality. For example, a shim can be provided to use a particular key for the commitment key (ideally cold) rather than use one that is generated by the wallet as normal, or signal that signing will be carried out in an interactive manner (PSBT based).

gRPC Response: lnrpc.ChannelPoint

Parameter Type Description
funding_txid_bytes bytes Txid of the funding transaction. When using REST, this field must be encoded as base64.
funding_txid_str string Hex-encoded string representing the byte-reversed hash of the funding transaction.
output_index uint32 The index of the output of the funding transaction

PendingChannels

Unary RPC

PendingChannels returns a list of all the channels that are currently considered "pending". A channel is pending if it has finished the funding workflow and is waiting for confirmations for the funding txn, or is in the process of closure, either initiated cooperatively or non-cooperatively.


# Display information pertaining to pending channels.

$ lncli pendingchannels [arguments...]

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.PendingChannelsRequest()
>>> response = stub.PendingChannels(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "total_limbo_balance": <int64>,
    "pending_open_channels": <array PendingOpenChannel>,
    "pending_closing_channels": <array ClosedChannel>,
    "pending_force_closing_channels": <array ForceClosedChannel>,
    "waiting_close_channels": <array WaitingCloseChannel>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = {}; 
lightning.pendingChannels(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "total_limbo_balance": <int64>,
//      "pending_open_channels": <array PendingOpenChannel>,
//      "pending_closing_channels": <array ClosedChannel>,
//      "pending_force_closing_channels": <array ForceClosedChannel>,
//      "waiting_close_channels": <array WaitingCloseChannel>,
//  }

gRPC Request: lnrpc.PendingChannelsRequest

This request has no parameters.

gRPC Response: lnrpc.PendingChannelsResponse

Parameter Type Description
total_limbo_balance int64 The balance in satoshis encumbered in pending channels
pending_open_channels array PendingOpenChannel Channels pending opening
pending_closing_channels array ClosedChannel Deprecated: Channels pending closing previously contained cooperatively closed channels with a single confirmation. These channels are now considered closed from the time we see them on chain.
pending_force_closing_channels array ForceClosedChannel Channels pending force closing
waiting_close_channels array WaitingCloseChannel Channels waiting for closing tx to confirm

QueryRoutes

Unary RPC

QueryRoutes attempts to query the daemon's Channel Router for a possible route to a target destination capable of carrying a specific amount of satoshis. The returned route contains the full details required to craft and send an HTLC, also including the necessary information that should be present within the Sphinx packet encapsulated within the HTLC.


# Queries the channel router for a potential path to the destination that has sufficient flow for the amount including fees

$ lncli queryroutes [command options] dest amt

# --dest value               the 33-byte hex-encoded public key for the payment destination
# --amt value                the amount to send expressed in satoshis (default: 0)
# --fee_limit value          maximum fee allowed in satoshis when sending the payment (default: 0)
# --fee_limit_percent value  percentage of the payment's amount used as the maximum fee allowed when sending the payment (default: 0)
# --final_cltv_delta value   (optional) number of blocks the last hop has to reveal the preimage (default: 0)
# --use_mc                   use mission control probabilities
# --cltv_limit value         the maximum time lock that may be used for this payment (default: 0)
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.QueryRoutesRequest(
        pub_key=<string>,
        amt=<int64>,
        amt_msat=<int64>,
        final_cltv_delta=<int32>,
        fee_limit=<FeeLimit>,
        ignored_nodes=<array bytes>,
        ignored_edges=<array EdgeLocator>,
        source_pub_key=<string>,
        use_mission_control=<bool>,
        ignored_pairs=<array NodePair>,
        cltv_limit=<uint32>,
        dest_custom_records=<array DestCustomRecordsEntry>,
        outgoing_chan_id=<uint64>,
        last_hop_pubkey=<bytes>,
        route_hints=<array RouteHint>,
        dest_features=<array FeatureBit>,
    )
>>> response = stub.QueryRoutes(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "routes": <array Route>,
    "success_prob": <double>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  pub_key: <string>, 
  amt: <int64>, 
  amt_msat: <int64>, 
  final_cltv_delta: <int32>, 
  fee_limit: <FeeLimit>, 
  ignored_nodes: <array bytes>, 
  ignored_edges: <array EdgeLocator>, 
  source_pub_key: <string>, 
  use_mission_control: <bool>, 
  ignored_pairs: <array NodePair>, 
  cltv_limit: <uint32>, 
  dest_custom_records: <array DestCustomRecordsEntry>, 
  outgoing_chan_id: <uint64>, 
  last_hop_pubkey: <bytes>, 
  route_hints: <array RouteHint>, 
  dest_features: <array FeatureBit>, 
}; 
lightning.queryRoutes(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "routes": <array Route>,
//      "success_prob": <double>,
//  }

gRPC Request: lnrpc.QueryRoutesRequest

Parameter Type Description
pub_key string The 33-byte hex-encoded public key for the payment destination
amt int64 The amount to send expressed in satoshis. The fields amt and amt_msat are mutually exclusive.
amt_msat int64 The amount to send expressed in millisatoshis. The fields amt and amt_msat are mutually exclusive.
final_cltv_delta int32 An optional CLTV delta from the current height that should be used for the timelock of the final hop. Note that unlike SendPayment, QueryRoutes does not add any additional block padding on top of final_ctlv_delta. This padding of a few blocks needs to be added manually or otherwise failures may happen when a block comes in while the payment is in flight.
fee_limit FeeLimit The maximum number of satoshis that will be paid as a fee of the payment. This value can be represented either as a percentage of the amount being sent, or as a fixed amount of the maximum fee the user is willing the pay to send the payment.
ignored_nodes array bytes A list of nodes to ignore during path finding. When using REST, these fields must be encoded as base64.
ignored_edges array EdgeLocator Deprecated. A list of edges to ignore during path finding.
source_pub_key string The source node where the request route should originated from. If empty, self is assumed.
use_mission_control bool If set to true, edge probabilities from mission control will be used to get the optimal route.
ignored_pairs array NodePair A list of directed node pairs that will be ignored during path finding.
cltv_limit uint32 An optional maximum total time lock for the route. If the source is empty or ourselves, this should not exceed lnd's --max-cltv-expiry setting. If zero, then the value of --max-cltv-expiry is used as the limit.
dest_custom_records array DestCustomRecordsEntry An optional field that can be used to pass an arbitrary set of TLV records to a peer which understands the new records. This can be used to pass application specific data during the payment attempt. If the destination does not support the specified recrods, and error will be returned. Record types are required to be in the custom range >= 65536. When using REST, the values must be encoded as base64.
outgoing_chan_id uint64 The channel id of the channel that must be taken to the first hop. If zero, any channel may be used.
last_hop_pubkey bytes The pubkey of the last hop of the route. If empty, any hop may be used.
route_hints array RouteHint Optional route hints to reach the destination through private channels.
dest_features array FeatureBit Features assumed to be supported by the final node. All transitive feature dependencies must also be set properly. For a given feature bit pair, either optional or remote may be set, but not both. If this field is nil or empty, the router will try to load destination features from the graph as a fallback.

gRPC Response: lnrpc.QueryRoutesResponse

Parameter Type Description
routes array Route The route that results from the path finding operation. This is still a repeated field to retain backwards compatibility.
success_prob double The success probability of the returned route based on the current mission control state. [EXPERIMENTAL]

RestoreChannelBackups

Unary RPC

RestoreChannelBackups accepts a set of singular channel backups, or a single encrypted multi-chan backup and attempts to recover any funds remaining within the channel. If we are able to unpack the backup, then the new channel will be shown under listchannels, as well as pending channels.


# Allows a user to restore a Static Channel Backup (SCB) that was
# obtained either via the exportchanbackup command, or from lnd's
# automatically manged channels.backup file. This command should be used
# if a user is attempting to restore a channel due to data loss on a
# running node restored with the same seed as the node that created the
# channel. If successful, this command will allows the user to recover
# the settled funds stored in the recovered channels.
# The command will accept backups in one of three forms:
# * A single channel packed SCB, which can be obtained from
# exportchanbackup. This should be passed in hex encoded format.
# * A packed multi-channel SCB, which couples several individual
# static channel backups in single blob.
# * A file path which points to a packed multi-channel backup within a
# file, using the same format that lnd does in its channels.backup
# file.

$ lncli restorechanbackup [command options] [--single_backup] [--multi_backup] [--multi_file=

# --single_backup value  a hex encoded single channel backup obtained from exportchanbackup
# --multi_backup value   a hex encoded multi-channel backup obtained from exportchanbackup
# --multi_file value     the path to a multi-channel back up file
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.RestoreChanBackupRequest(
        chan_backups=<ChannelBackups>,
        multi_chan_backup=<bytes>,
    )
>>> response = stub.RestoreChannelBackups(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  chan_backups: <ChannelBackups>, 
  multi_chan_backup: <bytes>, 
}; 
lightning.restoreChannelBackups(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//  }

gRPC Request: lnrpc.RestoreChanBackupRequest

Parameter Type Description
chan_backups ChannelBackups The channels to restore as a list of channel/backup pairs.
multi_chan_backup bytes The channels to restore in the packed multi backup format. When using REST, this field must be encoded as base64.

gRPC Response: lnrpc.RestoreBackupResponse

This response has no parameters.

SendCoins

Unary RPC

SendCoins executes a request to send coins to a particular address. Unlike SendMany, this RPC call only allows creating a single output at a time. If neither target_conf, or sat_per_byte are set, then the internal wallet will consult its fee model to determine a fee for the default confirmation target.


# Send amt coins in satoshis to the base58 or bech32 encoded bitcoin address addr.
# Fees used when sending the transaction can be specified via the --conf_target, or
# --sat_per_byte optional flags.
# Positional arguments and flags can be used interchangeably but not at the same time!

$ lncli sendcoins [command options] addr amt

# --addr value          the base58 or bech32 encoded bitcoin address to send coins to on-chain
# --sweepall            if set, then the amount field will be ignored, and all the wallet will attempt to sweep all outputs within the wallet to the target address
# --amt value           the number of bitcoin denominated in satoshis to send (default: 0)
# --conf_target value   (optional) the number of blocks that the transaction *should* confirm in, will be used for fee estimation (default: 0)
# --sat_per_byte value  (optional) a manual fee expressed in sat/byte that should be used when crafting the transaction (default: 0)
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.SendCoinsRequest(
        addr=<string>,
        amount=<int64>,
        target_conf=<int32>,
        sat_per_byte=<int64>,
        send_all=<bool>,
    )
>>> response = stub.SendCoins(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "txid": <string>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  addr: <string>, 
  amount: <int64>, 
  target_conf: <int32>, 
  sat_per_byte: <int64>, 
  send_all: <bool>, 
}; 
lightning.sendCoins(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "txid": <string>,
//  }

gRPC Request: lnrpc.SendCoinsRequest

Parameter Type Description
addr string The address to send coins to
amount int64 The amount in satoshis to send
target_conf int32 The target number of blocks that this transaction should be confirmed / by.
sat_per_byte int64 A manual fee rate set in sat/byte that should be used when crafting the / transaction.
send_all bool If set, then the amount field will be ignored, and lnd will attempt to send all the coins under control of the internal wallet to the specified address.

gRPC Response: lnrpc.SendCoinsResponse

Parameter Type Description
txid string The transaction ID of the transaction

SendMany

Unary RPC

SendMany handles a request for a transaction that creates multiple specified outputs in parallel. If neither target_conf, or sat_per_byte are set, then the internal wallet will consult its fee model to determine a fee for the default confirmation target.


# Create and broadcast a transaction paying the specified amount(s) to the passed address(es).
# The send-json-string' param decodes addresses and the amount to send
# respectively in the following format:
# '{"ExampleAddr": NumCoinsInSatoshis, "SecondAddr": NumCoins}'

$ lncli sendmany [command options] send-json-string [--conf_target=N] [--sat_per_byte=P]

# --conf_target value   (optional) the number of blocks that the transaction *should* confirm in, will be used for fee estimation (default: 0)
# --sat_per_byte value  (optional) a manual fee expressed in sat/byte that should be used when crafting the transaction (default: 0)
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.SendManyRequest(
        AddrToAmount=<array AddrToAmountEntry>,
        target_conf=<int32>,
        sat_per_byte=<int64>,
    )
>>> response = stub.SendMany(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "txid": <string>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  AddrToAmount: <array AddrToAmountEntry>, 
  target_conf: <int32>, 
  sat_per_byte: <int64>, 
}; 
lightning.sendMany(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "txid": <string>,
//  }

gRPC Request: lnrpc.SendManyRequest

Parameter Type Description
AddrToAmount array AddrToAmountEntry The map from addresses to amounts
target_conf int32 The target number of blocks that this transaction should be confirmed / by.
sat_per_byte int64 A manual fee rate set in sat/byte that should be used when crafting the / transaction.

gRPC Response: lnrpc.SendManyResponse

Parameter Type Description
txid string The id of the transaction

SendPayment

Bidirectional-streaming RPC

Deprecated, use routerrpc.SendPayment. SendPayment dispatches a bi-directional streaming RPC for sending payments through the Lightning Network. A single RPC invocation creates a persistent bi-directional stream allowing clients to rapidly send payments through the Lightning Network with a single persistent connection.


# Send a payment over Lightning. One can either specify the full
# parameters of the payment, or just use a payment request which encodes
# all the payment details.
# If payment isn't manually specified, then only a payment request needs
# to be passed using the --pay_req argument.
# If the payment *is* manually specified, then all four alternative
# arguments need to be specified in order to complete the payment:
# * --dest=N
# * --amt=A
# * --final_cltv_delta=T
# * --payment_hash=H

$ lncli sendpayment [command options] dest amt payment_hash final_cltv_delta | --pay_req=[payment request]

# --pay_req value                 a zpay32 encoded payment request to fulfill
# --fee_limit value               maximum fee allowed in satoshis when sending the payment (default: 0)
# --fee_limit_percent value       percentage of the payment's amount used as the maximum fee allowed when sending the payment (default: 0)
# --cltv_limit value              the maximum time lock that may be used for this payment (default: 0)
# --last_hop value                pubkey of the last hop (penultimate node in the path) to route through for this payment
# --outgoing_chan_id value        short channel id of the outgoing channel to use for the first hop of the payment (default: 0)
# --force, -f                     will skip payment request confirmation
# --allow_self_payment            allow sending a circular payment to self
# --data value                    attach custom data to the payment. The required format is: <record_id>=<hex_value>,<record_id>=<hex_value>,.. For example: --data 3438382=0a21ff. Custom record ids start from 65536.
# --inflight_updates              if set, intermediate payment state updates will be displayed. Only valid in combination with --json.
# --max_parts value               the maximum number of partial payments that may be used (default: 1)
# --json                          if set, payment updates are printed as json messages. Set by default on Windows because table formatting is unsupported.
# --dest value, -d value          the compressed identity pubkey of the payment recipient
# --amt value, -a value           number of satoshis to send (default: 0)
# --payment_hash value, -r value  the hash to use within the payment's HTLC
# --final_cltv_delta value        the number of blocks the last hop has to reveal the preimage (default: 0)
# --keysend                       will generate a pre-image and encode it in the sphinx packet, a dest must be set [experimental]
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
# Define a generator that returns an Iterable of lnrpc.SendRequest objects.
>>> def request_generator():
        # Initialization code here.
        while True:
            # Parameters here can be set as arguments to the generator.
            request = lnrpc.SendRequest(
                dest=<bytes>,
                dest_string=<string>,
                amt=<int64>,
                amt_msat=<int64>,
                payment_hash=<bytes>,
                payment_hash_string=<string>,
                payment_request=<string>,
                final_cltv_delta=<int32>,
                fee_limit=<FeeLimit>,
                outgoing_chan_id=<uint64>,
                last_hop_pubkey=<bytes>,
                cltv_limit=<uint32>,
                dest_custom_records=<array DestCustomRecordsEntry>,
                allow_self_payment=<bool>,
                dest_features=<array FeatureBit>,
            )
            yield request
            # Do things between iterations here.
>>> request_iterable = request_generator()
>>> for response in stub.SendPayment(request_iterable, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "payment_error": <string>,
    "payment_preimage": <bytes>,
    "payment_route": <Route>,
    "payment_hash": <bytes>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  dest: <bytes>, 
  dest_string: <string>, 
  amt: <int64>, 
  amt_msat: <int64>, 
  payment_hash: <bytes>, 
  payment_hash_string: <string>, 
  payment_request: <string>, 
  final_cltv_delta: <int32>, 
  fee_limit: <FeeLimit>, 
  outgoing_chan_id: <uint64>, 
  last_hop_pubkey: <bytes>, 
  cltv_limit: <uint32>, 
  dest_custom_records: <array DestCustomRecordsEntry>, 
  allow_self_payment: <bool>, 
  dest_features: <array FeatureBit>, 
}; 
let call = lightning.sendPayment({});
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
call.write(request);
// Console output:
//  { 
//      "payment_error": <string>,
//      "payment_preimage": <bytes>,
//      "payment_route": <Route>,
//      "payment_hash": <bytes>,
//  }

gRPC Request: lnrpc.SendRequest (Streaming)

Parameter Type Description
dest bytes The identity pubkey of the payment recipient. When using REST, this field must be encoded as base64.
dest_string string The hex-encoded identity pubkey of the payment recipient. Deprecated now that the REST gateway supports base64 encoding of bytes fields.
amt int64 The amount to send expressed in satoshis. The fields amt and amt_msat are mutually exclusive.
amt_msat int64 The amount to send expressed in millisatoshis. The fields amt and amt_msat are mutually exclusive.
payment_hash bytes The hash to use within the payment's HTLC. When using REST, this field must be encoded as base64.
payment_hash_string string The hex-encoded hash to use within the payment's HTLC. Deprecated now that the REST gateway supports base64 encoding of bytes fields.
payment_request string A bare-bones invoice for a payment within the Lightning Network. With the details of the invoice, the sender has all the data necessary to send a payment to the recipient.
final_cltv_delta int32 The CLTV delta from the current height that should be used to set the timelock for the final hop.
fee_limit FeeLimit The maximum number of satoshis that will be paid as a fee of the payment. This value can be represented either as a percentage of the amount being sent, or as a fixed amount of the maximum fee the user is willing the pay to send the payment.
outgoing_chan_id uint64 The channel id of the channel that must be taken to the first hop. If zero, any channel may be used.
last_hop_pubkey bytes The pubkey of the last hop of the route. If empty, any hop may be used.
cltv_limit uint32 An optional maximum total time lock for the route. This should not exceed lnd's --max-cltv-expiry setting. If zero, then the value of --max-cltv-expiry is enforced.
dest_custom_records array DestCustomRecordsEntry An optional field that can be used to pass an arbitrary set of TLV records to a peer which understands the new records. This can be used to pass application specific data during the payment attempt. Record types are required to be in the custom range >= 65536. When using REST, the values must be encoded as base64.
allow_self_payment bool If set, circular payments to self are permitted.
dest_features array FeatureBit Features assumed to be supported by the final node. All transitive feature dependencies must also be set properly. For a given feature bit pair, either optional or remote may be set, but not both. If this field is nil or empty, the router will try to load destination features from the graph as a fallback.

gRPC Response: lnrpc.SendResponse (Streaming)

Parameter Type Description
payment_error string
payment_preimage bytes
payment_route Route
payment_hash bytes

SendPaymentSync

Unary RPC

SendPaymentSync is the synchronous non-streaming version of SendPayment. This RPC is intended to be consumed by clients of the REST proxy. Additionally, this RPC expects the destination's public key and the payment hash (if any) to be encoded as hex strings.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.SendRequest(
        dest=<bytes>,
        dest_string=<string>,
        amt=<int64>,
        amt_msat=<int64>,
        payment_hash=<bytes>,
        payment_hash_string=<string>,
        payment_request=<string>,
        final_cltv_delta=<int32>,
        fee_limit=<FeeLimit>,
        outgoing_chan_id=<uint64>,
        last_hop_pubkey=<bytes>,
        cltv_limit=<uint32>,
        dest_custom_records=<array DestCustomRecordsEntry>,
        allow_self_payment=<bool>,
        dest_features=<array FeatureBit>,
    )
>>> response = stub.SendPaymentSync(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "payment_error": <string>,
    "payment_preimage": <bytes>,
    "payment_route": <Route>,
    "payment_hash": <bytes>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  dest: <bytes>, 
  dest_string: <string>, 
  amt: <int64>, 
  amt_msat: <int64>, 
  payment_hash: <bytes>, 
  payment_hash_string: <string>, 
  payment_request: <string>, 
  final_cltv_delta: <int32>, 
  fee_limit: <FeeLimit>, 
  outgoing_chan_id: <uint64>, 
  last_hop_pubkey: <bytes>, 
  cltv_limit: <uint32>, 
  dest_custom_records: <array DestCustomRecordsEntry>, 
  allow_self_payment: <bool>, 
  dest_features: <array FeatureBit>, 
}; 
lightning.sendPaymentSync(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "payment_error": <string>,
//      "payment_preimage": <bytes>,
//      "payment_route": <Route>,
//      "payment_hash": <bytes>,
//  }

gRPC Request: lnrpc.SendRequest

Parameter Type Description
dest bytes The identity pubkey of the payment recipient. When using REST, this field must be encoded as base64.
dest_string string The hex-encoded identity pubkey of the payment recipient. Deprecated now that the REST gateway supports base64 encoding of bytes fields.
amt int64 The amount to send expressed in satoshis. The fields amt and amt_msat are mutually exclusive.
amt_msat int64 The amount to send expressed in millisatoshis. The fields amt and amt_msat are mutually exclusive.
payment_hash bytes The hash to use within the payment's HTLC. When using REST, this field must be encoded as base64.
payment_hash_string string The hex-encoded hash to use within the payment's HTLC. Deprecated now that the REST gateway supports base64 encoding of bytes fields.
payment_request string A bare-bones invoice for a payment within the Lightning Network. With the details of the invoice, the sender has all the data necessary to send a payment to the recipient.
final_cltv_delta int32 The CLTV delta from the current height that should be used to set the timelock for the final hop.
fee_limit FeeLimit The maximum number of satoshis that will be paid as a fee of the payment. This value can be represented either as a percentage of the amount being sent, or as a fixed amount of the maximum fee the user is willing the pay to send the payment.
outgoing_chan_id uint64 The channel id of the channel that must be taken to the first hop. If zero, any channel may be used.
last_hop_pubkey bytes The pubkey of the last hop of the route. If empty, any hop may be used.
cltv_limit uint32 An optional maximum total time lock for the route. This should not exceed lnd's --max-cltv-expiry setting. If zero, then the value of --max-cltv-expiry is enforced.
dest_custom_records array DestCustomRecordsEntry An optional field that can be used to pass an arbitrary set of TLV records to a peer which understands the new records. This can be used to pass application specific data during the payment attempt. Record types are required to be in the custom range >= 65536. When using REST, the values must be encoded as base64.
allow_self_payment bool If set, circular payments to self are permitted.
dest_features array FeatureBit Features assumed to be supported by the final node. All transitive feature dependencies must also be set properly. For a given feature bit pair, either optional or remote may be set, but not both. If this field is nil or empty, the router will try to load destination features from the graph as a fallback.

gRPC Response: lnrpc.SendResponse

Parameter Type Description
payment_error string
payment_preimage bytes
payment_route Route
payment_hash bytes

SendToRoute

Bidirectional-streaming RPC

SendToRoute is a bi-directional streaming RPC for sending payment through the Lightning Network. This method differs from SendPayment in that it allows users to specify a full route manually. This can be used for things like rebalancing, and atomic swaps.


# Send a payment over Lightning using a specific route. One must specify
# the route to attempt and the payment hash. This command can even
# be chained with the response to queryroutes or buildroute. This command
# can be used to implement channel rebalancing by crafting a self-route,
# or even atomic swaps using a self-route that crosses multiple chains.
# There are three ways to specify a route:
# * using the --routes parameter to manually specify a JSON encoded
# route in the format of the return value of queryroutes or
# buildroute:
# (lncli sendtoroute --payment_hash=<pay_hash> --routes=<route>)
# * passing the route as a positional argument:
# (lncli sendtoroute --payment_hash=pay_hash <route>)
# * or reading in the route from stdin, which can allow chaining the
# response from queryroutes or buildroute, or even read in a file
# with a pre-computed route:
# (lncli queryroutes --args.. | lncli sendtoroute --payment_hash= -
# notice the '-' at the end, which signals that lncli should read
# the route in from stdin

$ lncli sendtoroute [command options] [arguments...]

# --payment_hash value, --pay_hash value  the hash to use within the payment's HTLC
# --routes value, -r value                a json array string in the format of the response of queryroutes that denotes which routes to use
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
# Define a generator that returns an Iterable of lnrpc.SendToRouteRequest objects.
>>> def request_generator():
        # Initialization code here.
        while True:
            # Parameters here can be set as arguments to the generator.
            request = lnrpc.SendToRouteRequest(
                payment_hash=<bytes>,
                payment_hash_string=<string>,
                route=<Route>,
            )
            yield request
            # Do things between iterations here.
>>> request_iterable = request_generator()
>>> for response in stub.SendToRoute(request_iterable, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "payment_error": <string>,
    "payment_preimage": <bytes>,
    "payment_route": <Route>,
    "payment_hash": <bytes>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  payment_hash: <bytes>, 
  payment_hash_string: <string>, 
  route: <Route>, 
}; 
let call = lightning.sendToRoute({});
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
call.write(request);
// Console output:
//  { 
//      "payment_error": <string>,
//      "payment_preimage": <bytes>,
//      "payment_route": <Route>,
//      "payment_hash": <bytes>,
//  }

gRPC Request: lnrpc.SendToRouteRequest (Streaming)

Parameter Type Description
payment_hash bytes The payment hash to use for the HTLC. When using REST, this field must be encoded as base64.
payment_hash_string string An optional hex-encoded payment hash to be used for the HTLC. Deprecated now that the REST gateway supports base64 encoding of bytes fields.
route Route Route that should be used to attempt to complete the payment.

gRPC Response: lnrpc.SendResponse (Streaming)

Parameter Type Description
payment_error string
payment_preimage bytes
payment_route Route
payment_hash bytes

SendToRouteSync

Unary RPC

SendToRouteSync is a synchronous version of SendToRoute. It Will block until the payment either fails or succeeds.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.SendToRouteRequest(
        payment_hash=<bytes>,
        payment_hash_string=<string>,
        route=<Route>,
    )
>>> response = stub.SendToRouteSync(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "payment_error": <string>,
    "payment_preimage": <bytes>,
    "payment_route": <Route>,
    "payment_hash": <bytes>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  payment_hash: <bytes>, 
  payment_hash_string: <string>, 
  route: <Route>, 
}; 
lightning.sendToRouteSync(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "payment_error": <string>,
//      "payment_preimage": <bytes>,
//      "payment_route": <Route>,
//      "payment_hash": <bytes>,
//  }

gRPC Request: lnrpc.SendToRouteRequest

Parameter Type Description
payment_hash bytes The payment hash to use for the HTLC. When using REST, this field must be encoded as base64.
payment_hash_string string An optional hex-encoded payment hash to be used for the HTLC. Deprecated now that the REST gateway supports base64 encoding of bytes fields.
route Route Route that should be used to attempt to complete the payment.

gRPC Response: lnrpc.SendResponse

Parameter Type Description
payment_error string
payment_preimage bytes
payment_route Route
payment_hash bytes

SignMessage

Unary RPC

SignMessage signs a message with this node's private key. The returned signature string is zbase32 encoded and pubkey recoverable, meaning that only the message digest and signature are needed for verification.


# Sign msg with the resident node's private key.
# Returns the signature as a zbase32 string.
# Positional arguments and flags can be used interchangeably but not at the same time!

$ lncli signmessage [command options] msg

# --msg value  the message to sign
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.SignMessageRequest(
        msg=<bytes>,
    )
>>> response = stub.SignMessage(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
    "signature": <string>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  msg: <bytes>, 
}; 
lightning.signMessage(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//      "signature": <string>,
//  }

gRPC Request: lnrpc.SignMessageRequest

Parameter Type Description
msg bytes The message to be signed. When using REST, this field must be encoded as base64.

gRPC Response: lnrpc.SignMessageResponse

Parameter Type Description
signature string The signature for the given message

StopDaemon

Unary RPC

StopDaemon will send a shutdown request to the interrupt handler, triggering a graceful shutdown of the daemon.


# Gracefully stop all daemon subsystems before stopping the daemon itself.
# This is equivalent to stopping it using CTRL-C.

$ lncli stop [arguments...]

>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.StopRequest()
>>> response = stub.StopDaemon(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = {}; 
lightning.stopDaemon(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//  }

gRPC Request: lnrpc.StopRequest

This request has no parameters.

gRPC Response: lnrpc.StopResponse

This response has no parameters.

SubscribeChannelBackups

Server-streaming RPC

SubscribeChannelBackups allows a client to sub-subscribe to the most up to date information concerning the state of all channel backups. Each time a new channel is added, we return the new set of channels, along with a multi-chan backup containing the backup info for all channels. Each time a channel is closed, we send a new update, which contains new new chan back ups, but the updated set of encrypted multi-chan backups with the closed channel(s) removed.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ChannelBackupSubscription()
>>> for response in stub.SubscribeChannelBackups(request, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "single_chan_backups": <ChannelBackups>,
    "multi_chan_backup": <MultiChanBackup>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = {}; 
let call = lightning.subscribeChannelBackups(request);
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
// Console output:
//  { 
//      "single_chan_backups": <ChannelBackups>,
//      "multi_chan_backup": <MultiChanBackup>,
//  }

gRPC Request: lnrpc.ChannelBackupSubscription

This request has no parameters.

gRPC Response: lnrpc.ChanBackupSnapshot (Streaming)

Parameter Type Description
single_chan_backups ChannelBackups The set of new channels that have been added since the last channel backup snapshot was requested.
multi_chan_backup MultiChanBackup A multi-channel backup that covers all open channels currently known to lnd.

SubscribeChannelEvents

Server-streaming RPC

SubscribeChannelEvents creates a uni-directional stream from the server to the client in which any updates relevant to the state of the channels are sent over. Events include new active channels, inactive channels, and closed channels.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.ChannelEventSubscription()
>>> for response in stub.SubscribeChannelEvents(request, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "open_channel": <Channel>,
    "closed_channel": <ChannelCloseSummary>,
    "active_channel": <ChannelPoint>,
    "inactive_channel": <ChannelPoint>,
    "pending_open_channel": <PendingUpdate>,
    "type": <UpdateType>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = {}; 
let call = lightning.subscribeChannelEvents(request);
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
// Console output:
//  { 
//      "open_channel": <Channel>,
//      "closed_channel": <ChannelCloseSummary>,
//      "active_channel": <ChannelPoint>,
//      "inactive_channel": <ChannelPoint>,
//      "pending_open_channel": <PendingUpdate>,
//      "type": <UpdateType>,
//  }

gRPC Request: lnrpc.ChannelEventSubscription

This request has no parameters.

gRPC Response: lnrpc.ChannelEventUpdate (Streaming)

Parameter Type Description
open_channel Channel
closed_channel ChannelCloseSummary
active_channel ChannelPoint
inactive_channel ChannelPoint
pending_open_channel PendingUpdate
type UpdateType

SubscribeChannelGraph

Server-streaming RPC

SubscribeChannelGraph launches a streaming RPC that allows the caller to receive notifications upon any changes to the channel graph topology from the point of view of the responding node. Events notified include: new nodes coming online, nodes updating their authenticated attributes, new channels being advertised, updates in the routing policy for a directional channel edge, and when channels are closed on-chain.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.GraphTopologySubscription()
>>> for response in stub.SubscribeChannelGraph(request, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "node_updates": <array NodeUpdate>,
    "channel_updates": <array ChannelEdgeUpdate>,
    "closed_chans": <array ClosedChannelUpdate>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = {}; 
let call = lightning.subscribeChannelGraph(request);
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
// Console output:
//  { 
//      "node_updates": <array NodeUpdate>,
//      "channel_updates": <array ChannelEdgeUpdate>,
//      "closed_chans": <array ClosedChannelUpdate>,
//  }

gRPC Request: lnrpc.GraphTopologySubscription

This request has no parameters.

gRPC Response: lnrpc.GraphTopologyUpdate (Streaming)

Parameter Type Description
node_updates array NodeUpdate
channel_updates array ChannelEdgeUpdate
closed_chans array ClosedChannelUpdate

SubscribeInvoices

Server-streaming RPC

SubscribeInvoices returns a uni-directional stream (server -> client) for notifying the client of newly added/settled invoices. The caller can optionally specify the add_index and/or the settle_index. If the add_index is specified, then we'll first start by sending add invoice events for all invoices with an add_index greater than the specified value. If the settle_index is specified, the next, we'll send out all settle events for invoices with a settle_index greater than the specified value. One or both of these fields can be set. If no fields are set, then we'll only send out the latest add/settle events.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.InvoiceSubscription(
        add_index=<uint64>,
        settle_index=<uint64>,
    )
>>> for response in stub.SubscribeInvoices(request, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "memo": <string>,
    "r_preimage": <bytes>,
    "r_hash": <bytes>,
    "value": <int64>,
    "value_msat": <int64>,
    "settled": <bool>,
    "creation_date": <int64>,
    "settle_date": <int64>,
    "payment_request": <string>,
    "description_hash": <bytes>,
    "expiry": <int64>,
    "fallback_addr": <string>,
    "cltv_expiry": <uint64>,
    "route_hints": <array RouteHint>,
    "private": <bool>,
    "add_index": <uint64>,
    "settle_index": <uint64>,
    "amt_paid": <int64>,
    "amt_paid_sat": <int64>,
    "amt_paid_msat": <int64>,
    "state": <InvoiceState>,
    "htlcs": <array InvoiceHTLC>,
    "features": <array FeaturesEntry>,
    "is_keysend": <bool>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  add_index: <uint64>, 
  settle_index: <uint64>, 
}; 
let call = lightning.subscribeInvoices(request);
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
// Console output:
//  { 
//      "memo": <string>,
//      "r_preimage": <bytes>,
//      "r_hash": <bytes>,
//      "value": <int64>,
//      "value_msat": <int64>,
//      "settled": <bool>,
//      "creation_date": <int64>,
//      "settle_date": <int64>,
//      "payment_request": <string>,
//      "description_hash": <bytes>,
//      "expiry": <int64>,
//      "fallback_addr": <string>,
//      "cltv_expiry": <uint64>,
//      "route_hints": <array RouteHint>,
//      "private": <bool>,
//      "add_index": <uint64>,
//      "settle_index": <uint64>,
//      "amt_paid": <int64>,
//      "amt_paid_sat": <int64>,
//      "amt_paid_msat": <int64>,
//      "state": <InvoiceState>,
//      "htlcs": <array InvoiceHTLC>,
//      "features": <array FeaturesEntry>,
//      "is_keysend": <bool>,
//  }

gRPC Request: lnrpc.InvoiceSubscription

Parameter Type Description
add_index uint64 If specified (non-zero), then we'll first start by sending out notifications for all added indexes with an add_index greater than this value. This allows callers to catch up on any events they missed while they weren't connected to the streaming RPC.
settle_index uint64 If specified (non-zero), then we'll first start by sending out notifications for all settled indexes with an settle_index greater than this value. This allows callers to catch up on any events they missed while they weren't connected to the streaming RPC.

gRPC Response: lnrpc.Invoice (Streaming)

Parameter Type Description
memo string An optional memo to attach along with the invoice. Used for record keeping purposes for the invoice's creator, and will also be set in the description field of the encoded payment request if the description_hash field is not being used.
r_preimage bytes The hex-encoded preimage (32 byte) which will allow settling an incoming HTLC payable to this preimage. When using REST, this field must be encoded as base64.
r_hash bytes The hash of the preimage. When using REST, this field must be encoded as base64.
value int64 The value of this invoice in satoshis The fields value and value_msat are mutually exclusive.
value_msat int64 The value of this invoice in millisatoshis The fields value and value_msat are mutually exclusive.
settled bool Whether this invoice has been fulfilled
creation_date int64 When this invoice was created
settle_date int64 When this invoice was settled
payment_request string A bare-bones invoice for a payment within the Lightning Network. With the details of the invoice, the sender has all the data necessary to send a payment to the recipient.
description_hash bytes Hash (SHA-256) of a description of the payment. Used if the description of payment (memo) is too long to naturally fit within the description field of an encoded payment request. When using REST, this field must be encoded as base64.
expiry int64 Payment request expiry time in seconds. Default is 3600 (1 hour).
fallback_addr string Fallback on-chain address.
cltv_expiry uint64 Delta to use for the time-lock of the CLTV extended to the final hop.
route_hints array RouteHint Route hints that can each be individually used to assist in reaching the invoice's destination.
private bool Whether this invoice should include routing hints for private channels.
add_index uint64 The "add" index of this invoice. Each newly created invoice will increment this index making it monotonically increasing. Callers to the SubscribeInvoices call can use this to instantly get notified of all added invoices with an add_index greater than this one.
settle_index uint64 The "settle" index of this invoice. Each newly settled invoice will increment this index making it monotonically increasing. Callers to the SubscribeInvoices call can use this to instantly get notified of all settled invoices with an settle_index greater than this one.
amt_paid int64 Deprecated, use amt_paid_sat or amt_paid_msat.
amt_paid_sat int64 The amount that was accepted for this invoice, in satoshis. This will ONLY be set if this invoice has been settled. We provide this field as if the invoice was created with a zero value, then we need to record what amount was ultimately accepted. Additionally, it's possible that the sender paid MORE that was specified in the original invoice. So we'll record that here as well.
amt_paid_msat int64 The amount that was accepted for this invoice, in millisatoshis. This will ONLY be set if this invoice has been settled. We provide this field as if the invoice was created with a zero value, then we need to record what amount was ultimately accepted. Additionally, it's possible that the sender paid MORE that was specified in the original invoice. So we'll record that here as well.
state InvoiceState The state the invoice is in.
htlcs array InvoiceHTLC List of HTLCs paying to this invoice [EXPERIMENTAL].
features array FeaturesEntry List of features advertised on the invoice.
is_keysend bool Indicates if this invoice was a spontaneous payment that arrived via keysend [EXPERIMENTAL].

SubscribePeerEvents

Server-streaming RPC

SubscribePeerEvents creates a uni-directional stream from the server to the client in which any events relevant to the state of peers are sent over. Events include peers going online and offline.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.PeerEventSubscription()
>>> for response in stub.SubscribePeerEvents(request, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "pub_key": <string>,
    "type": <EventType>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = {}; 
let call = lightning.subscribePeerEvents(request);
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
// Console output:
//  { 
//      "pub_key": <string>,
//      "type": <EventType>,
//  }

gRPC Request: lnrpc.PeerEventSubscription

This request has no parameters.

gRPC Response: lnrpc.PeerEvent (Streaming)

Parameter Type Description
pub_key string The identity pubkey of the peer.
type EventType

SubscribeTransactions

Server-streaming RPC

SubscribeTransactions creates a uni-directional stream from the server to the client in which any newly discovered transactions relevant to the wallet are sent over.


>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.GetTransactionsRequest(
        start_height=<int32>,
        end_height=<int32>,
    )
>>> for response in stub.SubscribeTransactions(request, metadata=[('macaroon', macaroon)]):
        print(response)
{ 
    "tx_hash": <string>,
    "amount": <int64>,
    "num_confirmations": <int32>,
    "block_hash": <string>,
    "block_height": <int32>,
    "time_stamp": <int64>,
    "total_fees": <int64>,
    "dest_addresses": <array string>,
    "raw_tx_hex": <string>,
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  start_height: <int32>, 
  end_height: <int32>, 
}; 
let call = lightning.subscribeTransactions(request);
call.on('data', function(response) {
  // A response was received from the server.
  console.log(response);
});
call.on('status', function(status) {
  // The current status of the stream.
});
call.on('end', function() {
  // The server has closed the stream.
});
// Console output:
//  { 
//      "tx_hash": <string>,
//      "amount": <int64>,
//      "num_confirmations": <int32>,
//      "block_hash": <string>,
//      "block_height": <int32>,
//      "time_stamp": <int64>,
//      "total_fees": <int64>,
//      "dest_addresses": <array string>,
//      "raw_tx_hex": <string>,
//  }

gRPC Request: lnrpc.GetTransactionsRequest

Parameter Type Description
start_height int32 The height from which to list transactions, inclusive. If this value is greater than end_height, transactions will be read in reverse.
end_height int32 The height until which to list transactions, inclusive. To include unconfirmed transactions, this value should be set to -1, which will return transactions from start_height until the current chain tip and unconfirmed transactions. If no end_height is provided, the call will default to this option.

gRPC Response: lnrpc.Transaction (Streaming)

Parameter Type Description
tx_hash string The transaction hash
amount int64 The transaction amount, denominated in satoshis
num_confirmations int32 The number of confirmations
block_hash string The hash of the block this transaction was included in
block_height int32 The height of the block this transaction was included in
time_stamp int64 Timestamp of this transaction
total_fees int64 Fees paid for this transaction
dest_addresses array string Addresses that received funds for this transaction
raw_tx_hex string The raw transaction hex.

UpdateChannelPolicy

Unary RPC

UpdateChannelPolicy allows the caller to update the fee schedule and channel policies for all channels globally, or a particular channel.


# Updates the channel policy for all channels, or just a particular channel
# identified by its channel point. The update will be committed, and
# broadcast to the rest of the network within the next batch.
# Channel points are encoded as: funding_txid:output_index

$ lncli updatechanpolicy [command options] base_fee_msat fee_rate time_lock_delta [--max_htlc_msat=N] [channel_point]

# --base_fee_msat value    the base fee in milli-satoshis that will be charged for each forwarded HTLC, regardless of payment size (default: 0)
# --fee_rate value         the fee rate that will be charged proportionally based on the value of each forwarded HTLC, the lowest possible rate is 0 with a granularity of 0.000001 (millionths)
# --time_lock_delta value  the CLTV delta that will be applied to all forwarded HTLCs (default: 0)
# --min_htlc_msat value    if set, the min HTLC size that will be applied to all forwarded HTLCs. If unset, the min HTLC is left unchanged. (default: 0)
# --max_htlc_msat value    if set, the max HTLC size that will be applied to all forwarded HTLCs. If unset, the max HTLC is left unchanged. (default: 0)
# --chan_point value       The channel whose fee policy should be updated, if nil the policies for all channels will be updated. Takes the form of: txid:output_index
>>> import codecs, grpc, os
>>> # Generate the following 2 modules by compiling the lnrpc/rpc.proto with the grpcio-tools.
>>> # See https://github.com/lightningnetwork/lnd/blob/master/docs/grpc/python.md for instructions.
>>> import rpc_pb2 as lnrpc, rpc_pb2_grpc as rpcstub
>>> macaroon = codecs.encode(open('LND_DIR/data/chain/bitcoin/simnet/admin.macaroon', 'rb').read(), 'hex')
>>> os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA'
>>> cert = open('LND_DIR/tls.cert', 'rb').read()
>>> ssl_creds = grpc.ssl_channel_credentials(cert)
>>> channel = grpc.secure_channel('localhost:10009', ssl_creds)
>>> stub = rpcstub.LightningStub(channel)
>>> request = lnrpc.PolicyUpdateRequest(
        global=<bool>,
        chan_point=<ChannelPoint>,
        base_fee_msat=<int64>,
        fee_rate=<double>,
        time_lock_delta=<uint32>,
        max_htlc_msat=<uint64>,
        min_htlc_msat=<uint64>,
        min_htlc_msat_specified=<bool>,
    )
>>> response = stub.UpdateChannelPolicy(request, metadata=[('macaroon', macaroon)])
>>> print(response)
{ 
}
const fs = require('fs');
const grpc = require('grpc');
const protoLoader = require('@grpc/proto-loader');
const loaderOptions = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
};
const packageDefinition = protoLoader.loadSync('rpc.proto', loaderOptions);
const lnrpc = grpc.loadPackageDefinition(packageDefinition).lnrpc;
const macaroon = fs.readFileSync("LND_DIR/data/chain/bitcoin/simnet/admin.macaroon").toString('hex');
process.env.GRPC_SSL_CIPHER_SUITES = 'HIGH+ECDSA';
const lndCert = fs.readFileSync('LND_DIR/tls.cert');
const sslCreds = grpc.credentials.createSsl(lndCert);
const macaroonCreds = grpc.credentials.createFromMetadataGenerator(function(args, callback) {
  let metadata = new grpc.Metadata();
  metadata.add('macaroon', macaroon);
  callback(null, metadata);
});
let creds = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds);
let lightning = new lnrpc.Lightning('localhost:10009', creds);
let request = { 
  global: <bool>, 
  chan_point: <ChannelPoint>, 
  base_fee_msat: <int64>, 
  fee_rate: <double>, 
  time_lock_delta: <uint32>, 
  max_htlc_msat: <uint64>, 
  min_htlc_msat: <uint64>, 
  min_htlc_msat_specified: <bool>, 
}; 
lightning.updateChannelPolicy(request, function(err, response) {
  console.log(response);
});
// Console output:
//  { 
//  }

gRPC Request: lnrpc.PolicyUpdateRequest

Parameter Type Description
global bool If set, then this update applies to all currently active channels.
chan_point ChannelPoint If set, this update will target a specific channel.
base_fee_msat int64 The base fee charged regardless of the number of milli-satoshis sent.
fee_rate double The effective fee rate in milli-satoshis. The precision of this value / goes up to 6 decimal places, so 1e-6.
time_lock_delta uint32 The required timelock delta for HTLCs forwarded over the channel.
max_htlc_msat uint64 If set, the maximum HTLC size in milli-satoshis. If unset, the maximum / HTLC will be unchanged.
min_htlc_msat uint64 The minimum HTLC size in milli-satoshis. Only applied if / min_htlc_msat_specified is true.
min_htlc_msat_specified bool If true, min_htlc_msat is applied.

gRPC Response: lnrpc.PolicyUpdateResponse

This response has no parameters.

VerifyChanBackup

Unary RPC

VerifyChanBackup allows a caller to verify the integrity of a channel backup snapshot