package lnrpc
Get desktop application:
View/edit binary Protocol Buffers messages
service Lightning
lightning.proto:26Lightning is the main RPC server of the daemon.
rpc AbandonChannel (, )
lightning.proto:263lncli: `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. This method can also be used to remove externally funded channels where the funding transaction was never broadcast. Only available for non-externally funded channels in dev build.
message
lightning.proto:4501optional channel_point = 1
bool pending_funding_shim_only = 2
bool i_know_what_i_am_doing = 3
Override the requirement for being in dev mode by setting this to true and confirming the user knows what they are doing and this is a potential foot gun to lose funds if used on active channels.
message
lightning.proto:4514string status = 1
The status of the abandon operation.
rpc AddInvoice (, )
lightning.proto:270lncli: `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
lightning.proto:4127bytes 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.
bytes payment_addr = 17
The payment address of the generated invoice. This is also called payment secret in specifications (e.g. BOLT 11). This value should be used in all payments for this invoice as we require it for end to end security.
rpc BakeMacaroon (, )
lightning.proto:494lncli: `bakemacaroon` 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.
message
lightning.proto:4899repeated permissions = 1
The list of permissions the new macaroon should grant.
uint64 root_key_id = 2
The root key ID used to create the macaroon, must be a positive integer.
bool allow_external_permissions = 3
Informs the RPC on whether to allow external permissions that LND is not aware of.
message
lightning.proto:4912string macaroon = 1
The hex encoded macaroon, serialized in binary format.
rpc BatchOpenChannel (, )
lightning.proto:219lncli: `batchopenchannel` BatchOpenChannel attempts to open multiple single-funded channels in a single transaction in an atomic way. This means either all channel open requests succeed at once or all attempts are aborted if any of them fail. This is the safer variant of using PSBTs to manually fund a batch of channels through the OpenChannel RPC.
message
lightning.proto:2169repeated channels = 1
The list of channels to open.
int32 target_conf = 2
The target number of blocks that the funding transaction should be confirmed by.
int64 sat_per_vbyte = 3
A manual fee rate set in sat/vByte that should be used when crafting the funding transaction.
int32 min_confs = 4
The minimum number of confirmations each one of your outputs used for the funding transaction must satisfy.
bool spend_unconfirmed = 5
Whether unconfirmed outputs should be used as inputs for the funding transaction.
string label = 6
An optional label for the batch transaction, limited to 500 characters.
CoinSelectionStrategy coin_selection_strategy = 7
The strategy to use for selecting coins during batch opening channels.
message
lightning.proto:2316repeated pending_channels = 1
rpc ChannelAcceptor (stream , stream )
lightning.proto:241ChannelAcceptor 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.
message
lightning.proto:925bool accept = 1
Whether or not the client accepts the channel.
bytes pending_chan_id = 2
The pending channel id to which this response applies.
string error = 3
An optional error to send the initiating party to indicate why the channel was rejected. This field *should not* contain sensitive information, it will be sent to the initiating party. This field should only be set if accept is false, the channel will be rejected if an error is set with accept=true because the meaning of this response is ambiguous. Limited to 500 characters.
string upfront_shutdown = 4
The upfront shutdown address to use if the initiating peer supports option upfront shutdown script (see ListPeers for the features supported). Note that the channel open will fail if this value is set for a peer that does not support this feature bit.
uint32 csv_delay = 5
The csv delay (in blocks) that we require for the remote party.
uint64 reserve_sat = 6
The reserve amount in satoshis that we require the remote peer to adhere to. We require that the remote peer always have some reserve amount allocated to them so that there is always a disincentive to broadcast old state (if they hold 0 sats on their side of the channel, there is nothing to lose).
uint64 in_flight_max_msat = 7
The maximum amount of funds in millisatoshis that we allow the remote peer to have in outstanding htlcs.
uint32 max_htlc_count = 8
The maximum number of htlcs that the remote peer can offer us.
uint64 min_htlc_in = 9
The minimum value in millisatoshis for incoming htlcs on the channel.
uint32 min_accept_depth = 10
The number of confirmations we require before we consider the channel open.
bool zero_conf = 11
Whether the responder wants this to be a zero-conf channel. This will fail if either side does not have the scid-alias feature bit set. The minimum depth field must be zero if this is true.
message
lightning.proto:865bytes node_pubkey = 1
The pubkey of the node that wishes to open an inbound channel.
bytes chain_hash = 2
The hash of the genesis block that the proposed channel resides in.
bytes pending_chan_id = 3
The pending channel id.
uint64 funding_amt = 4
The funding amount in satoshis that initiator wishes to use in the channel.
uint64 push_amt = 5
The push amount of the proposed channel in millisatoshis.
uint64 dust_limit = 6
The dust limit of the initiator's commitment tx.
uint64 max_value_in_flight = 7
The maximum amount of coins in millisatoshis that can be pending in this channel.
uint64 channel_reserve = 8
The minimum amount of satoshis the initiator requires us to have at all times.
uint64 min_htlc = 9
The smallest HTLC in millisatoshis that the initiator will accept.
uint64 fee_per_kw = 10
The initial fee rate that the initiator suggests for both commitment transactions.
uint32 csv_delay = 11
The number of blocks to use for the relative time lock in the pay-to-self output of both commitment transactions.
uint32 max_accepted_htlcs = 12
The total number of incoming HTLC's that the initiator will accept.
uint32 channel_flags = 13
A bit-field which the initiator uses to specify proposed channel behavior.
CommitmentType commitment_type = 14
The commitment type the initiator wishes to use for the proposed channel.
bool wants_zero_conf = 15
Whether the initiator wants to open a zero-conf channel via the channel type.
bool wants_scid_alias = 16
Whether the initiator wants to use the scid-alias channel type. This is separate from the feature bit.
rpc ChannelBalance (, )
lightning.proto:39lncli: `channelbalance` ChannelBalance returns a report on the total funds across all open channels, categorized in local/remote, pending local/remote and unsettled local/remote balances.
message
lightning.proto:3045(message has no fields)
message
lightning.proto:3047int64 balance = 1
Deprecated. Sum of channels balances denominated in satoshis
int64 pending_open_balance = 2
Deprecated. Sum of channels pending balances denominated in satoshis
optional local_balance = 3
Sum of channels local balances.
optional remote_balance = 4
Sum of channels remote balances.
optional unsettled_local_balance = 5
Sum of channels local unsettled balances.
optional unsettled_remote_balance = 6
Sum of channels remote unsettled balances.
optional pending_open_local_balance = 7
Sum of channels pending local balances.
optional pending_open_remote_balance = 8
Sum of channels pending remote balances.
bytes custom_channel_data = 9
Custom channel data that might be populated if there are custom channels present.
CheckMacaroonPermissions checks whether the provided macaroon contains all the provided permissions. If the macaroon is valid (e.g. all caveats are satisfied), and all permissions provided in the request are met, then this RPC returns true.
message
lightning.proto:5124bytes macaroon = 1
The macaroon to check permissions for, serialized in binary format. For a macaroon to be valid, it must have been issued by lnd, must succeed all caveat conditions, and must contain all of the permissions specified in the permissions field.
repeated permissions = 2
The list of permissions the macaroon should be checked against. Only if the macaroon contains all of these permissions, it is considered valid. If the list of permissions given is empty, then the macaroon is considered valid only based on issuance authority and caveat validity. An empty list of permissions is therefore equivalent to saying "skip checking permissions" (unless check_default_perms_from_full_method is specified).
string fullMethod = 3
The RPC method to check the macaroon against. This is only used if there are custom `uri:<rpcpackage>.<ServiceName>/<MethodName>` permissions in the permission list above. To check a macaroon against the list of permissions of a certain RPC method, query the `ListPermissions` RPC first, extract the permissions for the method, and then pass them in the `permissions` field above.
bool check_default_perms_from_full_method = 4
If this field is set to true, then the permissions list above MUST be empty. The default permissions for the provided fullMethod will be used to check the macaroon. This is equivalent to looking up the permissions for a method in the `ListPermissions` RPC and then calling this RPC with the permission list returned from that call. Without this flag, the list of permissions must be non-empty for the check to actually perform a permission check.
message
lightning.proto:5158bool valid = 1
rpc CloseChannel (, stream )
lightning.proto:253lncli: `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
lightning.proto:2077optional 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
Deprecated, use sat_per_vbyte. A manual fee rate set in sat/vbyte that should be used when crafting the closure transaction.
string delivery_address = 5
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.
uint64 sat_per_vbyte = 6
A manual fee rate set in sat/vbyte that should be used when crafting the closure transaction.
uint64 max_fee_per_vbyte = 7
The maximum fee rate the closer is willing to pay. NOTE: This field is only respected if we're the initiator of the channel.
bool no_wait = 8
If true, then the rpc call will not block while it awaits a closing txid to be broadcasted to the mempool. To obtain the closing tx one has to listen to the stream for the particular updates. Moreover if a coop close is specified and this flag is set to true the coop closing flow will be initiated even if HTLCs are active on the channel. The channel will wait until all HTLCs are resolved and then start the coop closing process. The channel will be disabled in the meantime and will disallow any new HTLCs.
message
lightning.proto:2125oneof update
close_pending = 1
chan_close = 3
close_instant = 4
rpc ClosedChannels (, )
lightning.proto:190lncli: `closedchannels` ClosedChannels returns a description of all the closed channels that this node was a participant in.
message
lightning.proto:1781bool cooperative = 1
bool local_force = 2
bool remote_force = 3
bool breach = 4
bool funding_canceled = 5
bool abandoned = 6
message
lightning.proto:1790repeated channels = 1
rpc ConnectPeer (, )
lightning.proto:118lncli: `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
lightning.proto:1253optional addr = 1
Lightning address of the peer to connect to.
bool perm = 2
If set, the daemon will attempt to persistently connect to the target peer. Otherwise, the call will be synchronous.
uint64 timeout = 3
The connection timeout value (in seconds) for this request. It won't affect other requests.
message
lightning.proto:1271string status = 1
The status of the connect operation.
rpc DebugLevel (, )
lightning.proto:408lncli: `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
lightning.proto:4519bool show = 1
string level_spec = 2
message
lightning.proto:4523string sub_systems = 1
rpc DecodePayReq (, )
lightning.proto:315lncli: `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
lightning.proto:4527string pay_req = 1
The payment request string to be decoded
message
lightning.proto:4531string 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 route_hints = 10
bytes payment_addr = 11
int64 num_msat = 12
map<uint32, > features = 13
repeated blinded_paths = 14
rpc DeleteAllPayments (, )
lightning.proto:332lncli: `deletepayments --all` DeleteAllPayments deletes all outgoing payments from DB. Note that it will not attempt to delete In-Flight payments, since that would be unsafe.
message
lightning.proto:4477bool failed_payments_only = 1
Only delete failed payments.
bool failed_htlcs_only = 2
Only delete failed HTLCs from payments, not the payment itself.
bool all_payments = 3
Delete all payments. NOTE: Using this option requires careful consideration as it is a destructive operation.
message
lightning.proto:4496string status = 1
The status of the delete operation.
lncli: `deletecanceledinvoice` DeleteCanceledInvoice removes a canceled invoice from the database. If the invoice is not in the canceled state, an error will be returned.
message
lightning.proto:4237string invoice_hash = 1
Invoice payment hash to delete.
message
lightning.proto:4242string status = 1
The status of the delete operation.
rpc DeleteMacaroonID (, )
lightning.proto:506lncli: `deletemacaroonid` DeleteMacaroonID deletes the specified macaroon ID and invalidates all macaroons derived from that ID.
message
lightning.proto:4924uint64 root_key_id = 1
The root key ID to be removed.
message
lightning.proto:4928bool deleted = 1
A boolean indicates that the deletion is successful.
rpc DeletePayment (, )
lightning.proto:326lncli: `deletepayments` DeletePayment deletes an outgoing payment from DB. Note that it will not attempt to delete an In-Flight payment, since that would be unsafe.
message
lightning.proto:4467bytes payment_hash = 1
Payment hash to delete.
bool failed_htlcs_only = 2
Only delete failed HTLCs from the payment, not the payment itself.
message
lightning.proto:4491string status = 1
The status of the delete operation.
rpc DescribeGraph (, )
lightning.proto:343lncli: `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
lightning.proto:3553bool 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.
bool include_auth_proof = 2
If true, will include announcements' signatures into ChannelEdge.
rpc DisconnectPeer (, )
lightning.proto:125lncli: `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
lightning.proto:1276string pub_key = 1
The pubkey of the node to disconnect from
message
lightning.proto:1280string status = 1
The status of the disconnect operation.
rpc EstimateFee (, )
lightning.proto:56lncli: `estimatefee` EstimateFee asks the chain backend to estimate the fee rate and total fees for a transaction that pays to multiple specified outputs. When using REST, the `AddrToAmount` map type can be set by appending `&AddrToAmount[<address>]=<amount_to_send>` to the URL. Unfortunately this map type doesn't appear in the REST API documentation because of a bug in the grpc-gateway library.
message
lightning.proto:1052map<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.
int32 min_confs = 3
The minimum number of confirmations each one of your outputs used for the transaction must satisfy.
bool spend_unconfirmed = 4
Whether unconfirmed outputs should be used as inputs for the transaction.
CoinSelectionStrategy coin_selection_strategy = 5
The strategy to use for selecting coins during fees estimation.
repeated inputs = 6
A list of selected inputs for the transaction.
message
lightning.proto:1074int64 fee_sat = 1
The total fee in satoshis.
int64 feerate_sat_per_byte = 2
Deprecated, use sat_per_vbyte. The fee rate in satoshi/vbyte.
uint64 sat_per_vbyte = 3
The fee rate in satoshi/vbyte.
repeated inputs = 4
A list of selected inputs for the transaction the estimate is for.
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
lightning.proto:4843(message has no fields)
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
lightning.proto:4808optional chan_point = 1
The target channel point to obtain a back up for.
rpc FeeReport (, )
lightning.proto:414lncli: `feereport` FeeReport allows the caller to obtain a report detailing the current fee schedule enforced by the node globally for each channel.
message
lightning.proto:4584(message has no fields)
message
lightning.proto:4612repeated 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 (, )
lightning.proto:436lncli: `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, for a maximum number of events. If no maximum number of events is specified, up to 100 events will be returned. If no time-range is specified, then events will be returned in the order that they occured. 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
lightning.proto:4711uint64 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.
bool peer_alias_lookup = 5
Informs the server if the peer alias should be looked up for each forwarding event.
repeated uint64 incoming_chan_ids = 6
List of incoming channel ids to filter htlcs received from a particular channel
repeated uint64 outgoing_chan_ids = 7
List of outgoing channel ids to filter htlcs being forwarded to a particular channel
message
lightning.proto:4798repeated 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 FundingStateStep (, )
lightning.proto:232FundingStateStep 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.
message
lightning.proto:2660oneof trigger
shim_register = 1
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 = 2
Used to cancel an existing registered funding shim.
psbt_verify = 3
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 = 4
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.
message
lightning.proto:2689(message has no fields)
rpc GetChanInfo (, )
lightning.proto:357lncli: `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
lightning.proto:3603uint64 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.
string chan_point = 2
The channel point of the channel in format funding_txid:output_index. If chan_id is specified, this field is ignored.
bool include_auth_proof = 3
If true, will include announcements' signatures into ChannelEdge.
rpc GetDebugInfo (, )
lightning.proto:151lncli: 'getdebuginfo' GetDebugInfo returns debug information concerning the state of the daemon and its subsystems. This includes the full configuration and the latest log entries from the log file.
message
lightning.proto:2006bool include_log = 1
If set to true, the log file content will be included in the response. By default, only the config information is returned.
message
lightning.proto:2012map<string, string> config = 1
repeated string log = 2
rpc GetInfo (, )
lightning.proto:144lncli: `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
lightning.proto:1914(message has no fields)
message
lightning.proto:1923string version = 14
The version of the LND software that the node is running.
string commit_hash = 20
The SHA1 commit hash that the daemon is compiled with.
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"
string color = 17
The color of the current node in hex code format
uint32 num_pending_channels = 3
Number of pending channels
uint32 num_active_channels = 4
Number of active channels
uint32 num_inactive_channels = 15
Number of inactive 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
int64 best_header_timestamp = 13
Timestamp of the block best known to the wallet
bool synced_to_chain = 9
Whether the wallet's view is synced to the main chain
bool synced_to_graph = 18
Whether we consider ourselves synced with the public channel graph.
bool testnet = 10
Whether the current node is connected to testnet or testnet4. This field is deprecated and the network field should be used instead.
repeated chains = 16
A list of active chains the node is connected to. This will only ever contain a single entry since LND will only ever have a single chain backend during its lifetime.
repeated string uris = 12
The URIs of the current node.
map<uint32, > features = 19
Features that our node has advertised in our init message, node announcements and invoices.
bool require_htlc_interceptor = 21
Indicates whether the HTLC interceptor API is in always-on mode.
bool store_final_htlc_resolutions = 22
Indicates whether final htlc resolutions are stored on disk.
bool wallet_synced = 23
Whether the wallet is fully synced to the best chain. This indicates the wallet's internal sync state with the backing chain source.
GraphCacheStatus graph_cache_status = 24
The current status of the in-memory graph cache.
rpc GetNetworkInfo (, )
lightning.proto:383lncli: `getnetworkinfo` GetNetworkInfo returns some basic stats about the known channel graph from the point of view of the node.
message
lightning.proto:3619(message has no fields)
message
lightning.proto:3621uint32 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
uint64 num_zombie_chans = 11
The number of edges marked as zombies.
rpc GetNodeInfo (, )
lightning.proto:363lncli: `getnodeinfo` GetNodeInfo returns the latest advertised, aggregated, and authenticated channel information for the specified node identified by its public key.
message
lightning.proto:3420string 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.
bool include_auth_proof = 3
If true, will include announcements' signatures into ChannelEdge. Depends on include_channels.
message
lightning.proto:3432optional 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 channels = 4
A list of all public channels for the node.
rpc GetNodeMetrics (, )
lightning.proto:349lncli: `getnodemetrics` GetNodeMetrics returns node metrics calculated from the graph. Currently the only supported metric is betweenness centrality of individual nodes.
message
lightning.proto:3579repeated NodeMetricType types = 1
The requested node metrics.
message
lightning.proto:3584map<string, > betweenness_centrality = 1
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.
rpc GetRecoveryInfo (, )
lightning.proto:158* lncli: `getrecoveryinfo` GetRecoveryInfo returns information concerning the recovery mode including whether it's in a recovery mode, whether the recovery is finished, and the progress made so far.
message
lightning.proto:2017(message has no fields)
message
lightning.proto:2019bool recovery_mode = 1
Whether the wallet is in recovery mode
bool recovery_finished = 2
Whether the wallet recovery progress is finished
double progress = 3
The recovery progress, ranging from 0 to 1.
rpc GetTransactions (, )
lightning.proto:45lncli: `listchaintxns` GetTransactions returns a list describing all the known transactions relevant to the wallet.
rpc ListAliases (, )
lightning.proto:576lncli: `listaliases` ListAliases returns the set of all aliases that have ever existed with their confirmed SCID (if it exists) and/or the base SCID (in the case of zero conf).
message
lightning.proto:1625(message has no fields)
message
lightning.proto:1627repeated alias_maps = 1
rpc ListChannels (, )
lightning.proto:175lncli: `listchannels` ListChannels returns a description of all the open channels that this node is a participant in.
message
lightning.proto:1593bool active_only = 1
bool inactive_only = 2
bool public_only = 3
bool private_only = 4
bytes peer = 5
Filters the response for channels with a target peer's pubkey. If peer is empty, all channels will be returned.
bool peer_alias_lookup = 6
Informs the server if the peer alias lookup per channel should be enabled. It is turned off by default in order to avoid degradation of performance for existing clients.
message
lightning.proto:1610repeated channels = 11
The list of active channels
rpc ListInvoices (, )
lightning.proto:281lncli: `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
lightning.proto:4168bool pending_only = 1
If set, only invoices that are not settled and not canceled 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.
uint64 creation_date_start = 7
If set, returns all invoices with a creation date greater than or equal to it. Measured in seconds since the unix epoch.
uint64 creation_date_end = 8
If set, returns all invoices with a creation date less than or equal to it. Measured in seconds since the unix epoch.
message
lightning.proto:4199repeated 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 ListMacaroonIDs (, )
lightning.proto:499lncli: `listmacaroonids` ListMacaroonIDs returns all root key IDs that are in use.
message
lightning.proto:4917(message has no fields)
message
lightning.proto:4919repeated uint64 root_key_ids = 1
The list of root key IDs that are in use.
rpc ListPayments (, )
lightning.proto:320lncli: `listpayments` ListPayments returns a list of all outgoing payments.
message
lightning.proto:4393bool 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. This flag doesn't change the meaning of the indices, which are tied to individual payments.
uint64 index_offset = 2
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.
uint64 max_payments = 3
The maximal number of payments returned in the response to this query.
bool reversed = 4
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).
bool count_total_payments = 5
If set, all payments (complete and incomplete, independent of the max_payments parameter) will be counted. Note that setting this to true will increase the run time of the call significantly on systems that have a lot of payments, as all of them have to be iterated through to be counted.
uint64 creation_date_start = 6
If set, returns all payments with a creation date greater than or equal to it. Measured in seconds since the unix epoch.
uint64 creation_date_end = 7
If set, returns all payments with a creation date less than or equal to it. Measured in seconds since the unix epoch.
bool omit_hops = 8
If set, omit hop-level route data for HTLC attempts to reduce query cost and response size.
message
lightning.proto:4442repeated payments = 1
The list of payments
uint64 first_index_offset = 2
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.
uint64 last_index_offset = 3
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.
uint64 total_num_payments = 4
Will only be set if count_total_payments in the request was set. Represents the total number of payments (complete and incomplete, independent of the number of payments requested in the query) currently present in the payments database.
rpc ListPeers (, )
lightning.proto:130lncli: `listpeers` ListPeers returns a verbose listing of all currently active peers.
message
lightning.proto:1886bool latest_error = 1
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.
message
lightning.proto:1894repeated peers = 1
The list of currently connected peers
rpc ListPermissions (, )
lightning.proto:513lncli: `listpermissions` ListPermissions lists all RPC method URIs and their required macaroon permissions to access them.
message
lightning.proto:4938(message has no fields)
message
lightning.proto:4940map<string, > method_permissions = 1
A map between all RPC method URIs and their required macaroon permissions to access them.
rpc ListUnspent (, )
lightning.proto:73lncli: `listunspent` Deprecated, use walletrpc.ListUnspent instead. ListUnspent returns a list of all utxos spendable by the wallet with a number of confirmations between the specified minimum and maximum.
message
lightning.proto:1171int32 min_confs = 1
The minimum number of confirmations to be included.
int32 max_confs = 2
The maximum number of confirmations to be included.
string account = 3
An optional filter to only include outputs belonging to an account.
message
lightning.proto:1181repeated utxos = 1
A list of utxos
LookupHtlcResolution retrieves a final htlc resolution from the database. If the htlc has no final resolution yet, a NotFound grpc status code is returned.
message
lightning.proto:587uint64 chan_id = 1
uint64 htlc_index = 2
message
lightning.proto:593bool settled = 1
Settled is true is the htlc was settled. If false, the htlc was failed.
bool offchain = 2
Offchain indicates whether the htlc was resolved off-chain or on-chain.
rpc LookupInvoice (, )
lightning.proto:288lncli: `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
lightning.proto:4152string 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. Deprecated now that the REST gateway supports base64 encoding of bytes fields.
bytes r_hash = 2
The payment hash of the invoice to be looked up. When using REST, this field must be encoded as base64.
rpc NewAddress (, )
lightning.proto:94lncli: `newaddress` NewAddress creates a new address under control of the local wallet.
message
lightning.proto:1202AddressType type = 1
The type of address to generate.
string account = 2
The name of the account to generate a new address for. If empty, the default wallet account is used.
message
lightning.proto:1212string address = 1
The newly generated wallet address
rpc OpenChannel (, stream )
lightning.proto:210lncli: `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. 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.
message
lightning.proto:2482oneof update
chan_pending = 1
Signals that the channel is now fully negotiated and the funding transaction published.
chan_open = 3
Signals that the channel's funding transaction has now reached the required number of confirmations on chain and can be used.
psbt_fund = 5
Signals that the funding process has been suspended and the construction of a PSBT that funds the channel PK script is now required.
bytes pending_chan_id = 4
The pending channel ID of the created channel. This value may be used to further the funding flow manually via the FundingStateStep method.
rpc OpenChannelSync (, )
lightning.proto:198OpenChannelSync 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 (, )
lightning.proto:168lncli: `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
lightning.proto:2716bool include_raw_tx = 1
Indicates whether to include the raw transaction hex for waiting_close_channels.
message
lightning.proto:2721int64 total_limbo_balance = 1
The balance in satoshis encumbered in pending channels
repeated pending_open_channels = 2
Channels pending opening
repeated pending_closing_channels = 3
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.
repeated pending_force_closing_channels = 4
Channels pending force closing
repeated waiting_close_channels = 5
Channels waiting for closing tx to confirm
rpc QueryRoutes (, )
lightning.proto:377lncli: `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. When using REST, the `dest_custom_records` map type can be set by appending `&dest_custom_records[<record_number>]=<record_data_base64_url_encoded>` to the URL. Unfortunately this map type doesn't appear in the REST API documentation because of a bug in the grpc-gateway library.
message
lightning.proto:3079string pub_key = 1
The 33-byte hex-encoded public key for the payment destination
int64 amt = 2
The amount to send expressed in satoshis. The fields amt and amt_msat are mutually exclusive.
int64 amt_msat = 12
The amount to send expressed in millisatoshis. The fields amt and amt_msat are mutually exclusive.
int32 final_cltv_delta = 4
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. Note: must not be set if making a payment to a blinded path (delta is set by the aggregate parameters provided by blinded_payment_paths)
optional 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. If not specified, lnd will use a default value of 100% fees for small amounts (<=1k sat) or 5% fees for larger amounts.
repeated bytes ignored_nodes = 6
A list of nodes to ignore during path finding. When using REST, these fields must be encoded as base64.
repeated ignored_edges = 7
Deprecated. 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.
bool use_mission_control = 9
If set to true, edge probabilities from mission control will be used to get the optimal route.
repeated ignored_pairs = 10
A list of directed node pairs that will be ignored during path finding.
uint32 cltv_limit = 11
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.
map<uint64, bytes> dest_custom_records = 13
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 records, an 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.
bytes last_hop_pubkey = 15
The pubkey of the last hop of the route. If empty, any hop may be used.
repeated route_hints = 16
Optional route hints to reach the destination through private channels.
repeated blinded_payment_paths = 19
An optional blinded path(s) to reach the destination. Note that the introduction node must be provided as the first hop in the route.
repeated FeatureBit dest_features = 17
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. Note: must not be set if making a payment to a blinded route (features are provided in blinded_payment_paths).
double time_pref = 18
The time preference for this payment. Set to -1 to optimize for fees only, to 1 to optimize for reliability only or a value inbetween for a mix.
repeated uint64 outgoing_chan_ids = 20
The channel ids of the channels allowed for the first hop. If empty, any channel may be used.
message
lightning.proto:3235repeated routes = 1
The route that results from the path finding operation. This is still a repeated field to retain backwards compatibility.
double success_prob = 2
The success probability of the returned route based on the current mission control state. [EXPERIMENTAL]
rpc RegisterRPCMiddleware (stream , stream )
lightning.proto:539RegisterRPCMiddleware adds a new gRPC middleware to the interceptor chain. A gRPC middleware is software component external to lnd that aims to add additional business logic to lnd by observing/intercepting/validating incoming gRPC client requests and (if needed) replacing/overwriting outgoing messages before they're sent to the client. When registering the middleware must identify itself and indicate what custom macaroon caveats it wants to be responsible for. Only requests that contain a macaroon with that specific custom caveat are then sent to the middleware for inspection. The other option is to register for the read-only mode in which all requests/responses are forwarded for interception to the middleware but the middleware is not allowed to modify any responses. As a security measure, _no_ middleware can modify responses for requests made with _unencumbered_ macaroons!
message
lightning.proto:5301uint64 ref_msg_id = 1
The request message ID this response refers to. Must always be set when giving feedback to an intercept but is ignored for the initial registration message.
oneof middleware_message
The middleware can only send two types of messages to lnd: The initial registration message that identifies the middleware and after that only feedback messages to requests sent to the middleware.
register = 2
The registration message identifies the middleware that's being registered in lnd. The registration message must be sent immediately after initiating the RegisterRpcMiddleware stream, otherwise lnd will time out the attempt and terminate the request. NOTE: The middleware will only receive interception messages for requests that contain a macaroon with the custom caveat that the middleware declares it is responsible for handling in the registration message! As a security measure, _no_ middleware can intercept requests made with _unencumbered_ macaroons!
feedback = 3
The middleware received an interception request and gives feedback to it. The request_id indicates what message the feedback refers to.
message
lightning.proto:5162uint64 request_id = 1
The unique ID of the intercepted original gRPC request. Useful for mapping request to response when implementing full duplex message interception. For streaming requests, this will be the same ID for all incoming and outgoing middleware intercept messages of the _same_ stream.
bytes raw_macaroon = 2
The raw bytes of the complete macaroon as sent by the gRPC client in the original request. This might be empty for a request that doesn't require macaroons such as the wallet unlocker RPCs.
string custom_caveat_condition = 3
The parsed condition of the macaroon's custom caveat for convenient access. This field only contains the value of the custom caveat that the handling middleware has registered itself for. The condition _must_ be validated for messages of intercept_type stream_auth and request!
oneof intercept_type
There are three types of messages that will be sent to the middleware for inspection and approval: Stream authentication, request and response interception. The first two can only be accepted (=forward to main RPC server) or denied (=return error to client). Intercepted responses can also be replaced/overwritten.
stream_auth = 4
Intercept stream authentication: each new streaming RPC call that is initiated against lnd and contains the middleware's custom macaroon caveat can be approved or denied based upon the macaroon in the stream header. This message will only be sent for streaming RPCs, unary RPCs must handle the macaroon authentication in the request interception to avoid an additional message round trip between lnd and the middleware.
request = 5
Intercept incoming gRPC client request message: all incoming messages, both on streaming and unary RPCs, are forwarded to the middleware for inspection. For unary RPC messages the middleware is also expected to validate the custom macaroon caveat of the request.
response = 6
Intercept outgoing gRPC response message: all outgoing messages, both on streaming and unary RPCs, are forwarded to the middleware for inspection and amendment. The response in this message is the original response as it was generated by the main RPC server. It can either be accepted (=forwarded to the client), replaced/overwritten with a new message of the same type, or replaced by an error message.
bool reg_complete = 8
This is used to indicate to the client that the server has successfully registered the interceptor. This is only used in the very first message that the server sends to the client after the client sends the server the middleware registration message.
uint64 msg_id = 7
The unique message ID of this middleware intercept message. There can be multiple middleware intercept messages per single gRPC request (one for the incoming request and one for the outgoing response) or gRPC stream (one for each incoming message and one for each outgoing response). This message ID must be referenced when responding (accepting/rejecting/modifying) to an intercept message.
map<string, > metadata_pairs = 9
The metadata pairs that were sent along with the original gRPC request via the golang context.Context using explicit [gRPC metadata](https://grpc.io/docs/guides/metadata/). Context values are not propagated via gRPC and so we send any pairs along explicitly here so that the interceptor can access them.
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
lightning.proto:4866oneof backup
chan_backups = 1
The channels to restore as a list of channel/backup pairs.
bytes multi_chan_backup = 2
The channels to restore in the packed multi backup format. When using REST, this field must be encoded as base64.
message
lightning.proto:4880uint32 num_restored = 1
The number of channels successfully restored.
rpc SendCoins (, )
lightning.proto:65lncli: `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_vbyte are set, then the internal wallet will consult its fee model to determine a fee for the default confirmation target.
message
lightning.proto:1124string 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.
uint64 sat_per_vbyte = 4
A manual fee rate set in sat/vbyte that should be used when crafting the transaction.
int64 sat_per_byte = 5
Deprecated, use sat_per_vbyte. A manual fee rate set in sat/vbyte that should be used when crafting the transaction.
bool send_all = 6
If set, the amount field should be unset. It indicates lnd will send all wallet coins or all selected coins to the specified address.
string label = 7
An optional label for the transaction, limited to 500 characters.
int32 min_confs = 8
The minimum number of confirmations each one of your outputs used for the transaction must satisfy.
bool spend_unconfirmed = 9
Whether unconfirmed outputs should be used as inputs for the transaction.
CoinSelectionStrategy coin_selection_strategy = 10
The strategy to use for selecting coins.
repeated outpoints = 11
A list of selected outpoints as inputs for the transaction.
message
lightning.proto:1166string txid = 1
The transaction ID of the transaction
rpc SendCustomMessage (, )
lightning.proto:545lncli: `sendcustom` SendCustomMessage sends a custom peer message.
message
lightning.proto:615bytes peer = 1
Peer to which the message will be sent. Represented as a byte-encoded public key
uint32 type = 2
Message type. This value needs to be in the custom range (>= 32768). To send a type < custom range, lnd needs to be compiled with the `dev` build tag, and the message type to override should be specified in lnd's experimental protocol configuration.
bytes data = 3
Raw message data.
message
lightning.proto:630string status = 1
The status of the send operation.
rpc SendMany (, )
lightning.proto:89lncli: `sendmany` SendMany handles a request for a transaction that creates multiple specified outputs in parallel. If neither target_conf, or sat_per_vbyte are set, then the internal wallet will consult its fee model to determine a fee for the default confirmation target.
message
lightning.proto:1089map<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.
uint64 sat_per_vbyte = 4
A manual fee rate set in sat/vbyte that should be used when crafting the transaction.
int64 sat_per_byte = 5
Deprecated, use sat_per_vbyte. A manual fee rate set in sat/vbyte that should be used when crafting the transaction.
string label = 6
An optional label for the transaction, limited to 500 characters.
int32 min_confs = 7
The minimum number of confirmations each one of your outputs used for the transaction must satisfy.
bool spend_unconfirmed = 8
Whether unconfirmed outputs should be used as inputs for the transaction.
CoinSelectionStrategy coin_selection_strategy = 9
The strategy to use for selecting coins during sending many requests.
message
lightning.proto:1119string txid = 1
The id of the transaction
rpc SendOnionMessage (, )
lightning.proto:562lncli: `sendonion` SendOnionMessage sends an onion message to a peer.
message
lightning.proto:679bytes peer = 1
Peer to send the message to
bytes path_key = 2
PathKey is used to derive the blinded node id by tweaking the hop's static public key. The hop uses the corresponding blinded private key together with the sender's ephemeral key to perform ECDH and obtain the shared secret for decrypting the onion payload. Separately, for decrypting `encrypted_recipient_data`, the recipient performs ECDH between its static node private key and the path_key to derive the decryption key.
bytes onion = 3
Serialized Sphinx onion packet (BOLT 4) containing the layered, per-hop encrypted payloads and routing instructions used to forward this message along its designated path.
message
lightning.proto:698string status = 1
The status of the onion message send operation.
rpc SignMessage (, )
lightning.proto:101lncli: `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
lightning.proto:1217bytes msg = 1
The message to be signed. When using REST, this field must be encoded as base64.
bool single_hash = 2
Instead of the default double-SHA256 hashing of the message before signing, only use one round of hashing instead.
message
lightning.proto:1230string signature = 1
The signature for the given message
rpc StopDaemon (, )
lightning.proto:389lncli: `stop` StopDaemon will send a shutdown request to the interrupt handler, triggering a graceful shutdown of the daemon.
message
lightning.proto:3643(message has no fields)
message
lightning.proto:3645string status = 1
The status of the stop operation.
rpc SubscribeChannelBackups (, stream )
lightning.proto:486SubscribeChannelBackups 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
lightning.proto:4885(message has no fields)
rpc SubscribeChannelEvents (, stream )
lightning.proto:183SubscribeChannelEvents 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
lightning.proto:2964(message has no fields)
message
lightning.proto:2971oneof channel
open_channel = 1
closed_channel = 2
active_channel = 3
inactive_channel = 4
pending_open_channel = 6
fully_resolved_channel = 7
channel_funding_timeout = 8
updated_channel = 9
ChannelEventUpdate.UpdateType type = 5
rpc SubscribeChannelGraph (, stream )
lightning.proto:399SubscribeChannelGraph 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
lightning.proto:3650(message has no fields)
message
lightning.proto:3652repeated node_updates = 1
repeated channel_updates = 2
repeated closed_chans = 3
rpc SubscribeCustomMessages (, stream )
lightning.proto:556lncli: `subscribecustom` SubscribeCustomMessages subscribes to a stream of incoming custom peer messages. To include messages with type outside of the custom range (>= 32768) lnd needs to be compiled with the `dev` build tag, and the message type to override should be specified in lnd's experimental protocol configuration.
message
lightning.proto:601(message has no fields)
message
lightning.proto:604bytes peer = 1
Peer from which the message originates
uint32 type = 2
Message type. This value will be in the custom range (>= 32768).
bytes data = 3
Raw message data
rpc SubscribeInvoices (, stream )
lightning.proto:301SubscribeInvoices 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, then 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
lightning.proto:4219uint64 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 SubscribeOnionMessages (, stream )
lightning.proto:568lncli: `subscribeonion` SubscribeOnionMessages subscribes to a stream of incoming onion messages.
message
lightning.proto:635(message has no fields)
message
lightning.proto:638bytes peer = 1
Peer from which this message originates. Represented as a byte-encoded public key.
bytes path_key = 2
PathKey is used to derive the blinded node id by tweaking the hop's static public key. The hop uses the corresponding blinded private key together with the sender's ephemeral key to perform ECDH and obtain the shared secret for decrypting the onion payload. Separately, for decrypting `encrypted_recipient_data`, the recipient performs ECDH between its static node private key and the path_key to derive the decryption key.
bytes onion = 3
Serialized Sphinx onion packet (BOLT 4) containing the layered, per-hop encrypted payloads and routing instructions used to forward this message along its designated path.
optional reply_path = 4
reply_path is the blinded path that should be used when replying to a received message. The introduction_node field is passed through verbatim from the wire. It may carry either the 33-byte SEC1 compressed pubkey form or the 9-byte sciddir form. The sciddir form consists of a 1-byte direction selector (0x00 or 0x01) followed by an 8-byte short channel ID. Subscribers that intend to reply resolve the sciddir form against their local channel graph.
bytes encrypted_recipient_data = 5
encrypted_recipient_data is the encrypted data that contains the forwarding information for an onion message. It contains either next_node_id or short_channel_id for each non-final node. It MAY contain the path_id for the final node.
map<uint64, bytes> custom_records = 6
Custom onion message tlv records. These are customized fields that are not defined by LND and cannot be extracted.
rpc SubscribePeerEvents (, stream )
lightning.proto:137SubscribePeerEvents 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.
message
lightning.proto:1899(message has no fields)
message
lightning.proto:1902string pub_key = 1
The identity pubkey of the peer.
PeerEvent.EventType type = 2
rpc SubscribeTransactions (, stream )
lightning.proto:80SubscribeTransactions creates a uni-directional stream from the server to the client in which any newly discovered transactions relevant to the wallet are sent over.
lncli: `updatechanpolicy` UpdateChannelPolicy allows the caller to update the fee schedule and channel policies for all channels globally, or a particular channel.
message
lightning.proto:4640oneof scope
bool global = 1
If set, then this update applies to all currently active channels.
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 fee_rate_ppm = 9
The effective fee rate in micro-satoshis (parts per million).
uint32 time_lock_delta = 5
The required timelock delta for HTLCs forwarded over the channel.
uint64 max_htlc_msat = 6
If set, the maximum HTLC size in milli-satoshis. If unset, the maximum HTLC will be unchanged.
uint64 min_htlc_msat = 7
The minimum HTLC size in milli-satoshis. Only applied if min_htlc_msat_specified is true.
bool min_htlc_msat_specified = 8
If true, min_htlc_msat is applied.
optional inbound_fee = 10
Optional inbound fee. If unset, the previously set value will be retained [EXPERIMENTAL].
bool create_missing_edge = 11
Under unknown circumstances a channel can exist with a missing edge in the graph database. This can cause an 'edge not found' error when calling `getchaninfo` and/or cause the default channel policy to be used during forwards. Setting this flag will recreate the edge if not found, allowing updating this channel policy and fixing the missing edge problem for this channel permanently. For fields not set in this command, the default policy will be created.
message
lightning.proto:4706repeated failed_updates = 1
List of failed policy updates.
rpc VerifyChanBackup (, )
lightning.proto:465lncli: `verifychanbackup` 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
lightning.proto:4888repeated string chan_points = 1
rpc VerifyMessage (, )
lightning.proto:111lncli: `verifymessage` VerifyMessage verifies a signature over a message and recovers the signer's public key. The signature is only deemed valid if the recovered public key corresponds to a node key in the public Lightning network. 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
lightning.proto:1235bytes msg = 1
The message over which the signature is to be verified. When using REST, this field must be encoded as base64.
string signature = 2
The signature to be verified over the given message
message
lightning.proto:1245bool valid = 1
Whether the signature was valid over the given message
string pubkey = 2
The pubkey recovered from the signature
rpc WalletBalance (, )
lightning.proto:32lncli: `walletbalance` WalletBalance returns total unspent outputs(confirmed and unconfirmed), all confirmed unspent outputs and all unconfirmed unspent outputs under control of the wallet.
message
lightning.proto:3005string account = 1
The wallet account the balance is shown for. If this is not specified, the balance of the "default" account is shown.
int32 min_confs = 2
The minimum number of confirmations each one of your outputs used for the funding transaction must satisfy. If this is not specified, the default value of 1 is used.
message
lightning.proto:3016int64 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)
int64 locked_balance = 5
The total amount of wallet UTXOs held in outputs that are locked for other usage.
int64 reserved_balance_anchor_chan = 6
The amount of reserve required.
map<string, > account_balance = 4
A mapping of each wallet account's name to its balance.
service State
stateservice.proto:27State service is a always running service that exposes the current state of the wallet and RPC server.
rpc GetState (, )
stateservice.proto:35GetState returns the current wallet state without streaming further changes.
message
stateservice.proto:68(message has no fields)
message
stateservice.proto:71WalletState state = 1
rpc SubscribeState (, stream )
stateservice.proto:30SubscribeState subscribes to the state of the wallet. The current wallet state will always be delivered immediately.
message
stateservice.proto:61(message has no fields)
message
stateservice.proto:64WalletState state = 1
WalletUnlocker is a service that is used to set up a wallet password for lnd at first startup, and unlock a previously set up wallet.
lncli: `changepassword` ChangePassword changes the password of the encrypted wallet. This will automatically unlock the wallet database if successful.
message
walletunlocker.proto:300bytes current_password = 1
current_password should be the current valid passphrase used to unlock the daemon. When using REST, this field must be encoded as base64.
bytes new_password = 2
new_password should be the new passphrase that will be needed to unlock the daemon. When using REST, this field must be encoded as base64.
bool stateless_init = 3
stateless_init is an optional argument instructing the daemon NOT to create any *.macaroon files in its filesystem. If this parameter is set, then the admin macaroon returned in the response MUST be stored by the caller of the RPC as otherwise all access to the daemon will be lost!
bool new_macaroon_root_key = 4
new_macaroon_root_key is an optional argument instructing the daemon to rotate the macaroon root key when set to true. This will invalidate all previously generated macaroons.
message
walletunlocker.proto:328bytes admin_macaroon = 1
The binary serialized admin macaroon that can be used to access the daemon after rotating the macaroon root key. If both the stateless_init and new_macaroon_root_key parameter were set to true, this is the ONLY copy of the macaroon that was created from the new root key and MUST be stored safely by the caller. Otherwise a copy of this macaroon is also persisted on disk by the daemon, together with other macaroon files.
rpc GenSeed (, )
walletunlocker.proto:40GenSeed 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
walletunlocker.proto:71bytes aezeed_passphrase = 1
aezeed_passphrase is an optional user provided passphrase that will be used to encrypt the generated aezeed cipher seed. When using REST, this field must be encoded as base64.
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. When using REST, this field must be encoded as base64.
message
walletunlocker.proto:86repeated 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 (, )
walletunlocker.proto:56InitWallet 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
walletunlocker.proto:103bytes 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. When using REST, this field must be encoded as base64.
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. When using REST, this field must be encoded as base64.
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 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.
bool stateless_init = 6
stateless_init is an optional argument instructing the daemon NOT to create any *.macaroon files in its filesystem. If this parameter is set, then the admin macaroon returned in the response MUST be stored by the caller of the RPC as otherwise all access to the daemon will be lost!
string extended_master_key = 7
extended_master_key is an alternative to specifying cipher_seed_mnemonic and aezeed_passphrase. Instead of deriving the master root key from the entropy of an aezeed cipher seed, the given extended master root key is used directly as the wallet's master key. This allows users to import/use a master key from another wallet. When doing so, lnd still uses its default SegWit only (BIP49/84) derivation paths and funds from custom/non-default derivation paths will not automatically appear in the on-chain wallet. Using an 'xprv' instead of an aezeed also has the disadvantage that the wallet's birthday is not known as that is an information that's only encoded in the aezeed, not the xprv. Therefore a birthday needs to be specified in extended_master_key_birthday_timestamp or a "safe" default value will be used.
uint64 extended_master_key_birthday_timestamp = 8
extended_master_key_birthday_timestamp is the optional unix timestamp in seconds to use as the wallet's birthday when using an extended master key to restore the wallet. lnd will only start scanning for funds in blocks that are after the birthday which can speed up the process significantly. If the birthday is not known, this should be left at its default value of 0 in which case lnd will start scanning from the first SegWit block (481824 on mainnet).
optional watch_only = 9
watch_only is the third option of initializing a wallet: by importing account xpubs only and therefore creating a watch-only wallet that does not contain any private keys. That means the wallet won't be able to sign for any of the keys and _needs_ to be run with a remote signer that has the corresponding private keys and can serve signing RPC requests.
bytes macaroon_root_key = 10
macaroon_root_key is an optional 32 byte macaroon root key that can be provided when initializing the wallet rather than letting lnd generate one on its own.
message
walletunlocker.proto:196bytes admin_macaroon = 1
The binary serialized admin macaroon that can be used to access the daemon after creating the wallet. If the stateless_init parameter was set to true, this is the ONLY copy of the macaroon and MUST be stored safely by the caller. Otherwise a copy of this macaroon is also persisted on disk by the daemon, together with other macaroon files.
rpc UnlockWallet (, )
walletunlocker.proto:62lncli: `unlock` UnlockWallet is used at startup of lnd to provide a password to unlock the wallet database.
message
walletunlocker.proto:264bytes 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. When using REST, this field must be encoded as base64.
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 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.
bool stateless_init = 4
stateless_init is an optional argument instructing the daemon NOT to create any *.macaroon files in its file system.
message
walletunlocker.proto:297(message has no fields)
message
lightning.proto:4106Details specific to AMP HTLCs.
Used in:
bytes root_share = 1
An n-of-n secret share of the root seed from which child payment hashes and preimages are derived.
bytes set_id = 2
An identifier for the HTLC set that this HTLC belongs to.
uint32 child_index = 3
A nonce used to randomize the child preimage and child hash from a given root_share.
bytes hash = 4
The payment hash of the AMP HTLC.
bytes preimage = 5
The preimage used to settle this AMP htlc. This field will only be populated if the invoice is in InvoiceState_ACCEPTED or InvoiceState_SETTLED.
message
lightning.proto:3799Used in:
InvoiceHTLCState state = 1
The state the HTLCs associated with this setID are in.
uint64 settle_index = 2
The settle index of this HTLC set, if the invoice state is settled.
int64 settle_time = 3
The time this HTLC set was settled expressed in unix epoch.
int64 amt_paid_msat = 5
The total amount paid for the sub-invoice expressed in milli satoshis.
message
lightning.proto:3350Used in:
bytes root_share = 1
bytes set_id = 2
uint32 child_index = 3
`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) - `p2tr`: Pay to taproot pubkey (`TAPROOT_PUBKEY` = 4)
Used in: ,
WITNESS_PUBKEY_HASH = 0
NESTED_PUBKEY_HASH = 1
UNUSED_WITNESS_PUBKEY_HASH = 2
UNUSED_NESTED_PUBKEY_HASH = 3
TAPROOT_PUBKEY = 4
UNUSED_TAPROOT_PUBKEY = 5
message
lightning.proto:1615Used in: , , , ,
uint64 base_scid = 1
For non-zero-conf channels, this is the confirmed SCID. Otherwise, this is the first assigned "base" alias.
repeated uint64 aliases = 2
The set of all aliases stored for the base SCID.
message
lightning.proto:3037Used in:
uint64 sat = 1
Value denominated in satoshis.
uint64 msat = 2
Value denominated in milli-satoshis.
message
lightning.proto:2196Used in:
bytes node_pubkey = 1
The pubkey of the node to open a channel with. When using REST, this field must be encoded as base64.
int64 local_funding_amount = 2
The number of satoshis the wallet should commit to the channel.
int64 push_sat = 3
The number of satoshis to push to the remote side as part of the initial commitment state.
bool private = 4
Whether this channel should be private, not announced to the greater network.
int64 min_htlc_msat = 5
The minimum value in millisatoshi we will require for incoming HTLCs on the channel.
uint32 remote_csv_delay = 6
The delay we require on the remote's commitment transaction. If this is not set, it will be scaled automatically with the channel size.
string close_address = 7
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.
bytes pending_chan_id = 8
An optional, unique identifier of 32 random bytes that will be used as the pending channel ID to identify the channel while it is in the pre-pending state.
CommitmentType commitment_type = 9
The explicit commitment type to use. Note this field will only be used if the remote peer supports explicit channel negotiation.
uint64 remote_max_value_in_flight_msat = 10
The maximum amount of coins in millisatoshi that can be pending within the channel. It only applies to the remote party.
uint32 remote_max_htlcs = 11
The maximum number of concurrent HTLCs we will allow the remote party to add to the commitment transaction.
uint32 max_local_csv = 12
Max local csv is the maximum csv delay we will allow for our own commitment transaction.
bool zero_conf = 13
If this is true, then a zero-conf channel open will be attempted.
bool scid_alias = 14
If this is true, then an option-scid-alias channel-type open will be attempted.
uint64 base_fee = 15
The base fee charged regardless of the number of milli-satoshis sent.
uint64 fee_rate = 16
The fee rate in ppm (parts per million) that will be charged in proportion of the value of each forwarded HTLC.
bool use_base_fee = 17
If use_base_fee is true the open channel announcement will update the channel base fee with the value specified in base_fee. In the case of a base_fee of 0 use_base_fee is needed downstream to distinguish whether to use the default base fee value specified in the config or 0.
bool use_fee_rate = 18
If use_fee_rate is true the open channel announcement will update the channel fee rate with the value specified in fee_rate. In the case of a fee_rate of 0 use_fee_rate is needed downstream to distinguish whether to use the default fee rate value specified in the config or 0.
uint64 remote_chan_reserve_sat = 19
The number of satoshis we require the remote peer to reserve. This value, if specified, must be above the dust limit and below 20% of the channel capacity.
string memo = 20
An optional note-to-self to go along with the channel containing some useful information. This is only ever stored locally and in no way impacts the channel's operation.
message
lightning.proto:3791Used in:
bytes blinded_node = 1
The blinded public key of the node.
bytes encrypted_data = 2
An encrypted blob of data provided to the blinded node.
message
lightning.proto:3776Used in: ,
bytes introduction_node = 1
The unblinded pubkey of the introduction node for the route.
bytes blinding_point = 2
The ephemeral pubkey used by nodes in the blinded route.
repeated blinded_hops = 3
A set of blinded node keys and data blobs for the blinded portion of the route. Note that the first hop is expected to be the introduction node, so the route is always expected to have at least one hop.
message
lightning.proto:4023Used in:
optional uint32 min_num_real_hops = 1
The minimum number of real hops to include in a blinded path. This doesn't include our node, so if the minimum is 1, then the path will contain at minimum our node along with an introduction node hop. If it is zero then the shortest path will use our node as an introduction node.
optional uint32 num_hops = 2
The number of hops to include in a blinded path. This doesn't include our node, so if it is 1, then the path will contain our node along with an introduction node or dummy node hop. If paths shorter than NumHops is found, then they will be padded using dummy hops.
optional uint32 max_num_paths = 3
The maximum number of blinded paths to select and add to an invoice.
repeated bytes node_omission_list = 4
A list of node IDs of nodes that should not be used in any of our generated blinded paths.
repeated uint64 incoming_channel_list = 5
The chained channels list specified via channel id (separated by commas), starting from a channel owned by the receiver node.
message
lightning.proto:3741Used in: ,
optional blinded_path = 1
The blinded path to send the payment to.
uint64 base_fee_msat = 2
The base fee for the blinded path provided, expressed in msat.
uint32 proportional_fee_rate = 3
The proportional fee for the blinded path provided, expressed in parts per million.
uint32 total_cltv_delta = 4
The total CLTV delta for the blinded path provided, including the final CLTV delta for the receiving node.
uint64 htlc_min_msat = 5
The minimum hltc size that may be sent over the blinded path, expressed in msat.
uint64 htlc_max_msat = 6
The maximum htlc size that may be sent over the blinded path, expressed in msat.
repeated FeatureBit features = 7
The feature bits for the route.
message
lightning.proto:2030Used in:
string chain = 1
Deprecated. The chain is now always assumed to be bitcoin. The blockchain the node is on (must be bitcoin)
string network = 2
The network the node is on (eg regtest, testnet, mainnet)
message
lightning.proto:4845Used as request type in: Lightning.VerifyChanBackup
Used as response type in: Lightning.ExportAllChannelBackups, Lightning.SubscribeChannelBackups
Used as field type in: ,
optional single_chan_backups = 1
The set of new channels that have been added since the last channel backup snapshot was requested.
optional multi_chan_backup = 2
A multi-channel backup that covers all open channels currently known to lnd.
message
lightning.proto:2530Used in:
int64 amt = 1
The size of the pre-crafted output to be used as the channel point for this channel funding.
optional chan_point = 2
The target channel point to refrence in created commitment transactions.
optional local_key = 3
Our local key to use when creating the multi-sig output.
bytes remote_key = 4
The key of the remote party to use when creating the multi-sig output.
bytes pending_chan_id = 5
If non-zero, then this will be used as the pending channel ID on the wire protocol to initate the funding request. This is an optional field, and should only be set if the responder is already expecting a specific pending channel ID.
uint32 thaw_height = 6
This uint32 indicates if this channel is to be considered 'frozen'. A frozen channel does not allow a cooperative channel close by the initiator. The thaw_height is the height that this restriction stops applying to the channel. The height can be interpreted in two ways: as a relative height if the value is less than 500,000, or as an absolute height otherwise.
bool musig2 = 7
Indicates that the funding output is using a MuSig2 multi-sig output.
message
lightning.proto:1410Used in: , ,
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 pending_htlcs = 15
The list of active, uncleared HTLCs currently pending within the channel.
uint32 csv_delay = 16
Deprecated. 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.
int64 local_chan_reserve_sat = 20
Deprecated. The minimum satoshis this node is required to reserve in its balance.
int64 remote_chan_reserve_sat = 21
Deprecated. The minimum satoshis the other node is required to reserve in its balance.
bool static_remote_key = 22
Deprecated. Use commitment_type.
CommitmentType commitment_type = 26
The commitment type used by this channel.
int64 lifetime = 23
The number of seconds that the channel has been monitored by the channel scoring system. Scores are currently not persisted, so this value may be less than the lifetime of the channel [EXPERIMENTAL].
int64 uptime = 24
The number of seconds that the remote peer has been observed as being online by the channel scoring system over the lifetime of the channel [EXPERIMENTAL].
string close_address = 25
Close address is the address that we will enforce payout to on cooperative close if the channel was opened utilizing option upfront shutdown. This value can be set on channel open by setting close_address in an open channel request. If this value is not set, you can still choose a payout address by cooperatively closing with the delivery_address field set.
uint64 push_amount_sat = 27
The amount that the initiator of the channel optionally pushed to the remote party on channel open. This amount will be zero if the channel initiator did not push any funds to the remote peer. If the initiator field is true, we pushed this amount to our peer, if it is false, the remote peer pushed this amount to us.
uint32 thaw_height = 28
This uint32 indicates if this channel is to be considered 'frozen'. A frozen channel doest not allow a cooperative channel close by the initiator. The thaw_height is the height that this restriction stops applying to the channel. This field is optional, not setting it or using a value of zero will mean the channel has no additional restrictions. The height can be interpreted in two ways: as a relative height if the value is less than 500,000, or as an absolute height otherwise.
optional local_constraints = 29
List constraints for the local node.
optional remote_constraints = 30
List constraints for the remote node.
repeated uint64 alias_scids = 31
This lists out the set of alias short channel ids that exist for a channel. This may be empty.
bool zero_conf = 32
Whether or not this is a zero-conf channel.
uint64 zero_conf_confirmed_scid = 33
This is the confirmed / on-chain zero-conf SCID.
string peer_alias = 34
The configured alias name of our peer.
uint64 peer_scid_alias = 35
This is the peer SCID alias.
string memo = 36
An optional note-to-self to go along with the channel containing some useful information. This is only ever stored locally and in no way impacts the channel's operation.
bytes custom_channel_data = 37
Custom channel data that might be populated in custom channels.
message
lightning.proto:3498ChannelAuthProof is the authentication proof (the signature portion) for a channel. Using the four signatures contained in the struct, and some auxiliary knowledge (the funding script, node identities, and outpoint) nodes on the network are able to validate the authenticity and existence of a channel.
Used in:
bytes node_sig1 = 1
node_sig1 are the raw bytes of the first node signature encoded in DER format.
bytes bitcoin_sig1 = 2
bitcoin_sig1 are the raw bytes of the first bitcoin signature of the MultiSigKey key of the channel encoded in DER format.
bytes node_sig2 = 3
node_sig2 are the raw bytes of the second node signature encoded in DER format.
bytes bitcoin_sig2 = 4
bitcoin_sig2 are the raw bytes of the second bitcoin signature of the MultiSigKey key of the channel encoded in DER format.
message
lightning.proto:4813Used as response type in: Lightning.ExportChannelBackup
Used as field type in:
optional 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. When using REST, this field must be encoded as base64.
message
lightning.proto:4859Used in: ,
repeated chan_backups = 1
A set of single-chan static channel backups.
message
lightning.proto:1638Used in: ,
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.
Initiator open_initiator = 11
Open initiator is the party that initiated opening the channel. Note that this value may be unknown if the channel was closed before we migrated to store open channel information after close.
Initiator close_initiator = 12
Close initiator indicates which party initiated the close. This value will be unknown for channels that were cooperatively closed before we started tracking cooperative close initiators. Note that this indicates which party initiated a close, and it is possible for both to initiate cooperative or force closes, although only one party's close will be confirmed on chain.
repeated resolutions = 13
repeated uint64 alias_scids = 14
This lists out the set of alias short channel ids that existed for the closed channel. This may be empty.
uint64 zero_conf_confirmed_scid = 15
The confirmed SCID for a zero-conf channel.
bytes custom_channel_data = 16
The TLV encoded custom channel data records for this output, which might be set for custom channels.
Used in:
COOPERATIVE_CLOSE = 0
LOCAL_FORCE_CLOSE = 1
REMOTE_FORCE_CLOSE = 2
BREACH_CLOSE = 3
FUNDING_CANCELED = 4
ABANDONED = 5
message
lightning.proto:2060Used in:
bytes closing_txid = 1
bool success = 2
optional local_close_output = 3
The local channel close output. If the local channel balance was dust to begin with, this output will not be set.
optional remote_close_output = 4
The remote channel close output. If the remote channel balance was dust to begin with, this output will not be set.
repeated additional_outputs = 5
Any additional outputs that might be added for custom channel types.
message
lightning.proto:2967Used in:
optional channel = 1
message
lightning.proto:1386Used in:
uint32 csv_delay = 1
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.
uint64 chan_reserve_sat = 2
The minimum satoshis this node is required to reserve in its balance.
uint64 dust_limit_sat = 3
The dust limit (in satoshis) of the initiator's commitment tx.
uint64 max_pending_amt_msat = 4
The maximum amount of coins in millisatoshis that can be pending in this channel.
uint64 min_htlc_msat = 5
The smallest HTLC in millisatoshis that the initiator will accept.
uint32 max_accepted_htlcs = 6
The total number of incoming HTLC's that the initiator will accept.
message
lightning.proto:3523A 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: ,
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 node1_policy = 7
optional node2_policy = 8
map<uint64, bytes> custom_records = 9
Custom channel announcement tlv records.
optional auth_proof = 10
Authentication proof for this channel. This proof contains a set of signatures binding four identities, which attests to the legitimacy of the advertised channel. This only is available for advertised channels. This field is not filled by default. Pass include_auth_proof flag to DescribeGraph, GetNodeInfo or GetChanInfo to get this data.
message
lightning.proto:3680Used in:
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 chan_point = 2
int64 capacity = 3
optional routing_policy = 4
string advertising_node = 5
string connecting_node = 6
Used in:
OPEN_CHANNEL = 0
CLOSED_CHANNEL = 1
ACTIVE_CHANNEL = 2
INACTIVE_CHANNEL = 3
PENDING_OPEN_CHANNEL = 4
FULLY_RESOLVED_CHANNEL = 5
CHANNEL_FUNDING_TIMEOUT = 6
CHANNEL_UPDATE = 7
message
lightning.proto:4586Used in:
uint64 chan_id = 5
The short channel id that this fee report belongs to.
string channel_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.
int32 inbound_base_fee_msat = 6
The base fee charged regardless of the number of milli-satoshis sent.
int32 inbound_fee_per_mil = 7
The amount charged per milli-satoshis transferred expressed in millionths of a satoshi.
message
lightning.proto:3566Returns a new instance of the directed channel graph.
Used as request type in: devrpc.Dev.ImportGraph
Used as response type in: Lightning.DescribeGraph
repeated nodes = 1
The list of `LightningNode`s in this channel graph
repeated edges = 2
The list of `ChannelEdge`s in this channel graph
message
lightning.proto:2039Used in:
optional channel_point = 1
message
lightning.proto:992Used as response type in: Lightning.OpenChannelSync
Used as field type in: , , , , , , , , , , , , ,
oneof funding_txid
bytes funding_txid_bytes = 1
Txid of the funding transaction. When using REST, this field must be encoded as base64.
string funding_txid_str = 2
Hex-encoded string representing the byte-reversed hash of the funding transaction.
uint32 output_index = 3
The index of the output of the funding transaction
message
lightning.proto:5030Used in:
bytes signature = 1
The signature that validates the announced data and proves the ownership of node id.
bytes chain_hash = 2
The target chain that this channel was opened within. This value should be the genesis hash of the target chain. Along with the short channel ID, this uniquely identifies the channel globally in a blockchain.
uint64 chan_id = 3
The unique description of the funding transaction.
uint32 timestamp = 4
A timestamp that allows ordering in the case of multiple announcements. We should ignore the message if timestamp is not greater than the last-received.
uint32 message_flags = 10
The bitfield that describes whether optional fields are present in this update. Currently, the least-significant bit must be set to 1 if the optional field MaxHtlc is present.
uint32 channel_flags = 5
The bitfield that describes additional meta-data concerning how the update is to be interpreted. Currently, the least-significant bit must be set to 0 if the creating node corresponds to the first node in the previously sent channel announcement and 1 otherwise. If the second bit is set, then the channel is set to be disabled.
uint32 time_lock_delta = 6
The minimum number of blocks this node requires to be added to the expiry of HTLCs. This is a security parameter determined by the node operator. This value represents the required gap between the time locks of the incoming and outgoing HTLC's set to this node.
uint64 htlc_minimum_msat = 7
The minimum HTLC value which will be accepted.
uint32 base_fee = 8
The base fee that must be used for incoming HTLC's to this particular channel. This value will be tacked onto the required for a payment independent of the size of the payment.
uint32 fee_rate = 9
The fee rate that will be charged per millionth of a satoshi.
uint64 htlc_maximum_msat = 11
The maximum HTLC value which will be accepted.
bytes extra_opaque_data = 12
The set of data that was appended to this message, some of which we may not actually know how to iterate or parse. By holding onto this data, we ensure that we're able to properly validate the set of signatures that cover these new fields, and ensure we're able to make upgrades to the network in a forwards compatible manner.
message
lightning.proto:2043Used in:
int64 amount_sat = 1
The amount in satoshi of this close output. This amount is the final commitment balance of the channel and the actual amount paid out on chain might be smaller due to subtracted fees.
bytes pk_script = 2
The pkScript of the close output.
bool is_local = 3
Whether this output is for the local or remote node.
bytes custom_channel_data = 4
The TLV encoded custom channel data records for this output, which might be set for custom channels.
message
lightning.proto:3697Used in:
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 chan_point = 4
Used in: , , , , ,
STRATEGY_USE_GLOBAL_CONFIG = 0
Use the coin selection strategy defined in the global configuration (lnd.conf).
STRATEGY_LARGEST = 1
Select the largest available coins first during coin selection.
STRATEGY_RANDOM = 2
Randomly select the available coins during coin selection.
Used in: , , , ,
UNKNOWN_COMMITMENT_TYPE = 0
Returned when the commitment type isn't known or unavailable.
LEGACY = 1
A channel using the legacy commitment format having tweaked to_remote keys.
STATIC_REMOTE_KEY = 2
A channel that uses the modern commitment format where the key in the output of the remote party does not change each state. This makes back up and recovery easier as when the channel is closed, the funds go directly to that key.
ANCHORS = 3
A channel that uses a commitment format that has anchor outputs on the commitments, allowing fee bumping after a force close transaction has been broadcast.
SCRIPT_ENFORCED_LEASE = 4
A channel that uses a commitment type that builds upon the anchors commitment format, but in addition requires a CLTV clause to spend outputs paying to the channel initiator. This is intended for use on leased channels to guarantee that the channel initiator has no incentives to close a leased channel before its maturity date.
TAPROOT = 7
The production taproot channel type that uses musig2 for the funding output and the new tapscript features, with final scripts and feature bits 80/81. This is the recommended taproot variant; new integrations should select this enum value.
SIMPLE_TAPROOT_FINAL = 7
Deprecated alias for TAPROOT, preserved so existing clients that select the production taproot channel type by its historic name continue to compile and serialize against the same wire value.
SIMPLE_TAPROOT = 5
A legacy taproot channel type that uses musig2 for the funding output and the new tapscript features, but with development scripts and the staging feature bits. Retained for compatibility with peers that have not upgraded to TAPROOT; new integrations should prefer TAPROOT.
SIMPLE_TAPROOT_OVERLAY = 6
Identical to the SIMPLE_TAPROOT channel type, but with extra functionality. This channel type also commits to additional meta data in the tapscript leaves for the scripts in a channel.
message
lightning.proto:3222Used in:
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.
message
lightning.proto:4695Used in:
optional outpoint = 1
The outpoint in format txid:n
UpdateFailure reason = 2
Reason for the policy update failure.
string update_error = 3
A string representation of the policy update error.
message
lightning.proto:4948Used in:
Failure.FailureCode code = 1
Failure code as defined in the Lightning spec
optional channel_update = 3
An optional channel update message.
uint64 htlc_msat = 4
A failure type-dependent htlc value.
bytes onion_sha_256 = 5
The sha256 sum of the onion payload.
uint32 cltv_expiry = 6
A failure type-dependent cltv expiry value.
uint32 flags = 7
A failure type-dependent flags value.
uint32 failure_source_index = 8
The position in the path of the intermediate or final node that generated the failure message. Position zero is the sender node.
uint32 height = 9
A failure type-dependent block height.
Used in: , ,
RESERVED = 0
The numbers assigned in this enumeration match the failure codes as defined in BOLT #4. Because protobuf 3 requires enums to start with 0, a RESERVED value is added.
INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS = 1
INCORRECT_PAYMENT_AMOUNT = 2
FINAL_INCORRECT_CLTV_EXPIRY = 3
FINAL_INCORRECT_HTLC_AMOUNT = 4
FINAL_EXPIRY_TOO_SOON = 5
INVALID_REALM = 6
EXPIRY_TOO_SOON = 7
INVALID_ONION_VERSION = 8
INVALID_ONION_HMAC = 9
INVALID_ONION_KEY = 10
AMOUNT_BELOW_MINIMUM = 11
FEE_INSUFFICIENT = 12
INCORRECT_CLTV_EXPIRY = 13
CHANNEL_DISABLED = 14
TEMPORARY_CHANNEL_FAILURE = 15
REQUIRED_NODE_FEATURE_MISSING = 16
REQUIRED_CHANNEL_FEATURE_MISSING = 17
UNKNOWN_NEXT_PEER = 18
TEMPORARY_NODE_FAILURE = 19
PERMANENT_NODE_FAILURE = 20
PERMANENT_CHANNEL_FAILURE = 21
EXPIRY_TOO_FAR = 22
MPP_TIMEOUT = 23
INVALID_ONION_PAYLOAD = 24
INVALID_ONION_BLINDING = 25
INTERNAL_FAILURE = 997
An internal error occurred.
UNKNOWN_FAILURE = 998
The error source is known, but the failure itself couldn't be decoded.
UNREADABLE_FAILURE = 999
An unreadable failure result is returned if the received failure message cannot be decrypted. In that case the error source is unknown.
message
lightning.proto:4578Used in: , , , , ,
string name = 2
bool is_required = 3
bool is_known = 4
Used in: , , ,
DATALOSS_PROTECT_REQ = 0
DATALOSS_PROTECT_OPT = 1
INITIAL_ROUING_SYNC = 3
UPFRONT_SHUTDOWN_SCRIPT_REQ = 4
UPFRONT_SHUTDOWN_SCRIPT_OPT = 5
GOSSIP_QUERIES_REQ = 6
GOSSIP_QUERIES_OPT = 7
TLV_ONION_REQ = 8
TLV_ONION_OPT = 9
EXT_GOSSIP_QUERIES_REQ = 10
EXT_GOSSIP_QUERIES_OPT = 11
STATIC_REMOTE_KEY_REQ = 12
STATIC_REMOTE_KEY_OPT = 13
PAYMENT_ADDR_REQ = 14
PAYMENT_ADDR_OPT = 15
MPP_REQ = 16
MPP_OPT = 17
WUMBO_CHANNELS_REQ = 18
WUMBO_CHANNELS_OPT = 19
ANCHORS_REQ = 20
ANCHORS_OPT = 21
ANCHORS_ZERO_FEE_HTLC_REQ = 22
ANCHORS_ZERO_FEE_HTLC_OPT = 23
ROUTE_BLINDING_REQUIRED = 24
ROUTE_BLINDING_OPTIONAL = 25
AMP_REQ = 30
AMP_OPT = 31
message
lightning.proto:844Used in:
oneof limit
int64 fixed = 1
The fee limit expressed as a fixed amount of satoshis. The fields fixed and fixed_msat are mutually exclusive.
int64 fixed_msat = 3
The fee limit expressed as a fixed amount of millisatoshis. The fields fixed and fixed_msat are mutually exclusive.
int64 percent = 2
The fee limit expressed as a percentage of the payment amount.
message
lightning.proto:3595Used in:
double value = 1
Arbitrary float value.
double normalized_value = 2
The value normalized to [0,1] or [-1,1].
message
lightning.proto:4742Used in:
uint64 timestamp = 1
Timestamp is the time (unix epoch offset) that this circuit was completed. Deprecated by timestamp_ns.
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.
uint64 amt_in_msat = 9
The total amount (in milli-satoshis) of the incoming HTLC that created half the circuit.
uint64 amt_out_msat = 10
The total amount (in milli-satoshis) of the outgoing HTLC that created the second half of the circuit.
uint64 timestamp_ns = 11
The number of nanoseconds elapsed since January 1, 1970 UTC when this circuit was completed.
string peer_alias_in = 12
The peer alias of the incoming channel.
string peer_alias_out = 13
The peer alias of the outgoing channel.
optional uint64 incoming_htlc_id = 14
The ID of the incoming HTLC in the payment circuit. This field is optional and is unset for forwarding events happened before v0.20.
optional uint64 outgoing_htlc_id = 15
The ID of the outgoing HTLC in the payment circuit. This field is optional and may be unset for legacy forwarding events.
message
lightning.proto:2641Used in:
bytes signed_psbt = 1
The funded PSBT that contains all witness data to send the exact channel capacity amount to the PK script returned in the open channel message in a previous step. Cannot be set at the same time as final_raw_tx.
bytes pending_chan_id = 2
The pending channel ID of the channel to get the PSBT for.
bytes final_raw_tx = 3
As an alternative to the signed PSBT with all witness data, the final raw wire format transaction can also be specified directly. Cannot be set at the same time as signed_psbt.
message
lightning.proto:2615Used in:
bytes funded_psbt = 1
The funded but not yet signed PSBT that sends the exact channel capacity amount to the PK script returned in the open channel message in a previous step.
bytes pending_chan_id = 2
The pending channel ID of the channel to get the PSBT for.
bool skip_finalize = 3
Can only be used if the no_publish flag was set to true in the OpenChannel call meaning that the caller is solely responsible for publishing the final funding transaction. If skip_finalize is set to true then lnd will not wait for a FundingPsbtFinalize state step and instead assumes that a transaction with the same TXID as the passed in PSBT will eventually confirm. IT IS ABSOLUTELY IMPERATIVE that the TXID of the transaction that is eventually published does have the _same TXID_ as the verified PSBT. That means no inputs or outputs can change, only signatures can be added. If the TXID changes between this call and the publish step then the channel will never be created and the funds will be in limbo.
message
lightning.proto:2594Used in: ,
oneof shim
chan_point_shim = 1
A channel shim where the channel point was fully constructed outside of lnd's wallet and the transaction might already be published.
psbt_shim = 2
A channel shim that uses a PSBT to fund and sign the channel funding transaction.
message
lightning.proto:2610Used in:
bytes pending_chan_id = 1
The pending channel ID of the channel to cancel the funding shim for.
message
lightning.proto:795Used as request type in: Lightning.GetTransactions, Lightning.SubscribeTransactions
int32 start_height = 1
The height from which to list transactions, inclusive. If this value is greater than end_height, transactions will be read in reverse.
int32 end_height = 2
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.
string account = 3
An optional filter to only include transactions relevant to an account.
uint32 index_offset = 4
The index of a transaction that will be used in a query to determine which transaction should be returned in the response.
uint32 max_transactions = 5
The maximal number of transactions returned in the response to this query. This value should be set to 0 to return all transactions.
Used in:
GRAPH_CACHE_STATUS_DISABLED = 0
GRAPH_CACHE_STATUS_LOADING = 1
GRAPH_CACHE_STATUS_LOADED = 2
GRAPH_CACHE_STATUS_FAILED = 3
message
lightning.proto:1285Used in:
bool incoming = 1
int64 amount = 2
bytes hash_lock = 3
uint32 expiration_height = 4
uint64 htlc_index = 5
Index identifying the htlc on the channel.
uint64 forwarding_channel = 6
If this HTLC is involved in a forwarding operation, this field indicates the forwarding channel. For an outgoing htlc, it is the incoming channel. For an incoming htlc, it is the outgoing channel. When the htlc originates from this node or this node is the final destination, forwarding_channel will be zero. The forwarding channel will also be zero for htlcs that need to be forwarded but don't have a forwarding decision persisted yet.
uint64 forwarding_htlc_index = 7
Index identifying the htlc on the forwarding channel.
bool locked_in = 8
Whether the HTLC is locked in. An HTLC is considered locked in when the remote party has sent us the `revoke_and_ack` to irrevocably commit this HTLC.
message
lightning.proto:4361Used as response type in: routerrpc.Router.SendToRouteV2
Used as field type in:
uint64 attempt_id = 7
The unique ID that is used for this attempt.
HTLCAttempt.HTLCStatus status = 1
The status of the HTLC.
optional route = 2
The route taken by this HTLC.
int64 attempt_time_ns = 3
The time in UNIX nanoseconds at which this HTLC was sent.
int64 resolve_time_ns = 4
The time in UNIX nanoseconds at which this HTLC was settled or failed. This value will not be set if the HTLC is still IN_FLIGHT.
optional failure = 5
Detailed htlc failure info.
bytes preimage = 6
The preimage that was used to settle the HTLC.
Used in:
IN_FLIGHT = 0
SUCCEEDED = 1
FAILED = 2
message
lightning.proto:3249Used in:
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.
bool tlv_payload = 9
If set to true, then this hop will be encoded using the new variable length TLV format. Note that if any custom tlv_records below are specified, then this field MUST be set to true for them to be encoded properly.
optional mpp_record = 10
An optional TLV record that signals the use of an MPP payment. If present, the receiver will enforce that the same mpp_record is included in the final hop payload of all non-zero payments in the HTLC set. If empty, a regular single-shot payment is or was attempted.
optional amp_record = 12
An optional TLV record that signals the use of an AMP payment. If present, the receiver will treat all received payments including the same (payment_addr, set_id) pair as being part of one logical payment. The payment will be settled by XORing the root_share's together and deriving the child hashes and preimages according to BOLT XX. Must be used in conjunction with mpp_record.
map<uint64, bytes> custom_records = 11
An optional set of key-value TLV records. This is useful within the context of the SendToRoute call as it allows callers to specify arbitrary K-V pairs to drop off at each hop within the onion.
bytes metadata = 13
The payment metadata to send along with the payment to the payee.
bytes blinding_point = 14
Blinding point is an optional blinding point included for introduction nodes in blinded paths. This field is mandatory for hops that represents the introduction point in a blinded path.
bytes encrypted_data = 15
Encrypted data is a receiver-produced blob of data that provides hops in a blinded route with forwarding data. As this data is encrypted by the recipient, we will not be able to parse it - it is essentially an arbitrary blob of data from our node's perspective. This field is mandatory for all hops in a blinded path, including the introduction node.
uint64 total_amt_msat = 16
The total amount that is sent to the recipient (possibly across multiple HTLCs), as specified by the sender when making a payment to a blinded path. This value is only set in the final hop payload of a blinded payment. This value is analogous to the MPPRecord that is used for regular (non-blinded) MPP payments.
message
lightning.proto:3709Used in:
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.
message
lightning.proto:4630Used in:
int32 base_fee_msat = 1
The inbound base fee charged regardless of the number of milli-satoshis received in the channel. By default, only negative values are accepted.
int32 fee_rate_ppm = 2
The effective inbound fee rate in micro-satoshis (parts per million). By default, only negative values are accepted.
Used in: ,
INITIATOR_UNKNOWN = 0
INITIATOR_LOCAL = 1
INITIATOR_REMOTE = 2
INITIATOR_BOTH = 3
message
lightning.proto:2140Used in:
int32 num_pending_htlcs = 1
The number of pending HTLCs that are currently active on the channel. These HTLCs need to be resolved before the channel can be closed cooperatively.
message
lightning.proto:5365Used in:
string error = 1
The error to return to the user. If this is non-empty, the incoming gRPC stream/request is aborted and the error is returned to the gRPC client. If this value is empty, it means the middleware accepts the stream/request/ response and the processing of it can continue.
bool replace_response = 2
A boolean indicating that the gRPC message should be replaced/overwritten. This boolean is needed because in protobuf an empty message is serialized as a 0-length or nil byte slice and we wouldn't be able to distinguish between an empty replacement message and the "don't replace anything" case.
bytes replacement_serialized = 3
If the replace_response field is set to true, this field must contain the binary serialized gRPC message in the protobuf format.
message
lightning.proto:3813Used as request type in: Lightning.AddInvoice
Used as response type in: invoicesrpc.Invoices.LookupInvoiceV2, invoicesrpc.Invoices.SubscribeSingleInvoice, Lightning.LookupInvoice, Lightning.SubscribeInvoices
Used as field type in: ,
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 r_preimage = 3
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.
bytes r_hash = 4
The hash of the preimage. When using REST, this field must be encoded as base64. Note: Output only, don't specify for creating an invoice.
int64 value = 5
The value of this invoice in satoshis The fields value and value_msat are mutually exclusive.
int64 value_msat = 23
The value of this invoice in millisatoshis The fields value and value_msat are mutually exclusive.
bool settled = 6
Whether this invoice has been fulfilled. The field is deprecated. Use the state field instead (compare to SETTLED).
int64 creation_date = 7
When this invoice was created. Measured in seconds since the unix epoch. Note: Output only, don't specify for creating an invoice.
int64 settle_date = 8
When this invoice was settled. Measured in seconds since the unix epoch. Note: Output only, don't specify for creating an invoice.
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. Note: Output only, don't specify for creating an invoice.
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. When using REST, this field must be encoded as base64.
int64 expiry = 11
Payment request expiry time in seconds. Default is 86400 (24 hours).
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 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. Note: When enabled, if value and value_msat are zero, a large number of hints with these channels can be included, which might not be desirable.
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. Note: Output only, don't specify for creating an invoice.
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. Note: Output only, don't specify for creating an invoice.
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 or accepted. 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. Note: Output only, don't specify for creating an invoice.
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 or accepted. 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. Note: Output only, don't specify for creating an invoice.
Invoice.InvoiceState state = 21
The state the invoice is in. Note: Output only, don't specify for creating an invoice.
repeated htlcs = 22
List of HTLCs paying to this invoice [EXPERIMENTAL]. Note: Output only, don't specify for creating an invoice.
map<uint32, > features = 24
List of features advertised on the invoice. Note: Output only, don't specify for creating an invoice.
bool is_keysend = 25
Indicates if this invoice was a spontaneous payment that arrived via keysend [EXPERIMENTAL]. Note: Output only, don't specify for creating an invoice.
bytes payment_addr = 26
The payment address of this invoice. This is also called payment secret in specifications (e.g. BOLT 11). This value will be used in MPP payments, and also for newer invoices that always require the MPP payload for added end-to-end security. Note: Output only, don't specify for creating an invoice.
bool is_amp = 27
Signals whether or not this is an AMP invoice.
map<string, > amp_invoice_state = 28
[EXPERIMENTAL]: Maps a 32-byte hex-encoded set ID to the sub-invoice AMP state for the given set ID. This field is always populated for AMP invoices, and can be used along side LookupInvoice to obtain the HTLC information related to a given sub-invoice. Note: Output only, don't specify for creating an invoice.
bool is_blinded = 29
Signals that the invoice should include blinded paths to hide the true identity of the recipient.
optional blinded_path_config = 30
Config values to use when creating blinded paths for this invoice. These can be used to override the defaults config values provided in by the global config. This field is only used if is_blinded is true.
Used in:
OPEN = 0
SETTLED = 1
CANCELED = 2
ACCEPTED = 3
message
lightning.proto:4065Details of an HTLC that paid to an invoice
Used in:
uint64 chan_id = 1
Short channel id over which the htlc was received.
uint64 htlc_index = 2
Index identifying the htlc on the channel.
uint64 amt_msat = 3
The amount of the htlc in msat.
int32 accept_height = 4
Block height at which this htlc was accepted.
int64 accept_time = 5
Time at which this htlc was accepted.
int64 resolve_time = 6
Time at which this htlc was settled or canceled.
int32 expiry_height = 7
Block height at which this htlc expires.
InvoiceHTLCState state = 8
Current state the htlc is in.
map<uint64, bytes> custom_records = 9
Custom tlv records.
uint64 mpp_total_amt_msat = 10
The total amount of the mpp payment in msat.
optional amp = 11
Details relevant to AMP HTLCs, only populated if this is an AMP HTLC.
bytes custom_channel_data = 12
Custom channel data that might be populated in custom channels.
Used in: ,
ACCEPTED = 0
SETTLED = 1
CANCELED = 2
message
lightning.proto:2518Used in:
bytes raw_key_bytes = 1
The raw bytes of the key being identified.
optional key_loc = 2
The key locator that identifies which key to use for signing.
message
lightning.proto:2510Used in:
int32 key_family = 1
The family of key being identified.
int32 key_index = 2
The precise index of the key being identified.
message
lightning.proto:1031Used in:
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`.
message
lightning.proto:3457An 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: ,
uint32 last_update = 1
string pub_key = 2
string alias = 3
repeated addresses = 4
string color = 5
map<uint32, > features = 6
map<uint64, bytes> custom_records = 7
Custom node announcement tlv records.
message
lightning.proto:3331Used in:
bytes payment_addr = 11
A unique, random identifier used to authenticate the sender as the intended payer of a multi-path payment. The payment_addr must be the same for all subpayments, and match the payment_addr provided in the receiver's invoice. The same payment_addr must be used on all subpayments. This is also called payment secret in specifications (e.g. BOLT 11).
int64 total_amt_msat = 10
The total amount in milli-satoshis being sent as part of a larger multi-path payment. The caller is responsible for ensuring subpayments to the same node and payment_hash sum exactly to total_amt_msat. The same total_amt_msat must be used on all subpayments.
message
lightning.proto:5113bytes nonce = 1
bytes storageId = 2
repeated ops = 3
message
lightning.proto:4892Used in: , ,
string entity = 1
The entity a permission grants access to.
string action = 2
The action that is granted.
message
lightning.proto:4933Used in:
repeated permissions = 1
A list of macaroon permissions.
message
lightning.proto:5251Used in:
repeated string values = 1
The set of metadata values that correspond to the metadata key.
message
lightning.proto:5336Used in:
string middleware_name = 1
The name of the middleware to register. The name should be as informative as possible and is logged on registration.
string custom_macaroon_caveat_name = 2
The name of the custom macaroon caveat that this middleware is responsible for. Only requests/responses that contain a macaroon with the registered custom caveat are forwarded for interception to the middleware. The exception being the read-only mode: All requests/responses are forwarded to a middleware that requests read-only access but such a middleware won't be allowed to _alter_ responses. As a security measure, _no_ middleware can change responses to requests made with _unencumbered_ macaroons! NOTE: Cannot be used at the same time as read_only_mode.
bool read_only_mode = 3
Instead of defining a custom macaroon caveat name a middleware can register itself for read-only access only. In that mode all requests/responses are forwarded to the middleware but the middleware isn't allowed to alter any of the responses. NOTE: Cannot be used at the same time as custom_macaroon_caveat_name.
message
lightning.proto:4828Used in:
repeated 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. When using REST, this field must be encoded as base64.
message
lightning.proto:3469Used in: ,
string network = 1
string addr = 2
Used in:
UNKNOWN = 0
BETWEENNESS_CENTRALITY = 1
message
lightning.proto:3208Used in:
bytes from = 1
The sending node of the pair. When using REST, this field must be encoded as base64.
bytes to = 2
The receiving node of the pair. When using REST, this field must be encoded as base64.
message
lightning.proto:3657Used in:
repeated string addresses = 1
Deprecated, use node_addresses.
string identity_key = 2
bytes global_features = 3
Deprecated, use features.
string alias = 4
string color = 5
repeated node_addresses = 7
map<uint32, > features = 6
Features that the node has advertised in the init message, node announcements and invoices.
message
lightning.proto:5119Used in: ,
string entity = 1
repeated string actions = 2
message
lightning.proto:2320Used as request type in: Lightning.OpenChannel, Lightning.OpenChannelSync
uint64 sat_per_vbyte = 1
A manual fee rate set in sat/vbyte that should be used when crafting the funding transaction.
bytes node_pubkey = 2
The pubkey of the node to open a channel with. When using REST, this field must be encoded as base64.
string node_pubkey_string = 3
The hex encoded pubkey of the node to open a channel with. Deprecated now that the REST gateway supports base64 encoding of bytes fields.
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
Deprecated, use sat_per_vbyte. A manual fee rate set in sat/vbyte 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.
string close_address = 13
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.
optional funding_shim = 14
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).
uint64 remote_max_value_in_flight_msat = 15
The maximum amount of coins in millisatoshi that can be pending within the channel. It only applies to the remote party.
uint32 remote_max_htlcs = 16
The maximum number of concurrent HTLCs we will allow the remote party to add to the commitment transaction.
uint32 max_local_csv = 17
Max local csv is the maximum csv delay we will allow for our own commitment transaction.
CommitmentType commitment_type = 18
The explicit commitment type to use. Note this field will only be used if the remote peer supports explicit channel negotiation.
bool zero_conf = 19
If this is true, then a zero-conf channel open will be attempted.
bool scid_alias = 20
If this is true, then an option-scid-alias channel-type open will be attempted.
uint64 base_fee = 21
The base fee charged regardless of the number of milli-satoshis sent.
uint64 fee_rate = 22
The fee rate in ppm (parts per million) that will be charged in proportion of the value of each forwarded HTLC.
bool use_base_fee = 23
If use_base_fee is true the open channel announcement will update the channel base fee with the value specified in base_fee. In the case of a base_fee of 0 use_base_fee is needed downstream to distinguish whether to use the default base fee value specified in the config or 0.
bool use_fee_rate = 24
If use_fee_rate is true the open channel announcement will update the channel fee rate with the value specified in fee_rate. In the case of a fee_rate of 0 use_fee_rate is needed downstream to distinguish whether to use the default fee rate value specified in the config or 0.
uint64 remote_chan_reserve_sat = 25
The number of satoshis we require the remote peer to reserve. This value, if specified, must be above the dust limit and below 20% of the channel capacity.
bool fund_max = 26
If set, then lnd will attempt to commit all the coins under control of the internal wallet to open the channel, and the LocalFundingAmount field must be zero and is ignored.
string memo = 27
An optional note-to-self to go along with the channel containing some useful information. This is only ever stored locally and in no way impacts the channel's operation.
repeated outpoints = 28
A list of selected outpoints that are allocated for channel funding.
message
lightning.proto:1011Used in: , , , , , , , , , , , ,
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.
message
lightning.proto:736Used in:
OutputScriptType output_type = 1
The type of the output
string address = 2
The address
string pk_script = 3
The pkscript in hex
int64 output_index = 4
The output index used in the raw transaction
int64 amount = 5
The value of the output coin in satoshis
bool is_our_address = 6
Denotes if the output is controlled by the internal wallet
Used in:
SCRIPT_TYPE_PUBKEY_HASH = 0
SCRIPT_TYPE_SCRIPT_HASH = 1
SCRIPT_TYPE_WITNESS_V0_PUBKEY_HASH = 2
SCRIPT_TYPE_WITNESS_V0_SCRIPT_HASH = 3
SCRIPT_TYPE_PUBKEY = 4
SCRIPT_TYPE_MULTISIG = 5
SCRIPT_TYPE_NULLDATA = 6
SCRIPT_TYPE_NON_STANDARD = 7
SCRIPT_TYPE_WITNESS_UNKNOWN = 8
SCRIPT_TYPE_WITNESS_V1_TAPROOT = 9
message
lightning.proto:4286Used as response type in: routerrpc.Router.SendPaymentV2, routerrpc.Router.TrackPaymentV2, routerrpc.Router.TrackPayments
Used as field type in:
string payment_hash = 1
The payment hash
int64 value = 2
Deprecated, use value_sat or value_msat.
int64 creation_date = 3
Deprecated, use creation_time_ns
int64 fee = 5
Deprecated, use fee_sat or fee_msat.
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.
int64 fee_sat = 11
The fee paid for this payment in satoshis
int64 fee_msat = 12
The fee paid for this payment in milli-satoshis
int64 creation_time_ns = 13
The time in UNIX nanoseconds at which the payment was created.
repeated htlcs = 14
The HTLCs made in attempt to settle the payment.
uint64 payment_index = 15
The creation index of this payment. Each payment can be uniquely identified by this index, which may not strictly increment by 1 for payments made in older versions of lnd.
PaymentFailureReason failure_reason = 16
map<uint64, bytes> first_hop_custom_records = 17
The custom TLV records that were sent to the first hop as part of the HTLC wire message for this payment.
Used in:
UNKNOWN = 0
Deprecated. This status will never be returned.
IN_FLIGHT = 1
Payment has inflight HTLCs.
SUCCEEDED = 2
Payment is settled.
FAILED = 3
Payment is failed.
INITIATED = 4
Payment is created and has not attempted any HTLCs.
Used in: ,
FAILURE_REASON_NONE = 0
Payment isn't failed (yet).
FAILURE_REASON_TIMEOUT = 1
There are more routes to try, but the payment timeout was exceeded.
FAILURE_REASON_NO_ROUTE = 2
All possible routes were tried and failed permanently. Or were no routes to the destination at all.
FAILURE_REASON_ERROR = 3
A non-recoverable error has occured.
FAILURE_REASON_INCORRECT_PAYMENT_DETAILS = 4
Payment details incorrect (unknown hash, invalid amt or invalid final cltv delta)
FAILURE_REASON_INSUFFICIENT_BALANCE = 5
Insufficient local balance.
FAILURE_REASON_CANCELED = 6
The payment was canceled.
message
lightning.proto:1794Used in:
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.
map<uint32, > features = 11
Features advertised by the remote peer in their init message.
repeated errors = 12
The latest errors received from our peer with timestamps, limited to the 10 most recent errors. These errors are tracked across peer connections, but are not persisted across lnd restarts. Note that these errors are only stored for peers that we have channels open with, to prevent peers from spamming us with errors at no cost.
int32 flap_count = 13
This field is populated when the peer has at least one channel with us. The number of times we have recorded this peer going offline or coming online, recorded across restarts. Note that this value is decreased over time if the peer has not recently flapped, so that we can forgive peers with historically high flap counts.
int64 last_flap_ns = 14
This field is populated when the peer has at least one channel with us. The timestamp of the last flap we observed for this peer. If this value is zero, we have not observed any flaps for this peer.
bytes last_ping_payload = 15
The last ping payload the peer has sent to us.
Used in:
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.
PINNED_SYNC = 3
Denotes that this peer is pinned into an active sync.
Used in:
PEER_ONLINE = 0
PEER_OFFLINE = 1
message
lightning.proto:2894Used in:
optional channel = 1
The pending channel to be closed
string closing_txid = 2
The transaction id of the closing transaction
message
lightning.proto:2865Used in:
string local_txid = 1
Hash of the local version of the commitment tx.
string remote_txid = 2
Hash of the remote version of the commitment tx.
string remote_pending_txid = 3
Hash of the remote pending version of the commitment tx.
uint64 local_commit_fee_sat = 4
The amount in satoshis calculated to be paid in fees for the local commitment.
uint64 remote_commit_fee_sat = 5
The amount in satoshis calculated to be paid in fees for the remote commitment.
uint64 remote_pending_commit_fee_sat = 6
The amount in satoshis calculated to be paid in fees for the remote pending commitment.
message
lightning.proto:2902Used in:
optional 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 pending_htlcs = 8
ForceClosedChannel.AnchorState anchor = 9
There are three resolution states for the anchor: limbo, lost and recovered. Derive the current state from the limbo and recovered balances.
Used in:
LIMBO = 0
The recovered_balance is zero and limbo_balance is non-zero.
RECOVERED = 1
The recovered_balance is non-zero.
LOST = 2
A state that is neither LIMBO nor RECOVERED.
message
lightning.proto:2722Used in: , , ,
string remote_node_pub = 1
string channel_point = 2
int64 capacity = 3
int64 local_balance = 4
int64 remote_balance = 5
int64 local_chan_reserve_sat = 6
The minimum satoshis this node is required to reserve in its balance.
int64 remote_chan_reserve_sat = 7
The minimum satoshis the other node is required to reserve in its balance.
Initiator initiator = 8
The party that initiated opening the channel.
CommitmentType commitment_type = 9
The commitment type used by this channel.
int64 num_forwarding_packages = 10
Total number of forwarding packages created in this channel.
string chan_status_flags = 11
A set of flags showing the current state of the channel.
bool private = 12
Whether this channel is advertised to the network or not.
string memo = 13
An optional note-to-self to go along with the channel containing some useful information. This is only ever stored locally and in no way impacts the channel's operation.
bytes custom_channel_data = 34
Custom channel data that might be populated in custom channels.
message
lightning.proto:2769Used in:
optional channel = 1
The pending channel
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.
int32 funding_expiry_blocks = 3
The number of blocks until the funding transaction is considered expired. If this value gets close to zero, there is a risk that the channel funding will be canceled by the channel responder. The channel should be fee bumped using CPFP (see walletrpc.BumpFee) to ensure that the channel confirms in time. Otherwise a force-close will be necessary if the channel confirms after the funding transaction expires. A negative value means the channel responder has very likely canceled the funding and the channel will never become fully operational.
uint32 confirmations_until_active = 7
The number of blocks remaining until the channel status changes from pending to active. A value of 0 indicates that the channel is now active. "Active" here means both channel peers have the channel marked OPEN and can immediately start using it. For public channels, this does not imply a channel_announcement has been gossiped. It only becomes public on the network after 6 on‐chain confirmations. See BOLT07 "Routing Gossip": https://github.com/lightning/bolts/blob/master/07-routing-gossip.md ZeroConf channels bypass the pending state entirely: they are marked active immediately upon creation, so they never show up as "pending".
uint32 confirmation_height = 8
The confirmation height records the block height at which the funding transaction was first confirmed.
message
lightning.proto:2826Used in:
optional channel = 1
The pending channel waiting for closing tx to confirm
int64 limbo_balance = 2
The balance in satoshis encumbered in this channel
optional commitments = 3
A list of valid commitment transactions. Any of these can confirm at this point.
string closing_txid = 4
The transaction id of the closing transaction
string closing_tx_hex = 5
The raw hex encoded bytes of the closing transaction. Included if include_raw_tx in the request is true.
uint32 blocks_til_close_confirmed = 6
Remaining number of confirmations until the channel closure is considered final and removed from waiting close. Channel closes require multiple confirmations for reorg protection — the exact number scales with channel capacity. A closing transaction that gets reorganized out of the chain resets this counter. When the closing transaction is not yet confirmed, this value equals the total number of confirmations required.
uint32 close_height = 7
The block height at which the closing transaction was first confirmed. This will be zero if the closing transaction has not yet confirmed, or if this information is not available for older channels.
message
lightning.proto:2692Used in:
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
message
lightning.proto:2133Used in: , , ,
bytes txid = 1
uint32 output_index = 2
int64 fee_per_vbyte = 3
bool local_close_tx = 4
message
lightning.proto:1022Used in:
string outpoint = 1
The outpoint in format txid:n.
bool is_our_output = 2
Denotes if the outpoint is controlled by the internal wallet. The flag will only detect p2wkh, np2wkh and p2tr inputs as its own.
message
lightning.proto:2569Used in:
bytes pending_chan_id = 1
A unique identifier of 32 random bytes that will be used as the pending channel ID to identify the PSBT state machine when interacting with it and on the wire protocol to initiate the funding request.
bytes base_psbt = 2
An optional base PSBT the new channel output will be added to. If this is non-empty, it must be a binary serialized PSBT.
bool no_publish = 3
If a channel should be part of a batch (multiple channel openings in one transaction), it can be dangerous if the whole batch transaction is published too early before all channel opening negotiations are completed. This flag prevents this particular channel from broadcasting the transaction after the negotiation with the remote peer. In a batch of channel openings this flag should be set to true for every channel but the very last.
message
lightning.proto:5267Used in:
string method_full_uri = 1
The full URI (in the format /<rpcpackage>.<ServiceName>/MethodName, for example /lnrpc.Lightning/GetInfo) of the RPC method the message was sent to/from.
bool stream_rpc = 2
Indicates whether the message was sent over a streaming RPC method or not.
string type_name = 3
The full canonical gRPC name of the message type (in the format <rpcpackage>.TypeName, for example lnrpc.GetInfoRequest). In case of an error being returned from lnd, this simply contains the string "error".
bytes serialized = 4
The full content of the gRPC message, serialized in the binary protobuf format.
bool is_error = 5
Indicates that the response from lnd was an error, not a gRPC response. If this is set to true then the type_name contains the string "error" and serialized contains the error string.
message
lightning.proto:2147Used in:
string funding_address = 1
The P2WSH address of the channel funding multisig address that the below specified amount in satoshis needs to be sent to.
int64 funding_amount = 2
The exact amount in satoshis that needs to be sent to the above address to fund the pending channel.
bytes psbt = 3
A raw PSBT that contains the pending channel output. If a base PSBT was provided in the PsbtShim, this is the base PSBT with one additional output. If no base PSBT was specified, this is an otherwise empty PSBT with exactly one output.
message
lightning.proto:1763Used in:
ResolutionType resolution_type = 1
The type of output we are resolving.
ResolutionOutcome outcome = 2
The outcome of our on chain action that resolved the outpoint.
optional outpoint = 3
The outpoint that was spent by the resolution.
uint64 amount_sat = 4
The amount that was claimed by the resolution.
string sweep_txid = 5
The hex-encoded transaction ID of the sweep transaction that spent the output.
Used in:
OUTCOME_UNKNOWN = 0
Outcome unknown.
CLAIMED = 1
An output was claimed on chain.
UNCLAIMED = 2
An output was left unclaimed on chain.
ABANDONED = 3
ResolverOutcomeAbandoned indicates that an output that we did not claim on chain, for example an anchor that we did not sweep and a third party claimed on chain, or a htlc that we could not decode so left unclaimed.
FIRST_STAGE = 4
If we force closed our channel, our htlcs need to be claimed in two stages. This outcome represents the broadcast of a timeout or success transaction for this two stage htlc claim.
TIMEOUT = 5
A htlc was timed out on chain.
Used in:
TYPE_UNKNOWN = 0
ANCHOR = 1
We resolved an anchor output.
INCOMING_HTLC = 2
We are resolving an incoming htlc on chain. This if this htlc is claimed, we swept the incoming htlc with the preimage. If it is timed out, our peer swept the timeout path.
OUTGOING_HTLC = 3
We are resolving an outgoing htlc on chain. If this htlc is claimed, the remote party swept the htlc with the preimage. If it is timed out, we swept it with the timeout path.
COMMIT = 4
We force closed and need to sweep our time locked commitment output.
message
lightning.proto:3365A 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: , , ,
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 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.
int64 first_hop_amount_msat = 7
The actual on-chain amount that was sent out to the first hop. This value is only different from the total_amt_msat field if this is a custom channel payment and the value transported in the HTLC is different from the BTC amount in the HTLC. If this value is zero, then this is an old payment that didn't have this value yet and can be ignored.
bytes custom_channel_data = 8
Custom channel data that might be populated in custom channels.
message
lightning.proto:3733Used in: , , , ,
repeated hop_hints = 1
A list of hop hints that when chained together can assist in reaching a specific destination.
message
lightning.proto:3474Used in: ,
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
uint32 last_update = 7
map<uint64, bytes> custom_records = 8
Custom channel update tlv records. These are customized fields that are not defined by LND and cannot be extracted.
int32 inbound_fee_base_msat = 9
int32 inbound_fee_rate_milli_msat = 10
message
lightning.proto:3729bytes set_id = 1
message
lightning.proto:5258Used in:
string method_full_uri = 1
The full URI (in the format /<rpcpackage>.<ServiceName>/MethodName, for example /lnrpc.Lightning/GetInfo) of the streaming RPC method that was just established.
message
lightning.proto:1878Used in:
uint64 timestamp = 1
The unix timestamp in seconds when the error occurred.
string error = 2
The string representation of the error sent by our peer.
message
lightning.proto:756Used as response type in: Lightning.SubscribeTransactions, walletrpc.WalletKit.GetTransaction
Used as field type in:
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. Deprecated as it is now incorporated in the output_details field.
repeated output_details = 11
Outputs that received funds for this transaction
string raw_tx_hex = 9
The raw transaction hex.
string label = 10
A label that was optionally set on transaction broadcast.
repeated previous_outpoints = 12
PreviousOutpoints/Inputs of this transaction.
message
lightning.proto:827Used as response type in: Lightning.GetTransactions
Used as field type in:
repeated transactions = 1
The list of transactions relevant to the wallet.
uint64 last_index = 2
The index of the last item in the set of returned transactions. This can be used to seek further, pagination style.
uint64 first_index = 3
The index of the last item in the set of returned transactions. This can be used to seek backwards, pagination style.
Used in:
UPDATE_FAILURE_UNKNOWN = 0
UPDATE_FAILURE_PENDING = 1
UPDATE_FAILURE_NOT_FOUND = 2
UPDATE_FAILURE_INTERNAL_ERR = 3
UPDATE_FAILURE_INVALID_PARAMETER = 4
message
lightning.proto:703Used in: ,
AddressType address_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 = 5
The outpoint in format txid:n
int64 confirmations = 6
The number of confirmations for the Utxo
message
lightning.proto:2997Used in:
int64 confirmed_balance = 1
The confirmed balance of the account (with >= 1 confirmations).
int64 unconfirmed_balance = 2
The unconfirmed balance of the account (with 0 confirmations).
Used in: ,
NON_EXISTING = 0
NON_EXISTING means that the wallet has not yet been initialized.
LOCKED = 1
LOCKED means that the wallet is locked and requires a password to unlock.
UNLOCKED = 2
UNLOCKED means that the wallet was unlocked successfully, but RPC server isn't ready.
RPC_ACTIVE = 3
RPC_ACTIVE means that the lnd server is active but not fully ready for calls.
SERVER_ACTIVE = 4
SERVER_ACTIVE means that the lnd server is ready to accept calls.
WAITING_TO_START = 255
WAITING_TO_START means that node is waiting to become the leader in a cluster and is not started yet.
message
walletunlocker.proto:207Used in:
uint64 master_key_birthday_timestamp = 1
The unix timestamp in seconds of when the master key was created. lnd will only start scanning for funds in blocks that are after the birthday which can speed up the process significantly. If the birthday is not known, this should be left at its default value of 0 in which case lnd will start scanning from the first SegWit block (481824 on mainnet).
bytes master_key_fingerprint = 2
The fingerprint of the root key (also known as the key with derivation path m/) from which the account public keys were derived from. This may be required by some hardware wallets for proper identification and signing. The bytes must be in big-endian order.
repeated accounts = 3
The list of accounts to import. There _must_ be an account for all of lnd's main key scopes: BIP49/BIP84 (m/49'/0'/0', m/84'/0'/0', note that the coin type is always 0, even for testnet/regtest) and lnd's internal key scope (m/1017'/<coin_type>'/<account>'), where account is the key family as defined in `keychain/derivation.go` (currently indices 0 to 9).
message
walletunlocker.proto:235Used in:
uint32 purpose = 1
Purpose is the first number in the derivation path, must be either 49, 84 or 1017.
uint32 coin_type = 2
Coin type is the second number in the derivation path, this is _always_ 0 for purposes 49 and 84. It only needs to be set to 1 for purpose 1017 on testnet or regtest.
uint32 account = 3
Account is the third number in the derivation path. For purposes 49 and 84 at least the default account (index 0) needs to be created but optional additional accounts are allowed. For purpose 1017 there needs to be exactly one account for each of the key families defined in `keychain/derivation.go` (currently indices 0 to 9)
string xpub = 4
The extended public key at depth 3 for the given account.