Add proto for ListChannels

Author: G8XSU

protos/src/proto/ldk_node_server.proto

@@ -238,3 +238,150 @@ message CloseChannelRequest {
 message CloseChannelResponse {
 
 }
+
+// Returns a list of known channels.
+// See more: https://docs.rs/ldk-node/latest/ldk_node/struct.Node.html#method.list_channels
+message ListChannelsRequest {}
+
+message ListChannelsResponse {
+
+  // List of channels.
+  repeated Channel channels = 1;
+}
+
+message Channel {
+  // The channel ID (prior to funding transaction generation, this is a random 32-byte
+  // identifier, afterwards this is the transaction ID of the funding transaction XOR the
+  // funding transaction output).
+  //
+  // Note that this means this value is *not* persistent - it can change once during the
+  // lifetime of the channel.
+  string channel_id = 1;
+
+  // The node ID of our the channel's remote counterparty.
+  string counterparty_node_id = 2;
+
+  // The channel's funding transaction output, if we've negotiated the funding transaction with
+  // our counterparty already.
+  optional OutPoint funding_txo = 3;
+
+  // The local `user_channel_id` of this channel.
+  bytes user_channel_id = 4;
+
+  // The value, in satoshis, that must always be held as a reserve in the channel for us. This
+  // value ensures that if we broadcast a revoked state, our counterparty can punish us by
+  // claiming at least this value on chain.
+  //
+  // This value is not included in [`outbound_capacity_msat`] as it can never be spent.
+  //
+  // This value will be `None` for outbound channels until the counterparty accepts the channel.
+  optional uint64 unspendable_punishment_reserve = 5;
+
+  // The value, in satoshis, of this channel as it appears in the funding output.
+  uint64 channel_value_sats = 6;
+
+  // The currently negotiated fee rate denominated in satoshi per 1000 weight units,
+  // which is applied to commitment and HTLC transactions.
+  uint32 feerate_sat_per_1000_weight = 7;
+
+  // The available outbound capacity for sending HTLCs to the remote peer.
+  //
+  // The amount does not include any pending HTLCs which are not yet resolved (and, thus, whose
+  // balance is not available for inclusion in new outbound HTLCs). This further does not include
+  // any pending outgoing HTLCs which are awaiting some other resolution to be sent.
+  uint64 outbound_capacity_msat = 8;
+
+  // The available outbound capacity for sending HTLCs to the remote peer.
+  //
+  // The amount does not include any pending HTLCs which are not yet resolved
+  // (and, thus, whose balance is not available for inclusion in new inbound HTLCs). This further
+  // does not include any pending outgoing HTLCs which are awaiting some other resolution to be
+  // sent.
+  uint64 inbound_capacity_msat = 9;
+
+  // The number of required confirmations on the funding transactions before the funding is
+  // considered "locked". The amount is selected by the channel fundee.
+  //
+  // The value will be `None` for outbound channels until the counterparty accepts the channel.
+  optional uint32 confirmations_required = 10;
+
+  // The current number of confirmations on the funding transaction.
+  optional uint32 confirmations = 11;
+
+  // Is `true` if the channel was initiated (and therefore funded) by us.
+  bool is_outbound = 12;
+
+  // Is `true` if both parties have exchanged `channel_ready` messages, and the channel is
+  // not currently being shut down. Both parties exchange `channel_ready` messages upon
+  // independently verifying that the required confirmations count provided by
+  // `confirmations_required` has been reached.
+  bool is_channel_ready = 13;
+
+  // Is `true` if the channel (a) `channel_ready` messages have been exchanged, (b) the
+  // peer is connected, and (c) the channel is not currently negotiating shutdown.
+  //
+  // This is a strict superset of `is_channel_ready`.
+  bool is_usable = 14;
+
+  // Is `true` if this channel is (or will be) publicly-announced
+  bool is_public = 15;
+
+  // Set of configurable parameters set by self that affect channel operation.
+  ChannelConfig channel_config = 16;
+
+  // The available outbound capacity for sending a single HTLC to the remote peer. This is
+  // similar to `outbound_capacity_msat` but it may be further restricted by
+  // the current state and per-HTLC limit(s). This is intended for use when routing, allowing us
+  // to use a limit as close as possible to the HTLC limit we can currently send.
+  uint64 next_outbound_htlc_limit_msat = 17;
+
+  // The minimum value for sending a single HTLC to the remote peer. This is the equivalent of
+  // `next_outbound_htlc_limit_msat` but represents a lower-bound, rather than
+  // an upper-bound. This is intended for use when routing, allowing us to ensure we pick a
+  // route which is valid.
+  uint64 next_outbound_htlc_minimum_msat = 18;
+
+  // The number of blocks (after our commitment transaction confirms) that we will need to wait
+  // until we can claim our funds after we force-close the channel. During this time our
+  // counterparty is allowed to punish us if we broadcasted a stale state. If our counterparty
+  // force-closes the channel and broadcasts a commitment transaction we do not have to wait any
+  // time to claim our non-HTLC-encumbered funds.
+  //
+  // This value will be `None` for outbound channels until the counterparty accepts the channel.
+  optional uint32 force_close_spend_delay = 19;
+
+  // The smallest value HTLC (in msat) the remote peer will accept, for this channel.
+  //
+  // This field is only `None` before we have received either the `OpenChannel` or
+  // `AcceptChannel` message from the remote peer.
+  optional uint64 counterparty_outbound_htlc_minimum_msat = 20;
+
+  // The largest value HTLC (in msat) the remote peer currently will accept, for this channel.
+  optional uint64 counterparty_outbound_htlc_maximum_msat = 21;
+
+  // The value, in satoshis, that must always be held in the channel for our counterparty. This
+  // value ensures that if our counterparty broadcasts a revoked state, we can punish them by
+  // claiming at least this value on chain.
+  //
+  // This value is not included in `inbound_capacity_msat` as it can never be spent.
+  optional uint64 counterparty_unspendable_punishment_reserve = 22;
+
+  // Base routing fee in millisatoshis.
+  optional uint32 counterparty_forwarding_info_fee_base_msat = 23;
+
+  // Proportional fee, in millionths of a satoshi the channel will charge per transferred satoshi.
+  optional uint32 counterparty_forwarding_info_fee_proportional_millionths = 24;
+
+  // The minimum difference in CLTV expiry between an ingoing HTLC and its outgoing counterpart,
+  // such that the outgoing HTLC is forwardable to this counterparty.
+  optional uint32 counterparty_forwarding_info_cltv_expiry_delta = 25;
+}
+
+// Represent a transaction outpoint.
+message OutPoint {
+  // The referenced transaction's txid.
+  string txid = 1;
+
+  // The index of the referenced output in its transaction's vout.
+  uint32 vout = 2;
+}