package lnrpc

Get desktop application:
View/edit binary Protocol Buffers messages

• rpc AbandonChannel (AbandonChannelRequest, AbandonChannelResponse)

  rpc.proto:454

  * lncli: `abandonchannel` 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.

  message AbandonChannelRequest

  rpc.proto:2196

  • optional ChannelPoint channel_point = 1

  message AbandonChannelResponse

  rpc.proto:2200

  (message has no fields)

• rpc AddInvoice (Invoice, AddInvoiceResponse)

  rpc.proto:506

  * lncli: `addinvoice` 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.

  message AddInvoiceResponse

  rpc.proto:2050

  • bytes r_hash = 1

  • string payment_request = 2

    * 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.

  • uint64 add_index = 16

    * 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.

• rpc ChannelBalance (ChannelBalanceRequest, ChannelBalanceResponse)

  rpc.proto:227

  * lncli: `channelbalance` ChannelBalance returns the total funds available across all open channels in satoshis.

  message ChannelBalanceRequest

  rpc.proto:1592

  (message has no fields)

  message ChannelBalanceResponse

  rpc.proto:1594

  • int64 balance = 1

    / Sum of channels balances denominated in satoshis

  • int64 pending_open_balance = 2

    / Sum of channels pending balances denominated in satoshis

• rpc CloseChannel (CloseChannelRequest, stream CloseStatusUpdate)

  rpc.proto:442

  * lncli: `closechannel` 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.

  message CloseChannelRequest

  rpc.proto:1365

  • optional ChannelPoint channel_point = 1

    * 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.

  • bool force = 2

    / If true, then the channel will be closed forcibly. This means the current commitment transaction will be signed and broadcast.

  • int32 target_conf = 3

    / The target number of blocks that the closure transaction should be confirmed by.

  • int64 sat_per_byte = 4

    / A manual fee rate set in sat/byte that should be used when crafting the closure transaction.

  message CloseStatusUpdate

  rpc.proto:1383

  • oneof update

    • PendingUpdate close_pending = 1

    • ChannelCloseUpdate chan_close = 3

• rpc ClosedChannels (ClosedChannelsRequest, ClosedChannelsResponse)

  rpc.proto:404

  * lncli: `closedchannels` ClosedChannels returns a description of all the closed channels that this node was a participant in.

  message ClosedChannelsRequest

  rpc.proto:1219

  • bool cooperative = 1

  • bool local_force = 2

  • bool remote_force = 3

  • bool breach = 4

  • bool funding_canceled = 5

  • bool abandoned = 6

  message ClosedChannelsResponse

  rpc.proto:1228

  • repeated ChannelCloseSummary channels = 1

• rpc ConnectPeer (ConnectPeerRequest, ConnectPeerResponse)

  rpc.proto:331

  * lncli: `connect` 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.

  message ConnectPeerRequest

  rpc.proto:1054

  • optional LightningAddress addr = 1

    / Lightning address of the peer, in the format `<pubkey>@host`

  • bool perm = 2

    * If set, the daemon will attempt to persistently connect to the target peer. Otherwise, the call will be synchronous.

  message ConnectPeerResponse

  rpc.proto:1062

  (message has no fields)

• rpc DebugLevel (DebugLevelRequest, DebugLevelResponse)

  rpc.proto:666

  * lncli: `debuglevel` 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.

  message DebugLevelRequest

  rpc.proto:2204

  • bool show = 1

  • string level_spec = 2

  message DebugLevelResponse

  rpc.proto:2208

  • string sub_systems = 1

• rpc DecodePayReq (PayReqString, PayReq)

  rpc.proto:561

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

  message PayReqString

  rpc.proto:2212

  • string pay_req = 1

    / The payment request string to be decoded

  message PayReq

  rpc.proto:2216

  • string destination = 1

  • string payment_hash = 2

  • int64 num_satoshis = 3

  • int64 timestamp = 4

  • int64 expiry = 5

  • string description = 6

  • string description_hash = 7

  • string fallback_addr = 8

  • int64 cltv_expiry = 9

  • repeated RouteHint route_hints = 10

• rpc DeleteAllPayments (DeleteAllPaymentsRequest, DeleteAllPaymentsResponse)

  rpc.proto:579

  * DeleteAllPayments deletes all outgoing payments from DB.

  message DeleteAllPaymentsRequest

  rpc.proto:2190

  (message has no fields)

  message DeleteAllPaymentsResponse

  rpc.proto:2193

  (message has no fields)

• rpc DescribeGraph (ChannelGraphRequest, ChannelGraph)

  rpc.proto:593

  * lncli: `describegraph` 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.

  message ChannelGraphRequest

  rpc.proto:1810

  • bool include_unannounced = 1

    * 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.

  message ChannelGraph

  rpc.proto:1820

  / Returns a new instance of the directed channel graph.

  • repeated LightningNode nodes = 1

    / The list of `LightningNode`s in this channel graph

  • repeated ChannelEdge edges = 2

    / The list of `ChannelEdge`s in this channel graph

• rpc DisconnectPeer (DisconnectPeerRequest, DisconnectPeerResponse)

  rpc.proto:343

  * lncli: `disconnect` 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.

  message DisconnectPeerRequest

  rpc.proto:1065

  • string pub_key = 1

    / The pubkey of the node to disconnect from

  message DisconnectPeerResponse

  rpc.proto:1069

  (message has no fields)

• rpc EstimateFee (EstimateFeeRequest, EstimateFeeResponse)

  rpc.proto:247

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

  message EstimateFeeRequest

  rpc.proto:940

  • map<string, int64> AddrToAmount = 1

    / The map from addresses to amounts for the transaction.

  • int32 target_conf = 2

    / The target number of blocks that this transaction should be confirmed by.

  message EstimateFeeResponse

  rpc.proto:948

  • int64 fee_sat = 1

    / The total fee in satoshis.

  • int64 feerate_sat_per_byte = 2

    / The fee rate in satoshi/byte.

• rpc ExportAllChannelBackups (ChanBackupExportRequest, ChanBackupSnapshot)

  rpc.proto:729

  * 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.

  message ChanBackupExportRequest

  rpc.proto:2358

  (message has no fields)

• rpc ExportChannelBackup (ExportChannelBackupRequest, ChannelBackup)

  rpc.proto:716

  * lncli: `exportchanbackup` 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.

  message ExportChannelBackupRequest

  rpc.proto:2325

  • optional ChannelPoint chan_point = 1

    / The target channel point to obtain a back up for.

• rpc FeeReport (FeeReportRequest, FeeReportResponse)

  rpc.proto:672

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

  message FeeReportRequest

  rpc.proto:2229

  (message has no fields)

  message FeeReportResponse

  rpc.proto:2243

  • repeated ChannelFeeReport channel_fees = 1

    / An array of channel fee reports which describes the current fee schedule for each channel.

  • uint64 day_fee_sum = 2

    / The total amount of fee revenue (in satoshis) the switch has collected over the past 24 hrs.

  • uint64 week_fee_sum = 3

    / The total amount of fee revenue (in satoshis) the switch has collected over the past 1 week.

  • uint64 month_fee_sum = 4

    / The total amount of fee revenue (in satoshis) the switch has collected over the past 1 month.

• rpc ForwardingHistory (ForwardingHistoryRequest, ForwardingHistoryResponse)

  rpc.proto:701

  * lncli: `fwdinghistory` 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.

  message ForwardingHistoryRequest

  rpc.proto:2278

  • uint64 start_time = 1

    / 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.

  • uint64 end_time = 2

    / 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.

  • uint32 index_offset = 3

    / 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.

  • uint32 num_max_events = 4

    / The max number of events to return in the response to this query.

  message ForwardingHistoryResponse

  rpc.proto:2317

  • repeated ForwardingEvent forwarding_events = 1

    / A list of forwarding events from the time slice of the time series specified in the request.

  • uint32 last_offset_index = 2

    / The index of the last time in the set of returned forwarding events. Can be used to seek further, pagination style.

• rpc GetChanInfo (ChanInfoRequest, ChannelEdge)

  rpc.proto:605

  * lncli: `getchaninfo` 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.

  message ChanInfoRequest

  rpc.proto:1828

  • uint64 chan_id = 1

    * 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.

• rpc GetInfo (GetInfoRequest, GetInfoResponse)

  rpc.proto:363

  * lncli: `getinfo` 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.

  message GetInfoRequest

  rpc.proto:1285

  (message has no fields)

  message GetInfoResponse

  rpc.proto:1287

  • string identity_pubkey = 1

    / The identity pubkey of the current node.

  • string alias = 2

    / If applicable, the alias of the current node, e.g. "bob"

  • uint32 num_pending_channels = 3

    / Number of pending channels

  • uint32 num_active_channels = 4

    / Number of active channels

  • uint32 num_peers = 5

    / Number of peers

  • uint32 block_height = 6

    / The node's current view of the height of the best block

  • string block_hash = 8

    / The node's current view of the hash of the best block

  • bool synced_to_chain = 9

    / Whether the wallet's view is synced to the main chain

  • bool testnet = 10

    * Whether the current node is connected to testnet. This field is deprecated and the network field should be used instead

  • repeated string uris = 12

    / The URIs of the current node.

  • int64 best_header_timestamp = 13

    / Timestamp of the block best known to the wallet

  • string version = 14

    / The version of the LND software that the node is running.

  • uint32 num_inactive_channels = 15

    / Number of inactive channels

  • repeated Chain chains = 16

    / A list of active chains the node is connected to

  • string color = 17

    / The color of the current node in hex code format

• rpc GetNetworkInfo (NetworkInfoRequest, NetworkInfo)

  rpc.proto:638

  * lncli: `getnetworkinfo` GetNetworkInfo returns some basic stats about the known channel graph from the point of view of the node.

  message NetworkInfoRequest

  rpc.proto:1837

  (message has no fields)

  message NetworkInfo

  rpc.proto:1839

  • uint32 graph_diameter = 1

  • double avg_out_degree = 2

  • uint32 max_out_degree = 3

  • uint32 num_nodes = 4

  • uint32 num_channels = 5

  • int64 total_network_capacity = 6

  • double avg_channel_size = 7

  • int64 min_channel_size = 8

  • int64 max_channel_size = 9

  • int64 median_channel_size_sat = 10

• rpc GetNodeInfo (NodeInfoRequest, NodeInfo)

  rpc.proto:615

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

  message NodeInfoRequest

  rpc.proto:1726

  • string pub_key = 1

    / The 33-byte hex-encoded compressed public of the target node

  • bool include_channels = 2

    / If true, will include all known channels associated with the node.

  message NodeInfo

  rpc.proto:1734

  • optional LightningNode node = 1

    * 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.

  • uint32 num_channels = 2

    / The total number of channels for the node.

  • int64 total_capacity = 3

    / The sum of all channels capacity for the node, denominated in satoshis.

  • repeated ChannelEdge channels = 4

    / A list of all public channels for the node.

• rpc GetTransactions (GetTransactionsRequest, TransactionDetails)

  rpc.proto:237

  * lncli: `listchaintxns` GetTransactions returns a list describing all the known transactions relevant to the wallet.

  message TransactionDetails

  rpc.proto:823

  • repeated Transaction transactions = 1

    / The list of transactions relevant to the wallet.

• rpc ListChannels (ListChannelsRequest, ListChannelsResponse)

  rpc.proto:386

  * lncli: `listchannels` ListChannels returns a description of all the open channels that this node is a participant in.

  message ListChannelsRequest

  rpc.proto:1167

  • bool active_only = 1

  • bool inactive_only = 2

  • bool public_only = 3

  • bool private_only = 4

  message ListChannelsResponse

  rpc.proto:1173

  • repeated Channel channels = 11

    / The list of active channels

• rpc ListInvoices (ListInvoiceRequest, ListInvoiceResponse)

  rpc.proto:522

  * lncli: `listinvoices` 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.

  message ListInvoiceRequest

  rpc.proto:2079

  • bool pending_only = 1

    / If set, only unsettled invoices will be returned in the response.

  • uint64 index_offset = 4

    * 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.

  • uint64 num_max_invoices = 5

    / The max number of invoices to return in the response to this query.

  • bool reversed = 6

    * If set, the invoices returned will result from seeking backwards from the specified index offset. This can be used to paginate backwards.

  message ListInvoiceResponse

  rpc.proto:2098

  • repeated Invoice invoices = 1

    * A list of invoices from the time slice of the time series specified in the request.

  • uint64 last_index_offset = 2

    * The index of the last item in the set of returned invoices. This can be used to seek further, pagination style.

  • uint64 first_index_offset = 3

    * The index of the last item in the set of returned invoices. This can be used to seek backwards, pagination style.

• rpc ListPayments (ListPaymentsRequest, ListPaymentsResponse)

  rpc.proto:570

  * lncli: `listpayments` ListPayments returns a list of all outgoing payments.

  message ListPaymentsRequest

  rpc.proto:2176

  • bool include_incomplete = 1

    * 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.

  message ListPaymentsResponse

  rpc.proto:2185

  • repeated Payment payments = 1

    / The list of payments

• rpc ListPeers (ListPeersRequest, ListPeersResponse)

  rpc.proto:352

  * lncli: `listpeers` ListPeers returns a verbose listing of all currently active peers.

  message ListPeersRequest

  rpc.proto:1278

  (message has no fields)

  message ListPeersResponse

  rpc.proto:1280

  • repeated Peer peers = 1

    / The list of currently connected peers

• rpc ListUnspent (ListUnspentRequest, ListUnspentResponse)

  rpc.proto:271

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

  message ListUnspentRequest

  rpc.proto:996

  • int32 min_confs = 1

    / The minimum number of confirmations to be included.

  • int32 max_confs = 2

    / The maximum number of confirmations to be included.

  message ListUnspentResponse

  rpc.proto:1003

  • repeated Utxo utxos = 1

    / A list of utxos

• rpc LookupInvoice (PaymentHash, Invoice)

  rpc.proto:533

  * lncli: `lookupinvoice` 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.

  message PaymentHash

  rpc.proto:2068

  • string r_hash_str = 1

    * 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.

  • bytes r_hash = 2

    / The payment hash of the invoice to be looked up.

• rpc NewAddress (NewAddressRequest, NewAddressResponse)

  rpc.proto:295

  * lncli: `newaddress` NewAddress creates a new address under control of the local wallet.

  message NewAddressRequest

  rpc.proto:1021

  • AddressType type = 1

    / The address type

  message NewAddressResponse

  rpc.proto:1025

  • string address = 1

    / The newly generated wallet address

• rpc OpenChannel (OpenChannelRequest, stream OpenStatusUpdate)

  rpc.proto:431

  * lncli: `openchannel` 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.

  message OpenStatusUpdate

  rpc.proto:1429

  • oneof update

    • PendingUpdate chan_pending = 1

    • ChannelOpenUpdate chan_open = 3

• rpc OpenChannelSync (OpenChannelRequest, ChannelPoint)

  rpc.proto:417

  * 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.

• rpc PendingChannels (PendingChannelsRequest, PendingChannelsResponse)

  rpc.proto:376

  * lncli: `pendingchannels` 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.

  message PendingChannelsRequest

  rpc.proto:1461

  (message has no fields)

  message PendingChannelsResponse

  rpc.proto:1462

  • int64 total_limbo_balance = 1

    / The balance in satoshis encumbered in pending channels

  • repeated PendingChannelsResponse.PendingOpenChannel pending_open_channels = 2

    / Channels pending opening

  • repeated PendingChannelsResponse.ClosedChannel pending_closing_channels = 3

    / Channels pending closing

  • repeated PendingChannelsResponse.ForceClosedChannel pending_force_closing_channels = 4

    / Channels pending force closing

  • repeated PendingChannelsResponse.WaitingCloseChannel waiting_close_channels = 5

    / Channels waiting for closing tx to confirm

• rpc QueryRoutes (QueryRoutesRequest, QueryRoutesResponse)

  rpc.proto:628

  * lncli: `queryroutes` 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.

  message QueryRoutesRequest

  rpc.proto:1602

  • string pub_key = 1

    / The 33-byte hex-encoded public key for the payment destination

  • int64 amt = 2

    / The amount to send expressed in satoshis

  • int32 final_cltv_delta = 4

    / An optional CLTV delta from the current height that should be used for the timelock of the final hop

  • optional FeeLimit fee_limit = 5

    * 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.

  • repeated bytes ignored_nodes = 6

    * A list of nodes to ignore during path finding.

  • repeated EdgeLocator ignored_edges = 7

    * A list of edges to ignore during path finding.

  • string source_pub_key = 8

    * The source node where the request route should originated from. If empty, self is assumed.

  message QueryRoutesResponse

  rpc.proto:1652

  • repeated Route routes = 1

• rpc RestoreChannelBackups (RestoreChanBackupRequest, RestoreBackupResponse)

  rpc.proto:753

  * lncli: `restorechanbackup` 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.

  message RestoreChanBackupRequest

  rpc.proto:2380

  • oneof backup

    • ChannelBackups chan_backups = 1

    • bytes multi_chan_backup = 2

  message RestoreBackupResponse

  rpc.proto:2387

  (message has no fields)

• rpc SendCoins (SendCoinsRequest, SendCoinsResponse)

  rpc.proto:260

  * lncli: `sendcoins` 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.

  message SendCoinsRequest

  rpc.proto:971

  • string addr = 1

    / The address to send coins to

  • int64 amount = 2

    / The amount in satoshis to send

  • int32 target_conf = 3

    / The target number of blocks that this transaction should be confirmed by.

  • int64 sat_per_byte = 5

    / A manual fee rate set in sat/byte that should be used when crafting the transaction.

  • bool send_all = 6

    * 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.

  message SendCoinsResponse

  rpc.proto:991

  • string txid = 1

    / The transaction ID of the transaction

• rpc SendMany (SendManyRequest, SendManyResponse)

  rpc.proto:290

  * lncli: `sendmany` 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.

  message SendManyRequest

  rpc.proto:956

  • map<string, int64> AddrToAmount = 1

    / The map from addresses to amounts

  • int32 target_conf = 3

    / The target number of blocks that this transaction should be confirmed by.

  • int64 sat_per_byte = 5

    / A manual fee rate set in sat/byte that should be used when crafting the transaction.

  message SendManyResponse

  rpc.proto:966

  • string txid = 1

    / The id of the transaction

• rpc SendPayment (stream SendRequest, stream SendResponse)

  rpc.proto:467

  * lncli: `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.

• rpc SendPaymentSync (SendRequest, SendResponse)

  rpc.proto:475

  * 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.

• rpc SendToRoute (stream SendToRouteRequest, stream SendResponse)

  rpc.proto:488

  * lncli: `sendtoroute` 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.

• rpc SendToRouteSync (SendToRouteRequest, SendResponse)

  rpc.proto:494

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

• rpc SignMessage (SignMessageRequest, SignMessageResponse)

  rpc.proto:306

  * lncli: `signmessage` 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.

  message SignMessageRequest

  rpc.proto:1030

  • bytes msg = 1

    / The message to be signed

  message SignMessageResponse

  rpc.proto:1034

  • string signature = 1

    / The signature for the given message

• rpc StopDaemon (StopRequest, StopResponse)

  rpc.proto:648

  * lncli: `stop` StopDaemon will send a shutdown request to the interrupt handler, triggering a graceful shutdown of the daemon.

  message StopRequest

  rpc.proto:1858

  (message has no fields)

  message StopResponse

  rpc.proto:1859

  (message has no fields)

• rpc SubscribeChannelBackups (ChannelBackupSubscription, stream ChanBackupSnapshot)

  rpc.proto:769

  * 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.

  message ChannelBackupSubscription

  rpc.proto:2389

  (message has no fields)

• rpc SubscribeChannelEvents (ChannelEventSubscription, stream ChannelEventUpdate)

  rpc.proto:398

  * lncli: `subscribechannelevents` 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.

  message ChannelEventSubscription

  rpc.proto:1558

  (message has no fields)

  message ChannelEventUpdate

  rpc.proto:1561

  • oneof channel

    • Channel open_channel = 1

    • ChannelCloseSummary closed_channel = 2

    • ChannelPoint active_channel = 3

    • ChannelPoint inactive_channel = 4

  • ChannelEventUpdate.UpdateType type = 5

• rpc SubscribeChannelGraph (GraphTopologySubscription, stream GraphTopologyUpdate)

  rpc.proto:658

  * 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.

  message GraphTopologySubscription

  rpc.proto:1861

  (message has no fields)

  message GraphTopologyUpdate

  rpc.proto:1862

  • repeated NodeUpdate node_updates = 1

  • repeated ChannelEdgeUpdate channel_updates = 2

  • repeated ClosedChannelUpdate closed_chans = 3

• rpc SubscribeInvoices (InvoiceSubscription, stream Invoice)

  rpc.proto:550

  * 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.

  message InvoiceSubscription

  rpc.proto:2118

  • uint64 add_index = 1

    * 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.

  • uint64 settle_index = 2

    * 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.

• rpc SubscribeTransactions (GetTransactionsRequest, stream Transaction)

  rpc.proto:282

  * 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.

• rpc UpdateChannelPolicy (PolicyUpdateRequest, PolicyUpdateResponse)

  rpc.proto:682

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

  message PolicyUpdateRequest

  rpc.proto:2257

  • oneof scope

    • bool global = 1

      / If set, then this update applies to all currently active channels.

    • ChannelPoint chan_point = 2

      / If set, this update will target a specific channel.

  • int64 base_fee_msat = 3

    / The base fee charged regardless of the number of milli-satoshis sent.

  • double fee_rate = 4

    / The effective fee rate in milli-satoshis. The precision of this value goes up to 6 decimal places, so 1e-6.

  • uint32 time_lock_delta = 5

    / The required timelock delta for HTLCs forwarded over the channel.

  message PolicyUpdateResponse

  rpc.proto:2275

  (message has no fields)

• rpc VerifyChanBackup (ChanBackupSnapshot, VerifyChanBackupResponse)

  rpc.proto:740

  * VerifyChanBackup allows a caller to verify the integrity of a channel backup snapshot. This method will accept either a packed Single or a packed Multi. Specifying both will result in an error.

  message VerifyChanBackupResponse

  rpc.proto:2391

  (message has no fields)

• rpc VerifyMessage (VerifyMessageRequest, VerifyMessageResponse)

  rpc.proto:319

  * lncli: `verifymessage` VerifyMessage verifies a signature over a msg. The signature must be zbase32 encoded and signed by an active node in the resident node's channel database. In addition to returning the validity of the signature, VerifyMessage also returns the recovered pubkey from the signature.

  message VerifyMessageRequest

  rpc.proto:1039

  • bytes msg = 1

    / The message over which the signature is to be verified

  • string signature = 2

    / The signature to be verified over the given message

  message VerifyMessageResponse

  rpc.proto:1046

  • bool valid = 1

    / Whether the signature was valid over the given message

  • string pubkey = 2

    / The pubkey recovered from the signature

• rpc WalletBalance (WalletBalanceRequest, WalletBalanceResponse)

  rpc.proto:217

  * lncli: `walletbalance` WalletBalance returns total unspent outputs(confirmed and unconfirmed), all confirmed unspent outputs and all unconfirmed unspent outputs under control of the wallet.

  message WalletBalanceRequest

  rpc.proto:1579

  (message has no fields)

  message WalletBalanceResponse

  rpc.proto:1581

  • int64 total_balance = 1

    / The balance of the wallet

  • int64 confirmed_balance = 2

    / The confirmed balance of a wallet(with >= 1 confirmations)

  • int64 unconfirmed_balance = 3

    / The unconfirmed balance of a wallet(with 0 confirmations)

The WalletUnlocker service is used to set up a wallet password for lnd at first startup, and unlock a previously set up wallet.

• rpc ChangePassword (ChangePasswordRequest, ChangePasswordResponse)

  rpc.proto:86

  * lncli: `changepassword` ChangePassword changes the password of the encrypted wallet. This will automatically unlock the wallet database if successful.

  message ChangePasswordRequest

  rpc.proto:196

  • bytes current_password = 1

    * current_password should be the current valid passphrase used to unlock the daemon.

  • bytes new_password = 2

    * new_password should be the new passphrase that will be needed to unlock the daemon.

  message ChangePasswordResponse

  rpc.proto:209

  (message has no fields)

• rpc GenSeed (GenSeedRequest, GenSeedResponse)

  rpc.proto:44

  * GenSeed is the first method that should be used to instantiate a new lnd instance. This method allows a caller to generate a new aezeed cipher seed given an optional passphrase. If provided, the passphrase will be necessary to decrypt the cipherseed to expose the internal wallet seed. Once the cipherseed is obtained and verified by the user, the InitWallet method should be used to commit the newly generated seed, and create the wallet.

  message GenSeedRequest

  rpc.proto:94

  • bytes aezeed_passphrase = 1

    * aezeed_passphrase is an optional user provided passphrase that will be used to encrypt the generated aezeed cipher seed.

  • bytes seed_entropy = 2

    * seed_entropy is an optional 16-bytes generated via CSPRNG. If not specified, then a fresh set of randomness will be used to create the seed.

  message GenSeedResponse

  rpc.proto:107

  • repeated string cipher_seed_mnemonic = 1

    * cipher_seed_mnemonic is a 24-word mnemonic that encodes a prior aezeed cipher seed obtained by the user. This field is optional, as if not provided, then the daemon will generate a new cipher seed for the user. Otherwise, then the daemon will attempt to recover the wallet state linked to this cipher seed.

  • bytes enciphered_seed = 2

    * enciphered_seed are the raw aezeed cipher seed bytes. This is the raw cipher text before run through our mnemonic encoding scheme.

• rpc InitWallet (InitWalletRequest, InitWalletResponse)

  rpc.proto:64

  * InitWallet is used when lnd is starting up for the first time to fully initialize the daemon and its internal wallet. At the very least a wallet password must be provided. This will be used to encrypt sensitive material on disk. In the case of a recovery scenario, the user can also specify their aezeed mnemonic and passphrase. If set, then the daemon will use this prior state to initialize its internal wallet. Alternatively, this can be used along with the GenSeed RPC to obtain a seed, then present it to the user. Once it has been verified by the user, the seed can be fed into this RPC in order to commit the new wallet.

  message InitWalletRequest

  rpc.proto:124

  • bytes wallet_password = 1

    * wallet_password is the passphrase that should be used to encrypt the wallet. This MUST be at least 8 chars in length. After creation, this password is required to unlock the daemon.

  • repeated string cipher_seed_mnemonic = 2

    * cipher_seed_mnemonic is a 24-word mnemonic that encodes a prior aezeed cipher seed obtained by the user. This may have been generated by the GenSeed method, or be an existing seed.

  • bytes aezeed_passphrase = 3

    * aezeed_passphrase is an optional user provided passphrase that will be used to encrypt the generated aezeed cipher seed.

  • int32 recovery_window = 4

    * recovery_window is an optional argument specifying the address lookahead when restoring a wallet seed. The recovery window applies to each individual branch of the BIP44 derivation paths. Supplying a recovery window of zero indicates that no addresses should be recovered, such after the first initialization of the wallet.

  • optional ChanBackupSnapshot channel_backups = 5

    * channel_backups is an optional argument that allows clients to recover the settled funds within a set of channels. This should be populated if the user was unable to close out all channels and sweep funds before partial or total data loss occurred. If specified, then after on-chain recovery of funds, lnd begin to carry out the data loss recovery protocol in order to recover the funds in each channel from a remote force closed transaction.

  message InitWalletResponse

  rpc.proto:164

  (message has no fields)

• rpc UnlockWallet (UnlockWalletRequest, UnlockWalletResponse)

  rpc.proto:75

  * lncli: `unlock` UnlockWallet is used at startup of lnd to provide a password to unlock the wallet database.

  message UnlockWalletRequest

  rpc.proto:167

  • bytes wallet_password = 1

    * wallet_password should be the current valid passphrase for the daemon. This will be required to decrypt on-disk material that the daemon requires to function properly.

  • int32 recovery_window = 2

    * recovery_window is an optional argument specifying the address lookahead when restoring a wallet seed. The recovery window applies to each individual branch of the BIP44 derivation paths. Supplying a recovery window of zero indicates that no addresses should be recovered, such after the first initialization of the wallet.

  • optional ChanBackupSnapshot channel_backups = 3

    * channel_backups is an optional argument that allows clients to recover the settled funds within a set of channels. This should be populated if the user was unable to close out all channels and sweep funds before partial or total data loss occurred. If specified, then after on-chain recovery of funds, lnd begin to carry out the data loss recovery protocol in order to recover the funds in each channel from a remote force closed transaction.

  message UnlockWalletResponse

  rpc.proto:194

  (message has no fields)

* `AddressType` has to be one of: - `p2wkh`: Pay to witness key hash (`WITNESS_PUBKEY_HASH` = 0) - `np2wkh`: Pay to nested witness key hash (`NESTED_PUBKEY_HASH` = 1)

Used in: NewAddressRequest, Utxo

• WITNESS_PUBKEY_HASH = 0

• NESTED_PUBKEY_HASH = 1

• UNUSED_WITNESS_PUBKEY_HASH = 2

• UNUSED_NESTED_PUBKEY_HASH = 3

Used in: GetInfoResponse

• string chain = 1

  / The blockchain the node is on (eg bitcoin, litecoin)

• string network = 2

  / The network the node is on (eg regtest, testnet, mainnet)

Used as request type in: Lightning.VerifyChanBackup

Used as response type in: Lightning.ExportAllChannelBackups, Lightning.SubscribeChannelBackups

Used as field type in: InitWalletRequest, UnlockWalletRequest

• optional ChannelBackups single_chan_backups = 1

  * The set of new channels that have been added since the last channel backup snapshot was requested.

• optional MultiChanBackup multi_chan_backup = 2

  * A multi-channel backup that covers all open channels currently known to lnd.

Used in: ChannelEventUpdate, ListChannelsResponse

• bool active = 1

  / Whether this channel is active or not

• string remote_pubkey = 2

  / The identity pubkey of the remote node

• string channel_point = 3

  * 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.

• uint64 chan_id = 4

  * 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.

• int64 capacity = 5

  / The total amount of funds held in this channel

• int64 local_balance = 6

  / This node's current balance in this channel

• int64 remote_balance = 7

  / The counterparty's current balance in this channel

• int64 commit_fee = 8

  * The amount calculated to be paid in fees for the current set of commitment transactions. The fee amount is persisted with the channel in order to allow the fee amount to be removed and recalculated with each channel state update, including updates that happen after a system restart.

• int64 commit_weight = 9

  / The weight of the commitment transaction

• int64 fee_per_kw = 10

  * The required number of satoshis per kilo-weight that the requester will pay at all times, for both the funding transaction and commitment transaction. This value can later be updated once the channel is open.

• int64 unsettled_balance = 11

  / The unsettled balance in this channel

• int64 total_satoshis_sent = 12

  * The total number of satoshis we've sent within this channel.

• int64 total_satoshis_received = 13

  * The total number of satoshis we've received within this channel.

• uint64 num_updates = 14

  * The total number of updates conducted within this channel.

• repeated HTLC pending_htlcs = 15

  * The list of active, uncleared HTLCs currently pending within the channel.

• uint32 csv_delay = 16

  * The CSV delay expressed in relative blocks. If the channel is force closed, we will need to wait for this many blocks before we can regain our funds.

• bool private = 17

  / Whether this channel is advertised to the network or not.

• bool initiator = 18

  / True if we were the ones that created the channel.

• string chan_status_flags = 19

  / A set of flags showing the current state of the channel.

Used as response type in: Lightning.ExportChannelBackup

Used as field type in: ChannelBackups

• optional ChannelPoint chan_point = 1

  * Identifies the channel that this backup belongs to.

• bytes chan_backup = 2

  * 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.

Used in: ChanBackupSnapshot, RestoreChanBackupRequest

• repeated ChannelBackup chan_backups = 1

  * A set of single-chan static channel backups.

Used in: ChannelEventUpdate, ClosedChannelsResponse

• string channel_point = 1

  / The outpoint (txid:index) of the funding transaction.

• uint64 chan_id = 2

  / The unique channel ID for the channel.

• string chain_hash = 3

  / The hash of the genesis block that this channel resides within.

• string closing_tx_hash = 4

  / The txid of the transaction which ultimately closed this channel.

• string remote_pubkey = 5

  / Public key of the remote peer that we formerly had a channel with.

• int64 capacity = 6

  / Total capacity of the channel.

• uint32 close_height = 7

  / Height at which the funding transaction was spent.

• int64 settled_balance = 8

  / Settled balance at the time of channel closure

• int64 time_locked_balance = 9

  / The sum of all the time-locked outputs at the time of channel closure

• ChannelCloseSummary.ClosureType close_type = 10

  / Details on how the channel was closed.

Used in: ChannelCloseSummary

• COOPERATIVE_CLOSE = 0

• LOCAL_FORCE_CLOSE = 1

• REMOTE_FORCE_CLOSE = 2

• BREACH_CLOSE = 3

• FUNDING_CANCELED = 4

• ABANDONED = 5

Used in: CloseStatusUpdate

• bytes closing_txid = 1

• bool success = 2

* A fully authenticated channel along with all its unique attributes. Once an authenticated channel announcement has been processed on the network, then an instance of ChannelEdgeInfo encapsulating the channels attributes is stored. The other portions relevant to routing policy of a channel are stored within a ChannelEdgePolicy for each direction of the channel.

Used as response type in: Lightning.GetChanInfo

Used as field type in: ChannelGraph, NodeInfo

• uint64 channel_id = 1

  * 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.

• string chan_point = 2

• uint32 last_update = 3

• string node1_pub = 4

• string node2_pub = 5

• int64 capacity = 6

• optional RoutingPolicy node1_policy = 7

• optional RoutingPolicy node2_policy = 8

Used in: GraphTopologyUpdate

• uint64 chan_id = 1

  * 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.

• optional ChannelPoint chan_point = 2

• int64 capacity = 3

• optional RoutingPolicy routing_policy = 4

• string advertising_node = 5

• string connecting_node = 6

Used in: ChannelEventUpdate

• OPEN_CHANNEL = 0

• CLOSED_CHANNEL = 1

• ACTIVE_CHANNEL = 2

• INACTIVE_CHANNEL = 3

Used in: FeeReportResponse

• string chan_point = 1

  / The channel that this fee report belongs to.

• int64 base_fee_msat = 2

  / The base fee charged regardless of the number of milli-satoshis sent.

• int64 fee_per_mil = 3

  / The amount charged per milli-satoshis transferred expressed in millionths of a satoshi.

• double fee_rate = 4

  / The effective fee rate in milli-satoshis. Computed by dividing the fee_per_mil value by 1 million.

Used in: OpenStatusUpdate

• optional ChannelPoint channel_point = 1

Used as response type in: Lightning.OpenChannelSync

Used as field type in: AbandonChannelRequest, ChannelBackup, ChannelEdgeUpdate, ChannelEventUpdate, ChannelOpenUpdate, CloseChannelRequest, ClosedChannelUpdate, ExportChannelBackupRequest, MultiChanBackup, PolicyUpdateRequest

• oneof funding_txid

  • bytes funding_txid_bytes = 1

    / Txid of the funding transaction

  • string funding_txid_str = 2

    / Hex-encoded string representing the funding transaction

• uint32 output_index = 3

  / The index of the output of the funding transaction

Used in: GraphTopologyUpdate

• uint64 chan_id = 1

  * 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.

• int64 capacity = 2

• uint32 closed_height = 3

• optional ChannelPoint chan_point = 4

• bytes block_sha = 1

• int32 block_height = 2

• uint32 num_confs_left = 3

Used in: QueryRoutesRequest

• uint64 channel_id = 1

  / The short channel id of this edge.

• bool direction_reverse = 2

  * The direction of this edge. If direction_reverse is false, the direction of this edge is from the channel endpoint with the lexicographically smaller pub key to the endpoint with the larger pub key. If direction_reverse is is true, the edge goes the other way.

Used in: QueryRoutesRequest, SendRequest

• oneof limit

  • int64 fixed = 1

    / The fee limit expressed as a fixed amount of satoshis.

  • int64 percent = 2

    / The fee limit expressed as a percentage of the payment amount.

Used in: ForwardingHistoryResponse

• uint64 timestamp = 1

  / Timestamp is the time (unix epoch offset) that this circuit was completed.

• uint64 chan_id_in = 2

  / The incoming channel ID that carried the HTLC that created the circuit.

• uint64 chan_id_out = 4

  / The outgoing channel ID that carried the preimage that completed the circuit.

• uint64 amt_in = 5

  / The total amount (in satoshis) of the incoming HTLC that created half the circuit.

• uint64 amt_out = 6

  / The total amount (in satoshis) of the outgoing HTLC that created the second half of the circuit.

• uint64 fee = 7

  / The total fee (in satoshis) that this payment circuit carried.

• uint64 fee_msat = 8

  / The total fee (in milli-satoshis) that this payment circuit carried.

Used as request type in: Lightning.GetTransactions, Lightning.SubscribeTransactions

(message has no fields)

Used in: Channel

• bool incoming = 1

• int64 amount = 2

• bytes hash_lock = 3

• uint32 expiration_height = 4

Used in: Route

• uint64 chan_id = 1

  * 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.

• int64 chan_capacity = 2

• int64 amt_to_forward = 3

• int64 fee = 4

• uint32 expiry = 5

• int64 amt_to_forward_msat = 6

• int64 fee_msat = 7

• string pub_key = 8

  * An optional public key of the hop. If the public key is given, the payment can be executed without relying on a copy of the channel graph.

Used in: RouteHint

• string node_id = 1

  / The public key of the node at the start of the channel.

• uint64 chan_id = 2

  / The unique identifier of the channel.

• uint32 fee_base_msat = 3

  / The base fee of the channel denominated in millisatoshis.

• uint32 fee_proportional_millionths = 4

  * The fee rate of the channel for sending one satoshi across it denominated in millionths of a satoshi.

• uint32 cltv_expiry_delta = 5

  / The time-lock delta of the channel.

Used as request type in: Lightning.AddInvoice

Used as response type in: Lightning.LookupInvoice, Lightning.SubscribeInvoices

Used as field type in: ListInvoiceResponse

• string memo = 1

  * 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.

• bytes receipt = 2

  * Deprecated. An optional cryptographic receipt of payment which is not implemented.

• bytes r_preimage = 3

  * The hex-encoded preimage (32 byte) which will allow settling an incoming HTLC payable to this preimage

• bytes r_hash = 4

  / The hash of the preimage

• int64 value = 5

  / The value of this invoice in satoshis

• bool settled = 6

  / Whether this invoice has been fulfilled

• int64 creation_date = 7

  / When this invoice was created

• int64 settle_date = 8

  / When this invoice was settled

• string payment_request = 9

  * 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.

• bytes description_hash = 10

  * 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.

• int64 expiry = 11

  / Payment request expiry time in seconds. Default is 3600 (1 hour).

• string fallback_addr = 12

  / Fallback on-chain address.

• uint64 cltv_expiry = 13

  / Delta to use for the time-lock of the CLTV extended to the final hop.

• repeated RouteHint route_hints = 14

  * Route hints that can each be individually used to assist in reaching the invoice's destination.

• bool private = 15

  / Whether this invoice should include routing hints for private channels.

• uint64 add_index = 16

  * 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.

• uint64 settle_index = 17

  * 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.

• int64 amt_paid = 18

  / Deprecated, use amt_paid_sat or amt_paid_msat.

• int64 amt_paid_sat = 19

  * 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.

• int64 amt_paid_msat = 20

  * 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.

• Invoice.InvoiceState state = 21

  * The state the invoice is in.

Used in: Invoice

• OPEN = 0

• SETTLED = 1

• CANCELED = 2

• ACCEPTED = 3

Used in: ConnectPeerRequest

• string pubkey = 1

  / The identity pubkey of the Lightning node

• string host = 2

  / The network location of the lightning node, e.g. `69.69.69.69:1337` or `localhost:10011`

* 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.

Used in: ChannelGraph, NodeInfo

• uint32 last_update = 1

• string pub_key = 2

• string alias = 3

• repeated NodeAddress addresses = 4

• string color = 5

Used in: ChanBackupSnapshot

• repeated ChannelPoint chan_points = 1

  * Is the set of all channels that are included in this multi-channel backup.

• bytes multi_chan_backup = 2

  * A single encrypted blob containing all the static channel backups of the channel listed above. This can be stored as a single file or blob, and safely be replaced with any prior/future versions.

Used in: LightningNode

• string network = 1

• string addr = 2

Used in: GraphTopologyUpdate

• repeated string addresses = 1

• string identity_key = 2

• bytes global_features = 3

• string alias = 4

• string color = 5

Used as request type in: Lightning.OpenChannel, Lightning.OpenChannelSync

• bytes node_pubkey = 2

  / The pubkey of the node to open a channel with

• string node_pubkey_string = 3

  / The hex encoded pubkey of the node to open a channel with

• int64 local_funding_amount = 4

  / The number of satoshis the wallet should commit to the channel

• int64 push_sat = 5

  / The number of satoshis to push to the remote side as part of the initial commitment state

• int32 target_conf = 6

  / The target number of blocks that the funding transaction should be confirmed by.

• int64 sat_per_byte = 7

  / A manual fee rate set in sat/byte that should be used when crafting the funding transaction.

• bool private = 8

  / Whether this channel should be private, not announced to the greater network.

• int64 min_htlc_msat = 9

  / The minimum value in millisatoshi we will require for incoming HTLCs on the channel.

• uint32 remote_csv_delay = 10

  / The delay we require on the remote's commitment transaction. If this is not set, it will be scaled automatically with the channel size.

• int32 min_confs = 11

  / The minimum number of confirmations each one of your outputs used for the funding transaction must satisfy.

• bool spend_unconfirmed = 12

  / Whether unconfirmed outputs should be used as inputs for the funding transaction.

Used in: Utxo

• bytes txid_bytes = 1

  / Raw bytes representing the transaction id.

• string txid_str = 2

  / Reversed, hex-encoded string representing the transaction id.

• uint32 output_index = 3

  / The index of the output on the transaction.

Used in: ListPaymentsResponse

• string payment_hash = 1

  / The payment hash

• int64 value = 2

  / Deprecated, use value_sat or value_msat.

• int64 creation_date = 3

  / The date of this payment

• repeated string path = 4

  / The path this payment took

• int64 fee = 5

  / The fee paid for this payment in satoshis

• string payment_preimage = 6

  / The payment preimage

• int64 value_sat = 7

  / The value of the payment in satoshis

• int64 value_msat = 8

  / The value of the payment in milli-satoshis

• string payment_request = 9

  / The optional payment request being fulfilled.

• Payment.PaymentStatus status = 10

  The status of the payment.

Used in: Payment

• UNKNOWN = 0

• IN_FLIGHT = 1

• SUCCEEDED = 2

• FAILED = 3

Used in: ListPeersResponse

• string pub_key = 1

  / The identity pubkey of the peer

• string address = 3

  / Network address of the peer; eg `127.0.0.1:10011`

• uint64 bytes_sent = 4

  / Bytes of data transmitted to this peer

• uint64 bytes_recv = 5

  / Bytes of data transmitted from this peer

• int64 sat_sent = 6

  / Satoshis sent to this peer

• int64 sat_recv = 7

  / Satoshis received from this peer

• bool inbound = 8

  / A channel is inbound if the counterparty initiated the channel

• int64 ping_time = 9

  / Ping time to this peer

• Peer.SyncType sync_type = 10

  The type of sync we are currently performing with this peer.

Used in: Peer

• UNKNOWN_SYNC = 0

  * Denotes that we cannot determine the peer's current sync type.

• ACTIVE_SYNC = 1

  * Denotes that we are actively receiving new graph updates from the peer.

• PASSIVE_SYNC = 2

  * Denotes that we are not receiving new graph updates from the peer.

Used in: PendingChannelsResponse

• optional PendingChannel channel = 1

  / The pending channel to be closed

• string closing_txid = 2

  / The transaction id of the closing transaction

Used in: PendingChannelsResponse

• optional PendingChannel channel = 1

  / The pending channel to be force closed

• string closing_txid = 2

  / The transaction id of the closing transaction

• int64 limbo_balance = 3

  / The balance in satoshis encumbered in this pending channel

• uint32 maturity_height = 4

  / The height at which funds can be swept into the wallet

• int32 blocks_til_maturity = 5

  Remaining # of blocks until the commitment output can be swept. Negative values indicate how many blocks have passed since becoming mature.

• int64 recovered_balance = 6

  / The total value of funds successfully recovered from this channel

• repeated PendingHTLC pending_htlcs = 8

Used in: ClosedChannel, ForceClosedChannel, PendingOpenChannel, WaitingCloseChannel

• string remote_node_pub = 1

• string channel_point = 2

• int64 capacity = 3

• int64 local_balance = 4

• int64 remote_balance = 5

Used in: PendingChannelsResponse

• optional PendingChannel channel = 1

  / The pending channel

• uint32 confirmation_height = 2

  / The height at which this channel will be confirmed

• int64 commit_fee = 4

  * The amount calculated to be paid in fees for the current set of commitment transactions. The fee amount is persisted with the channel in order to allow the fee amount to be removed and recalculated with each channel state update, including updates that happen after a system restart.

• int64 commit_weight = 5

  / The weight of the commitment transaction

• int64 fee_per_kw = 6

  * The required number of satoshis per kilo-weight that the requester will pay at all times, for both the funding transaction and commitment transaction. This value can later be updated once the channel is open.

Used in: PendingChannelsResponse

• optional PendingChannel channel = 1

  / The pending channel waiting for closing tx to confirm

• int64 limbo_balance = 2

  / The balance in satoshis encumbered in this channel

Used in: PendingChannelsResponse.ForceClosedChannel

• bool incoming = 1

  / The direction within the channel that the htlc was sent

• int64 amount = 2

  / The total value of the htlc

• string outpoint = 3

  / The final output to be swept back to the user's wallet

• uint32 maturity_height = 4

  / The next block height at which we can spend the current stage

• int32 blocks_til_maturity = 5

  * The number of blocks remaining until the current stage can be swept. Negative values indicate how many blocks have passed since becoming mature.

• uint32 stage = 6

  / Indicates whether the htlc is in its first or second stage of recovery

Used in: CloseStatusUpdate, OpenStatusUpdate

• bytes txid = 1

• uint32 output_index = 2

* A path through the channel graph which runs over one or more channels in succession. This struct carries all the information required to craft the Sphinx onion packet, and send the payment along the first hop in the path. A route is only selected as valid if all the channels have sufficient capacity to carry the initial payment amount after fees are accounted for.

Used in: QueryRoutesResponse, SendResponse, SendToRouteRequest

• uint32 total_time_lock = 1

  * The cumulative (final) time lock across the entire route. This is the CLTV value that should be extended to the first hop in the route. All other hops will decrement the time-lock as advertised, leaving enough time for all hops to wait for or present the payment preimage to complete the payment.

• int64 total_fees = 2

  * The sum of the fees paid at each hop within the final route. In the case of a one-hop payment, this value will be zero as we don't need to pay a fee to ourselves.

• int64 total_amt = 3

  * The total amount of funds required to complete a payment over this route. This value includes the cumulative fees at each hop. As a result, the HTLC extended to the first-hop in the route will need to have at least this many satoshis, otherwise the route will fail at an intermediate node due to an insufficient amount of fees.

• repeated Hop hops = 4

  * Contains details concerning the specific forwarding details at each hop.

• int64 total_fees_msat = 5

  * The total fees in millisatoshis.

• int64 total_amt_msat = 6

  * The total amount in millisatoshis.

Used in: Invoice, PayReq

• repeated HopHint hop_hints = 1

  * A list of hop hints that when chained together can assist in reaching a specific destination.

Used in: ChannelEdge, ChannelEdgeUpdate

• uint32 time_lock_delta = 1

• int64 min_htlc = 2

• int64 fee_base_msat = 3

• int64 fee_rate_milli_msat = 4

• bool disabled = 5

• uint64 max_htlc_msat = 6

Used as request type in: Lightning.SendPayment, Lightning.SendPaymentSync

• bytes dest = 1

  / The identity pubkey of the payment recipient

• string dest_string = 2

  / The hex-encoded identity pubkey of the payment recipient

• int64 amt = 3

  / Number of satoshis to send.

• bytes payment_hash = 4

  / The hash to use within the payment's HTLC

• string payment_hash_string = 5

  / The hex-encoded hash to use within the payment's HTLC

• string payment_request = 6

  * 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.

• int32 final_cltv_delta = 7

  * The CLTV delta from the current height that should be used to set the timelock for the final hop.

• optional FeeLimit fee_limit = 8

  * 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.

• uint64 outgoing_chan_id = 9

  * The channel id of the channel that must be taken to the first hop. If zero, any channel may be used.

• uint32 cltv_limit = 10

  * An optional maximum total time lock for the route. If zero, there is no maximum enforced.

Used as response type in: Lightning.SendPayment, Lightning.SendPaymentSync, Lightning.SendToRoute, Lightning.SendToRouteSync

• string payment_error = 1

• bytes payment_preimage = 2

• optional Route payment_route = 3

• bytes payment_hash = 4

Used as request type in: Lightning.SendToRoute, Lightning.SendToRouteSync

• bytes payment_hash = 1

  / The payment hash to use for the HTLC.

• string payment_hash_string = 2

  / An optional hex-encoded payment hash to be used for the HTLC.

• optional Route route = 4

  / Route that should be used to attempt to complete the payment.

Used as response type in: Lightning.SubscribeTransactions

Used as field type in: TransactionDetails

• string tx_hash = 1

  / The transaction hash

• int64 amount = 2

  / The transaction amount, denominated in satoshis

• int32 num_confirmations = 3

  / The number of confirmations

• string block_hash = 4

  / The hash of the block this transaction was included in

• int32 block_height = 5

  / The height of the block this transaction was included in

• int64 time_stamp = 6

  / Timestamp of this transaction

• int64 total_fees = 7

  / Fees paid for this transaction

• repeated string dest_addresses = 8

  / Addresses that received funds for this transaction

• string raw_tx_hex = 9

  / The raw transaction hex.

Used in: ListUnspentResponse

• AddressType type = 1

  / The type of address

• string address = 2

  / The address

• int64 amount_sat = 3

  / The value of the unspent coin in satoshis

• string pk_script = 4

  / The pkscript in hex

• optional OutPoint outpoint = 5

  / The outpoint in format txid:n

• int64 confirmations = 6

  / The number of confirmations for the Utxo