lnd.xprv/lnrpc/rpc.proto

1413 lines
47 KiB
Protocol Buffer
Raw Normal View History

2015-12-30 23:19:09 +03:00
syntax = "proto3";
import "google/api/annotations.proto";
2015-12-30 23:19:09 +03:00
package lnrpc;
/**
* Comments in this file will be directly parsed into the API
* Documentation as descriptions of the associated method, message, or field.
* These descriptions should go right above the definition of the object, and
* can be in either block or /// comment format.
*
* One edge case exists where a // comment followed by a /// comment in the
* next line will cause the description not to show up in the documentation. In
* that instance, simply separate the two comments with a blank line.
*
* An RPC method can be matched to an lncli command by placing a line in the
* beginning of the description in exactly the following format:
* lncli: `methodname`
*
* Failure to specify the exact name of the command will cause documentation
* generation to fail.
*
* More information on how exactly the gRPC documentation is generated from
* this proto file can be found here:
* https://github.com/MaxFangX/lightning-api
*/
2015-12-30 23:19:09 +03:00
// The WalletUnlocker service is used to set up a wallet password for
// lnd at first startup, and unlock a previously set up wallet.
service WalletUnlocker {
/** lncli: `create`
CreateWallet is used at lnd startup to set the encryption password for
the wallet database.
*/
rpc CreateWallet(CreateWalletRequest) returns (CreateWalletResponse) {
option (google.api.http) = {
post: "/v1/createwallet"
body: "*"
};
}
/** lncli: `unlock`
UnlockWallet is used at startup of lnd to provide a password to unlock
the wallet database.
*/
rpc UnlockWallet(UnlockWalletRequest) returns (UnlockWalletResponse) {
option (google.api.http) = {
post: "/v1/unlockwallet"
body: "*"
};
}
}
message CreateWalletRequest {
bytes password = 1;
}
message CreateWalletResponse {}
message UnlockWalletRequest {
bytes password = 1;
}
message UnlockWalletResponse {}
2015-12-30 23:19:09 +03:00
service Lightning {
/** lncli: `walletbalance`
WalletBalance returns the sum of all confirmed unspent outputs under control
by the wallet. This method can be modified by having the request specify
only witness outputs should be factored into the final output sum.
*/
rpc WalletBalance (WalletBalanceRequest) returns (WalletBalanceResponse) {
option (google.api.http) = {
get: "/v1/balance/blockchain"
};
}
/** lncli: `channelbalance`
ChannelBalance returns the total funds available across all open channels
in satoshis.
*/
rpc ChannelBalance (ChannelBalanceRequest) returns (ChannelBalanceResponse) {
option (google.api.http) = {
get: "/v1/balance/channels"
};
}
/** lncli: `listchaintxns`
GetTransactions returns a list describing all the known transactions
relevant to the wallet.
*/
rpc GetTransactions (GetTransactionsRequest) returns (TransactionDetails) {
option (google.api.http) = {
get: "/v1/transactions"
};
}
/** lncli: `sendcoins`
SendCoins executes a request to send coins to a particular address. Unlike
SendMany, this RPC call only allows creating a single output at a time. If
neither target_conf, or sat_per_byte are set, then the internal wallet will
consult its fee model to determine a fee for the default confirmation
target.
*/
rpc SendCoins (SendCoinsRequest) returns (SendCoinsResponse) {
option (google.api.http) = {
post: "/v1/transactions"
body: "*"
};
}
/**
SubscribeTransactions creates a uni-directional stream from the server to
the client in which any newly discovered transactions relevant to the
wallet are sent over.
*/
rpc SubscribeTransactions (GetTransactionsRequest) returns (stream Transaction);
/** lncli: `sendmany`
SendMany handles a request for a transaction that creates multiple specified
outputs in parallel. If neither target_conf, or sat_per_byte are set, then
the internal wallet will consult its fee model to determine a fee for the
default confirmation target.
*/
rpc SendMany (SendManyRequest) returns (SendManyResponse);
2015-12-31 06:02:24 +03:00
/** lncli: `newaddress`
NewAddress creates a new address under control of the local wallet.
*/
rpc NewAddress (NewAddressRequest) returns (NewAddressResponse);
/**
NewWitnessAddress creates a new witness address under control of the local wallet.
*/
rpc NewWitnessAddress (NewWitnessAddressRequest) returns (NewAddressResponse) {
option (google.api.http) = {
get: "/v1/newaddress"
};
}
/** lncli: `signmessage`
SignMessage signs a message with this node's private key. The returned
signature string is `zbase32` encoded and pubkey recoverable, meaning that
only the message digest and signature are needed for verification.
*/
rpc SignMessage (SignMessageRequest) returns (SignMessageResponse);
/** lncli: `verifymessage`
VerifyMessage verifies a signature over a msg. The signature must be
zbase32 encoded and signed by an active node in the resident node's
channel database. In addition to returning the validity of the signature,
VerifyMessage also returns the recovered pubkey from the signature.
*/
rpc VerifyMessage (VerifyMessageRequest) returns (VerifyMessageResponse);
/** lncli: `connect`
ConnectPeer attempts to establish a connection to a remote peer. This is at
the networking level, and is used for communication between nodes. This is
distinct from establishing a channel with a peer.
*/
rpc ConnectPeer (ConnectPeerRequest) returns (ConnectPeerResponse) {
option (google.api.http) = {
post: "/v1/peers"
body: "*"
};
}
/** lncli: `disconnect`
DisconnectPeer attempts to disconnect one peer from another identified by a
given pubKey. In the case that we currently have a pending or active channel
with the target peer, then this action will be not be allowed.
*/
rpc DisconnectPeer (DisconnectPeerRequest) returns (DisconnectPeerResponse) {
option (google.api.http) = {
delete: "/v1/peers/{pub_key}"
};
}
/** lncli: `listpeers`
ListPeers returns a verbose listing of all currently active peers.
*/
rpc ListPeers (ListPeersRequest) returns (ListPeersResponse) {
option (google.api.http) = {
get: "/v1/peers"
};
}
/** lncli: `getinfo`
GetInfo returns general information concerning the lightning node including
it's identity pubkey, alias, the chains it is connected to, and information
concerning the number of open+pending channels.
*/
rpc GetInfo (GetInfoRequest) returns (GetInfoResponse) {
option (google.api.http) = {
get: "/v1/getinfo"
};
}
// TODO(roasbeef): merge with below with bool?
/** lncli: `pendingchannels`
PendingChannels returns a list of all the channels that are currently
considered "pending". A channel is pending if it has finished the funding
workflow and is waiting for confirmations for the funding txn, or is in the
process of closure, either initiated cooperatively or non-cooperatively.
*/
rpc PendingChannels (PendingChannelRequest) returns (PendingChannelResponse) {
option (google.api.http) = {
get: "/v1/channels/pending"
};
}
/** lncli: `listchannels`
ListChannels returns a description of all the open channels that this node
is a participant in.
*/
rpc ListChannels (ListChannelsRequest) returns (ListChannelsResponse) {
option (google.api.http) = {
get: "/v1/channels"
};
}
/**
OpenChannelSync is a synchronous version of the OpenChannel RPC call. This
call is meant to be consumed by clients to the REST proxy. As with all
other sync calls, all byte slices are intended to be populated as hex
encoded strings.
*/
rpc OpenChannelSync (OpenChannelRequest) returns (ChannelPoint) {
option (google.api.http) = {
post: "/v1/channels"
body: "*"
};
}
/** lncli: `openchannel`
OpenChannel attempts to open a singly funded channel specified in the
request to a remote peer. Users are able to specify a target number of
blocks that the funding transaction should be confirmed in, or a manual fee
rate to us for the funding transaction. If neither are specified, then a
lax block confirmation target is used.
*/
rpc OpenChannel (OpenChannelRequest) returns (stream OpenStatusUpdate);
/** lncli: `closechannel`
CloseChannel attempts to close an active channel identified by its channel
outpoint (ChannelPoint). The actions of this method can additionally be
augmented to attempt a force close after a timeout period in the case of an
inactive peer. If a non-force close (cooperative closure) is requested,
then the user can specify either a target number of blocks until the
closure transaction is confirmed, or a manual fee rate. If neither are
specified, then a default lax, block confirmation target is used.
*/
rpc CloseChannel (CloseChannelRequest) returns (stream CloseStatusUpdate) {
option (google.api.http) = {
delete: "/v1/channels/{channel_point.funding_txid}/{channel_point.output_index}"
};
}
/** lncli: `sendpayment`
SendPayment dispatches a bi-directional streaming RPC for sending payments
through the Lightning Network. A single RPC invocation creates a persistent
bi-directional stream allowing clients to rapidly send payments through the
Lightning Network with a single persistent connection.
*/
rpc SendPayment (stream SendRequest) returns (stream SendResponse);
/**
SendPaymentSync is the synchronous non-streaming version of SendPayment.
This RPC is intended to be consumed by clients of the REST proxy.
Additionally, this RPC expects the destination's public key and the payment
hash (if any) to be encoded as hex strings.
*/
rpc SendPaymentSync (SendRequest) returns (SendResponse) {
option (google.api.http) = {
post: "/v1/channels/transactions"
body: "*"
};
}
/** lncli: `addinvoice`
AddInvoice attempts to add a new invoice to the invoice database. Any
duplicated invoices are rejected, therefore all invoices *must* have a
unique payment preimage.
*/
rpc AddInvoice (Invoice) returns (AddInvoiceResponse) {
option (google.api.http) = {
post: "/v1/invoices"
body: "*"
};
}
/** lncli: `listinvoices`
ListInvoices returns a list of all the invoices currently stored within the
database. Any active debug invoices are ignored.
*/
rpc ListInvoices (ListInvoiceRequest) returns (ListInvoiceResponse) {
option (google.api.http) = {
get: "/v1/invoices/{pending_only}"
};
}
/** lncli: `lookupinvoice`
LookupInvoice attemps 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.
*/
rpc LookupInvoice (PaymentHash) returns (Invoice) {
option (google.api.http) = {
get: "/v1/invoices/{r_hash_str}"
};
}
/**
SubscribeInvoices returns a uni-directional stream (sever -> client) for
notifying the client of newly added/settled invoices.
*/
rpc SubscribeInvoices (InvoiceSubscription) returns (stream Invoice) {
option (google.api.http) = {
get: "/v1/invoices/subscribe"
};
}
/** lncli: `decodepayreq`
DecodePayReq takes an encoded payment request string and attempts to decode
it, returning a full description of the conditions encoded within the
payment request.
*/
rpc DecodePayReq (PayReqString) returns (PayReq) {
option (google.api.http) = {
get: "/v1/payreq/{pay_req}"
};
}
/** lncli: `listpayments`
ListPayments returns a list of all outgoing payments.
*/
rpc ListPayments (ListPaymentsRequest) returns (ListPaymentsResponse) {
option (google.api.http) = {
get: "/v1/payments"
};
};
/**
DeleteAllPayments deletes all outgoing payments from DB.
*/
rpc DeleteAllPayments (DeleteAllPaymentsRequest) returns (DeleteAllPaymentsResponse) {
option (google.api.http) = {
delete: "/v1/payments"
};
};
/** lncli: `describegraph`
DescribeGraph returns a description of the latest graph state from the
point of view of the node. The graph information is partitioned into two
components: all the nodes/vertexes, and all the edges that connect the
vertexes themselves. As this is a directed graph, the edges also contain
the node directional specific routing policy which includes: the time lock
delta, fee information, etc.
*/
rpc DescribeGraph (ChannelGraphRequest) returns (ChannelGraph) {
option (google.api.http) = {
get: "/v1/graph"
};
}
/** lncli: `getchaninfo`
GetChanInfo returns the latest authenticated network announcement for the
given channel identified by its channel ID: an 8-byte integer which
uniquely identifies the location of transaction's funding output within the
blockchain.
*/
rpc GetChanInfo (ChanInfoRequest) returns (ChannelEdge) {
option (google.api.http) = {
get: "/v1/graph/edge/{chan_id}"
};
}
/** lncli: `getnodeinfo`
GetNodeInfo returns the latest advertised, aggregated, and authenticated
channel information for the specified node identified by its public key.
*/
rpc GetNodeInfo (NodeInfoRequest) returns (NodeInfo) {
option (google.api.http) = {
get: "/v1/graph/node/{pub_key}"
};
}
/** lncli: `queryroutes`
QueryRoutes attempts to query the daemon's Channel Router for a possible
route to a target destination capable of carrying a specific amount of
satoshis. The retuned 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 encapsualted within the HTLC.
*/
rpc QueryRoutes(QueryRoutesRequest) returns (QueryRoutesResponse) {
option (google.api.http) = {
get: "/v1/graph/routes/{pub_key}/{amt}"
};
}
/** lncli: `getnetworkinfo`
GetNetworkInfo returns some basic stats about the known channel graph from
the point of view of the node.
*/
rpc GetNetworkInfo (NetworkInfoRequest) returns (NetworkInfo) {
option (google.api.http) = {
get: "/v1/graph/info"
};
}
/** lncli: `stop`
StopDaemon will send a shutdown request to the interrupt handler, triggering
a graceful shutdown of the daemon.
*/
rpc StopDaemon(StopRequest) returns (StopResponse);
/**
SubscribeChannelGraph launches a streaming RPC that allows the caller to
receive notifications upon any changes to the channel graph topology from
the point of view of the responding node. Events notified include: new
nodes coming online, nodes updating their authenticated attributes, new
channels being advertised, updates in the routing policy for a directional
channel edge, and when channels are closed on-chain.
*/
rpc SubscribeChannelGraph(GraphTopologySubscription) returns (stream GraphTopologyUpdate);
/**
SetAlias sets the alias for this node; e.g. "alice"
*/
rpc SetAlias(SetAliasRequest) returns (SetAliasResponse);
2017-01-15 05:14:03 +03:00
/** lncli: `debuglevel`
DebugLevel allows a caller to programmatically set the logging verbosity of
lnd. The logging can be targeted according to a coarse daemon-wide logging
level, or in a granular fashion to specify the logging for a target
sub-system.
*/
rpc DebugLevel (DebugLevelRequest) returns (DebugLevelResponse);
/** lncli: `feereport`
FeeReport allows the caller to obtain a report detailing the current fee
schedule enforced by the node globally for each channel.
*/
rpc FeeReport(FeeReportRequest) returns (FeeReportResponse) {
option (google.api.http) = {
get: "/v1/fees"
};
}
/** lncli: `updatefees`
UpdateFees allows the caller to update the fee schedule for all channels
globally, or a particular channel.
*/
rpc UpdateFees(FeeUpdateRequest) returns (FeeUpdateResponse) {
option (google.api.http) = {
post: "/v1/fees"
body: "*"
};
}
}
message Transaction {
/// The transaction hash
string tx_hash = 1 [ json_name = "tx_hash" ];
/// The transaction ammount, denominated in satoshis
int64 amount = 2 [ json_name = "amount" ];
/// The number of confirmations
int32 num_confirmations = 3 [ json_name = "num_confirmations" ];
/// The hash of the block this transaction was included in
string block_hash = 4 [ json_name = "block_hash" ];
/// The height of the block this transaction was included in
int32 block_height = 5 [ json_name = "block_height" ];
/// Timestamp of this transaction
int64 time_stamp = 6 [ json_name = "time_stamp" ];
/// Fees paid for this transaction
int64 total_fees = 7 [ json_name = "total_fees" ];
}
message GetTransactionsRequest {
}
message TransactionDetails {
/// The list of transactions relevant to the wallet.
repeated Transaction transactions = 1 [json_name = "transactions"];
}
message SendRequest {
/// The identity pubkey of the payment recipient
bytes dest = 1;
/// The hex-encoded identity pubkey of the payment recipient
string dest_string = 2;
/// Number of satoshis to send.
int64 amt = 3;
/// The hash to use within the payment's HTLC
bytes payment_hash = 4;
/// The hex-encoded hash to use within the payment's HTLC
string payment_hash_string = 5;
/**
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.
*/
string payment_request = 6;
}
message SendResponse {
string payment_error = 1 [json_name = "payment_error"];
bytes payment_preimage = 2 [json_name = "payment_preimage"];
Route payment_route = 3 [json_name = "payment_route"];
2015-12-30 23:19:09 +03:00
}
message ChannelPoint {
// TODO(roasbeef): make str vs bytes into a oneof
/// Txid of the funding transaction
bytes funding_txid = 1 [ json_name = "funding_txid" ];
/// Hex-encoded string representing the funding transaction
string funding_txid_str = 2 [ json_name = "funding_txid_str" ];
/// The index of the output of the funding transaction
uint32 output_index = 3 [ json_name = "output_index" ];
}
message LightningAddress {
/// The identity pubkey of the Lightning node
string pubkey = 1 [json_name = "pubkey"];
/// The network location of the lightning node, e.g. `69.69.69.69:1337` or `localhost:10011`
string host = 2 [json_name = "host"];
}
2015-12-30 23:19:09 +03:00
message SendManyRequest {
/// The map from addresses to amounts
2015-12-30 23:19:09 +03:00
map<string, int64> AddrToAmount = 1;
/// The target number of blocks that this transaction should be confirmed by.
int32 target_conf = 3;
/// A manual fee rate set in sat/byte that should be used when crafting the transaction.
int64 sat_per_byte = 5;
2015-12-30 23:19:09 +03:00
}
message SendManyResponse {
/// The id of the transaction
string txid = 1 [json_name = "txid"];
2015-12-30 23:19:09 +03:00
}
message SendCoinsRequest {
/// The address to send coins to
string addr = 1;
/// The amount in satoshis to send
int64 amount = 2;
/// The target number of blocks that this transaction should be confirmed by.
int32 target_conf = 3;
/// A manual fee rate set in sat/byte that should be used when crafting the transaction.
int64 sat_per_byte = 5;
}
message SendCoinsResponse {
/// The transaction ID of the transaction
string txid = 1 [json_name = "txid"];
}
/**
`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)
- `p2pkh`: Pay to public key hash (`PUBKEY_HASH` = 2)
*/
message NewAddressRequest {
enum AddressType {
WITNESS_PUBKEY_HASH = 0;
NESTED_PUBKEY_HASH = 1;
PUBKEY_HASH = 2;
}
/// The address type
AddressType type = 1;
}
message NewWitnessAddressRequest {
}
2015-12-30 23:19:09 +03:00
message NewAddressResponse {
/// The newly generated wallet address
string address = 1 [json_name = "address"];
2015-12-30 23:19:09 +03:00
}
message SignMessageRequest {
/// The message to be signed
bytes msg = 1 [ json_name = "msg" ];
}
message SignMessageResponse {
/// The signature for the given message
string signature = 1 [ json_name = "signature" ];
}
message VerifyMessageRequest {
/// The message over which the signature is to be verified
bytes msg = 1 [ json_name = "msg" ];
/// The signature to be verifed over the given message
string signature = 2 [ json_name = "signature" ];
}
message VerifyMessageResponse {
/// Whether the signature was valid over the given message
bool valid = 1 [ json_name = "valid" ];
/// The pubkey recovered from the signature
string pubkey = 2 [ json_name = "pubkey" ];
}
message ConnectPeerRequest {
/// Lightning address of the peer, in the format `<pubkey>@host`
LightningAddress addr = 1;
/** If set, the daemon will attempt to persistently connect to the target
* peer. Otherwise, the call will be synchronous. */
bool perm = 2;
}
message ConnectPeerResponse {
/// The id of the newly connected peer
int32 peer_id = 1 [json_name = "peer_id"];
}
message DisconnectPeerRequest {
/// The pubkey of the node to disconnect from
string pub_key = 1 [json_name = "pub_key"];
}
message DisconnectPeerResponse {
}
message HTLC {
bool incoming = 1 [json_name = "incoming"];
int64 amount = 2 [json_name = "amount"];
bytes hash_lock = 3 [json_name = "hash_lock"];
uint32 expiration_height = 4 [json_name = "expiration_height"];
}
message ActiveChannel {
/// Whether this channel is active or not
bool active = 1 [json_name = "active"];
/// The identity pubkey of the remote node
string remote_pubkey = 2 [json_name = "remote_pubkey"];
/**
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.
*/
string channel_point = 3 [json_name = "channel_point"];
/**
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.
*/
uint64 chan_id = 4 [json_name = "chan_id"];
/// The total amount of funds held in this channel
int64 capacity = 5 [json_name = "capacity"];
/// This node's current balance in this channel
int64 local_balance = 6 [json_name = "local_balance"];
/// The counterparty's current balance in this channel
int64 remote_balance = 7 [json_name = "remote_balance"];
/**
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_fee = 8 [json_name = "commit_fee"];
/// The weight of the commitment transaction
int64 commit_weight = 9 [ json_name = "commit_weight" ];
/**
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 fee_per_kw = 10 [json_name = "fee_per_kw"];
/// The unsettled balance in this channel
int64 unsettled_balance = 11 [json_name = "unsettled_balance"];
/**
The total number of satoshis we've sent within this channel.
*/
int64 total_satoshis_sent = 12 [json_name = "total_satoshis_sent"];
/**
The total number of satoshis we've received within this channel.
*/
int64 total_satoshis_received = 13 [json_name = "total_satoshis_received"];
/**
The total number of updates conducted within this channel.
*/
uint64 num_updates = 14 [json_name = "num_updates"];
/**
The list of active, uncleared HTLCs currently pending within the channel.
*/
repeated HTLC pending_htlcs = 15 [json_name = "pending_htlcs"];
}
message ListChannelsRequest {
}
message ListChannelsResponse {
/// The list of active channels
repeated ActiveChannel channels = 11 [json_name = "channels"];
}
message Peer {
/// The identity pubkey of the peer
string pub_key = 1 [json_name = "pub_key"];
/// The peer's id from the local point of view
int32 peer_id = 2 [json_name = "peer_id"];
/// Network address of the peer; eg `127.0.0.1:10011`
string address = 3 [json_name = "address"];
/// Bytes of data transmitted to this peer
uint64 bytes_sent = 4 [json_name = "bytes_sent"];
/// Bytes of data transmitted from this peer
uint64 bytes_recv = 5 [json_name = "bytes_recv"];
/// Satoshis sent to this peer
int64 sat_sent = 6 [json_name = "sat_sent"];
/// Satoshis received from this peer
int64 sat_recv = 7 [json_name = "sat_recv"];
/// A channel is inbound if the counterparty initiated the channel
bool inbound = 8 [json_name = "inbound"];
/// Ping time to this peer
int64 ping_time = 9 [json_name = "ping_time"];
}
message ListPeersRequest {
}
message ListPeersResponse {
/// The list of currently connected peers
repeated Peer peers = 1 [json_name = "peers"];
}
message GetInfoRequest {
}
2016-07-06 04:52:05 +03:00
message GetInfoResponse {
/// The identity pubkey of the current node.
string identity_pubkey = 1 [json_name = "identity_pubkey"];
/// If applicable, the alias of the current node, e.g. "bob"
string alias = 2 [json_name = "alias"];
2016-07-06 04:52:05 +03:00
/// Number of pending channels
uint32 num_pending_channels = 3 [json_name = "num_pending_channels"];
/// Number of active channels
uint32 num_active_channels = 4 [json_name = "num_active_channels"];
2016-07-06 04:52:05 +03:00
/// Number of peers
uint32 num_peers = 5 [json_name = "num_peers"];
/// The node's current view of the height of the best block
uint32 block_height = 6 [json_name = "block_height"];
/// The node's current view of the hash of the best block
string block_hash = 8 [json_name = "block_hash"];
/// Whether the wallet's view is synced to the main chain
bool synced_to_chain = 9 [ json_name = "synced_to_chain" ];
/// Whether the current node is connected to testnet
bool testnet = 10 [ json_name = "testnet" ];
/// A list of active chains the node is connected to
repeated string chains = 11 [ json_name = "chains" ];
2016-07-06 04:52:05 +03:00
}
message ConfirmationUpdate {
bytes block_sha = 1;
int32 block_height = 2;
uint32 num_confs_left = 3;
}
message ChannelOpenUpdate {
ChannelPoint channel_point = 1 [json_name = "channel_point"];
}
message ChannelCloseUpdate {
bytes closing_txid = 1 [json_name = "closing_txid"];
bool success = 2 [json_name = "success"];
}
message CloseChannelRequest {
/**
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.
*/
ChannelPoint channel_point = 1;
/// If true, then the channel will be closed forcibly. This means the current commitment transaction will be signed and broadcast.
bool force = 2;
/// The target number of blocks that the closure transaction should be confirmed by.
int32 target_conf = 3;
/// A manual fee rate set in sat/byte that should be used when crafting the closure transaction.
int64 sat_per_byte = 5;
}
message CloseStatusUpdate {
oneof update {
PendingUpdate close_pending = 1 [json_name = "close_pending"];
ConfirmationUpdate confirmation = 2 [json_name = "confirmation"];
ChannelCloseUpdate chan_close = 3 [json_name = "chan_close"];
}
}
message PendingUpdate {
bytes txid = 1 [json_name = "txid"];
uint32 output_index = 2 [json_name = "output_index"];
}
message OpenChannelRequest {
/// The peer_id of the node to open a channel with
int32 target_peer_id = 1 [json_name = "target_peer_id"];
/// The pubkey of the node to open a channel with
bytes node_pubkey = 2 [json_name = "node_pubkey"];
/// The hex encorded pubkey of the node to open a channel with
string node_pubkey_string = 3 [json_name = "node_pubkey_string"];
/// The number of satoshis the wallet should commit to the channel
int64 local_funding_amount = 4 [json_name = "local_funding_amount"];
/// The number of satoshis to push to the remote side as part of the initial commitment state
int64 push_sat = 5 [json_name = "push_sat"];
/// The target number of blocks that the closure transaction should be confirmed by.
int32 target_conf = 6;
/// A manual fee rate set in sat/byte that should be used when crafting the closure transaction.
int64 sat_per_byte = 7;
}
message OpenStatusUpdate {
oneof update {
PendingUpdate chan_pending = 1 [json_name = "chan_pending"];
ConfirmationUpdate confirmation = 2 [json_name = "confirmation"];
ChannelOpenUpdate chan_open = 3 [json_name = "chan_open"];
}
}
message PendingHTLC {
/// The direction within the channel that the htlc was sent
bool incoming = 1 [ json_name = "incoming" ];
/// The total value of the htlc
int64 amount = 2 [ json_name = "amount" ];
/// The final output to be swept back to the user's wallet
string outpoint = 3 [ json_name = "outpoint" ];
/// The next block height at which we can spend the current stage
uint32 maturity_height = 4 [ json_name = "maturity_height" ];
/**
The number of blocks remaining until the current stage can be swept.
Negative values indicate how many blocks have passed since becoming
mature.
*/
int32 blocks_til_maturity = 5 [ json_name = "blocks_til_maturity" ];
/// Indicates whether the htlc is in its first or second stage of recovery
uint32 stage = 6 [ json_name = "stage" ];
}
message PendingChannelRequest {}
message PendingChannelResponse {
message PendingChannel {
string remote_node_pub = 1 [ json_name = "remote_node_pub" ];
string channel_point = 2 [ json_name = "channel_point" ];
int64 capacity = 3 [ json_name = "capacity" ];
int64 local_balance = 4 [ json_name = "local_balance" ];
int64 remote_balance = 5 [ json_name = "remote_balance" ];
}
message PendingOpenChannel {
/// The pending channel
PendingChannel channel = 1 [ json_name = "channel" ];
/// The height at which this channel will be confirmed
uint32 confirmation_height = 2 [ json_name = "confirmation_height" ];
/// The number of blocks until this channel is open
2017-12-03 05:36:09 +03:00
int32 blocks_till_open = 3 [ json_name = "blocks_till_open" ];
/**
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_fee = 4 [json_name = "commit_fee" ];
/// The weight of the commitment transaction
int64 commit_weight = 5 [ json_name = "commit_weight" ];
/**
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 fee_per_kw = 6 [ json_name = "fee_per_kw" ];
}
message ClosedChannel {
/// The pending channel to be closed
PendingChannel channel = 1;
/// The transaction id of the closing transaction
string closing_txid = 2 [ json_name = "closing_txid" ];
}
message ForceClosedChannel {
/// The pending channel to be force closed
PendingChannel channel = 1 [ json_name = "channel" ];
/// The transaction id of the closing transaction
string closing_txid = 2 [ json_name = "closing_txid" ];
/// The balance in satoshis encumbered in this pending channel
int64 limbo_balance = 3 [ json_name = "limbo_balance" ];
/// The height at which funds can be sweeped into the wallet
uint32 maturity_height = 4 [ json_name = "maturity_height" ];
/*
Remaining # of blocks until the commitment output can be swept.
Negative values indicate how many blocks have passed since becoming
mature.
*/
int32 blocks_til_maturity = 5 [ json_name = "blocks_til_maturity" ];
/// The total value of funds successfully recovered from this channel
int64 recovered_balance = 6 [ json_name = "recovered_balance" ];
repeated PendingHTLC pending_htlcs = 8 [ json_name = "pending_htlcs" ];
}
/// The balance in satoshis encumbered in pending channels
int64 total_limbo_balance = 1 [ json_name = "total_limbo_balance" ];
/// Channels pending opening
repeated PendingOpenChannel pending_open_channels = 2 [ json_name = "pending_open_channels" ];
/// Channels pending closing
repeated ClosedChannel pending_closing_channels = 3 [ json_name = "pending_closing_channels" ];
/// Channels pending force closing
repeated ForceClosedChannel pending_force_closing_channels = 4 [ json_name = "pending_force_closing_channels" ];
}
message WalletBalanceRequest {
/// If only witness outputs should be considered when calculating the wallet's balance
bool witness_only = 1;
}
message WalletBalanceResponse {
/// The balance of the wallet
int64 balance = 1 [json_name = "balance"];
}
message ChannelBalanceRequest {
}
message ChannelBalanceResponse {
/// Sum of channels balances denominated in satoshis
int64 balance = 1 [json_name = "balance"];
}
message QueryRoutesRequest {
/// The 33-byte hex-encoded public key for the payment destination
string pub_key = 1;
/// The amount to send expressed in satoshis
int64 amt = 2;
}
message QueryRoutesResponse {
repeated Route routes = 1 [ json_name = "routes"];
}
message Hop {
/**
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.
*/
uint64 chan_id = 1 [json_name = "chan_id"];
int64 chan_capacity = 2 [json_name = "chan_capacity"];
int64 amt_to_forward = 3 [json_name = "amt_to_forward"];
int64 fee = 4 [json_name = "fee"];
uint32 expiry = 5 [json_name = "expiry"];
}
/**
A path through the channel graph which runs over one or more channels in
succession. This struct carries all the information required to craft the
Sphinx onion packet, and send the payment along the first hop in the path. A
route is only selected as valid if all the channels have sufficient capacity to
carry the initial payment amount after fees are accounted for.
*/
message Route {
/**
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.
*/
uint32 total_time_lock = 1 [json_name = "total_time_lock"];
/**
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
it ourself.
*/
int64 total_fees = 2 [json_name = "total_fees"];
/**
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.
*/
int64 total_amt = 3 [json_name = "total_amt"];
/**
Contains details concerning the specific forwarding details at each hop.
*/
repeated Hop hops = 4 [json_name = "hops"];
}
message NodeInfoRequest {
/// The 33-byte hex-encoded compressed public of the target node
string pub_key = 1;
}
message NodeInfo {
/**
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.
*/
LightningNode node = 1 [json_name = "node"];
uint32 num_channels = 2 [json_name = "num_channels"];
int64 total_capacity = 3 [json_name = "total_capacity"];
}
/**
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.
*/
message LightningNode {
uint32 last_update = 1 [ json_name = "last_update" ];
string pub_key = 2 [ json_name = "pub_key" ];
string alias = 3 [ json_name = "alias" ];
repeated NodeAddress addresses = 4 [ json_name = "addresses" ];
string color = 5 [ json_name = "color" ];
}
message NodeAddress {
string network = 1 [ json_name = "network" ];
string addr = 2 [ json_name = "addr" ];
}
message RoutingPolicy {
uint32 time_lock_delta = 1 [json_name = "time_lock_delta"];
int64 min_htlc = 2 [json_name = "min_htlc"];
int64 fee_base_msat = 3 [json_name = "fee_base_msat"];
int64 fee_rate_milli_msat = 4 [json_name = "fee_rate_milli_msat"];
}
/**
A fully authenticated channel along with all its unique attributes.
Once an authenticated channel announcement has been processed on the network,
then a 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.
*/
message ChannelEdge {
/**
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.
*/
uint64 channel_id = 1 [json_name = "channel_id"];
string chan_point = 2 [json_name = "chan_point"];
uint32 last_update = 3 [json_name = "last_update"];
string node1_pub = 4 [json_name = "node1_pub"];
string node2_pub = 5 [json_name = "node2_pub"];
int64 capacity = 6 [json_name = "capacity"];
RoutingPolicy node1_policy = 7 [json_name = "node1_policy"];
RoutingPolicy node2_policy = 8 [json_name = "node2_policy"];
}
message ChannelGraphRequest {
}
/// Returns a new instance of the directed channel graph.
message ChannelGraph {
/// The list of `LightningNode`s in this channel graph
repeated LightningNode nodes = 1 [json_name = "nodes"];
/// The list of `ChannelEdge`s in this channel graph
repeated ChannelEdge edges = 2 [json_name = "edges"];
}
message ChanInfoRequest {
/**
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.
*/
uint64 chan_id = 1;
}
message NetworkInfoRequest {
}
message NetworkInfo {
uint32 graph_diameter = 1 [json_name = "graph_diameter"];
double avg_out_degree = 2 [json_name = "avg_out_degree"];
uint32 max_out_degree = 3 [json_name = "max_out_degree"];
uint32 num_nodes = 4 [json_name = "num_nodes"];
uint32 num_channels = 5 [json_name = "num_channels"];
int64 total_network_capacity = 6 [json_name = "total_network_capacity"];
double avg_channel_size = 7 [json_name = "avg_channel_size"];
int64 min_channel_size = 8 [json_name = "min_channel_size"];
int64 max_channel_size = 9 [json_name = "max_channel_size"];
// TODO(roasbeef): fee rate info, expiry
// * also additional RPC for tracking fee info once in
}
message StopRequest{}
message StopResponse{}
message GraphTopologySubscription {}
message GraphTopologyUpdate {
repeated NodeUpdate node_updates = 1;
repeated ChannelEdgeUpdate channel_updates = 2;
repeated ClosedChannelUpdate closed_chans = 3;
}
message NodeUpdate {
repeated string addresses = 1;
string identity_key = 2;
bytes global_features = 3;
string alias = 4;
}
message ChannelEdgeUpdate {
/**
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.
*/
uint64 chan_id = 1;
ChannelPoint chan_point = 2;
int64 capacity = 3;
RoutingPolicy routing_policy = 4;
string advertising_node = 5;
string connecting_node = 6;
}
message ClosedChannelUpdate {
/**
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.
*/
uint64 chan_id = 1;
int64 capacity = 2;
uint32 closed_height = 3;
ChannelPoint chan_point = 4;
}
message SetAliasRequest {
string new_alias = 1;
}
message SetAliasResponse {
}
message Invoice {
/**
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.
*/
string memo = 1 [json_name = "memo"];
/// An optional cryptographic receipt of payment
bytes receipt = 2 [json_name = "receipt"];
/**
The hex-encoded preimage (32 byte) which will allow settling an incoming
HTLC payable to this preimage
*/
bytes r_preimage = 3 [json_name = "r_preimage"];
/// The hash of the preimage
bytes r_hash = 4 [json_name = "r_hash"];
/// The value of this invoice in satoshis
int64 value = 5 [json_name = "value"];
/// Whether this invoice has been fulfilled
bool settled = 6 [json_name = "settled"];
/// When this invoice was created
int64 creation_date = 7 [json_name = "creation_date"];
/// When this invoice was settled
int64 settle_date = 8 [json_name = "settle_date"];
/**
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.
*/
string payment_request = 9 [json_name = "payment_request"];
/**
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.
*/
bytes description_hash = 10 [json_name = "description_hash"];
/// Payment request expiry time in seconds. Default is 3600 (1 hour).
int64 expiry = 11 [json_name = "expiry"];
/// Fallback on-chain address.
string fallback_addr = 12 [json_name = "fallback_addr"];
/// Delta to use for the time-lock of the CLTV extended to the final hop.
uint64 cltv_expiry = 13 [json_name = "cltv_expiry"];
}
message AddInvoiceResponse {
bytes r_hash = 1 [json_name = "r_hash"];
/**
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.
*/
string payment_request = 2 [json_name = "payment_request"];
}
message PaymentHash {
/**
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.
*/
string r_hash_str = 1 [json_name = "r_hash_str"];
/// The payment hash of the invoice to be looked up.
bytes r_hash = 2 [json_name = "r_hash"];
}
message ListInvoiceRequest {
/// Toggles if all invoices should be returned, or only those that are currently unsettled.
bool pending_only = 1;
}
message ListInvoiceResponse {
repeated Invoice invoices = 1 [json_name = "invoices"];
}
message InvoiceSubscription {
}
message Payment {
/// The payment hash
string payment_hash = 1 [json_name = "payment_hash"];
/// The value of the payment in satoshis
int64 value = 2 [json_name = "value"];
/// The date of this payment
int64 creation_date = 3 [json_name = "creation_date"];
/// The path this payment took
repeated string path = 4 [ json_name = "path" ];
/// The fee paid for this payment in satoshis
int64 fee = 5 [json_name = "fee"];
}
message ListPaymentsRequest {
}
message ListPaymentsResponse {
/// The list of payments
repeated Payment payments = 1 [json_name = "payments"];
}
message DeleteAllPaymentsRequest {
}
message DeleteAllPaymentsResponse {
}
2017-01-15 05:14:03 +03:00
message DebugLevelRequest {
bool show = 1;
string level_spec = 2;
}
message DebugLevelResponse {
string sub_systems = 1 [json_name = "sub_systems"];
2017-01-15 05:14:03 +03:00
}
message PayReqString {
/// The payment request string to be decoded
string pay_req = 1;
}
message PayReq {
string destination = 1 [json_name = "destination"];
string payment_hash = 2 [json_name = "payment_hash"];
int64 num_satoshis = 3 [json_name = "num_satoshis"];
int64 timestamp = 4 [json_name = "timestamp"];
int64 expiry = 5 [json_name = "expiry"];
string description = 6 [json_name = "description"];
string description_hash = 7 [json_name = "description_hash"];
string fallback_addr = 8 [json_name = "fallback_addr"];
int64 cltv_expiry = 9 [json_name = "cltv_expiry"];
}
message FeeReportRequest {}
message ChannelFeeReport {
/// The channel that this fee report belongs to.
string chan_point = 1 [json_name = "channel_point"];
/// The base fee charged regardless of the number of milli-satoshis sent.
int64 base_fee_msat = 2 [json_name = "base_fee_msat"];
/// The amount charged per milli-satoshis transferred expressed in millionths of a satoshi.
int64 fee_per_mil = 3 [json_name = "fee_per_mil"];
/// The effective fee rate in milli-satoshis. Computed by dividing the fee_per_mil value by 1 million.
double fee_rate = 4 [json_name = "fee_rate"];
}
message FeeReportResponse {
/// An array of channel fee reports which describes the current fee schedule for each channel.
repeated ChannelFeeReport channel_fees = 1 [json_name = "channel_fees"];
}
message FeeUpdateRequest {
oneof scope {
/// If set, then this fee update applies to all currently active channels.
bool global = 1 [json_name = "global"] ;
/// If set, this fee update will target a specific channel.
ChannelPoint chan_point = 2 [json_name = "chan_point"];
}
/// The base fee charged regardless of the number of milli-satoshis sent.
int64 base_fee_msat = 3 [json_name = "base_fee_msat"];
/// The effective fee rate in milli-satoshis. The precision of this value goes up to 6 decimal places, so 1e-6.
double fee_rate = 4 [json_name = "fee_rate"];
}
message FeeUpdateResponse {
}