lightning 5.16.6 → 5.17.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Versions
 
+## 5.17.0
+
+- `getChannels`: Add support for `is_trusted_funding` and `other_ids`
+- `getClosedChannels`: Add support for `other_ids`
+- `getEphemeralChannelIds`: Add method to get other channel ids
+- `openChannels`: Add support for `is_trusted_funding` for instant opening
+- `subscribeToChannels`: Add support for `is_trusted_funding`, `other_ids`
+- `subscribeToOpenRequests`: Add support for `is_trusted_funding`
+
 ## 5.16.6
 
 - `subscribeToInvoices`: Cancel subscription when there are no event listeners

package/README.md

@@ -156,6 +156,8 @@ variables set:
     channels on the node.
 - [getConnectedWatchtowers](https://github.com/alexbosworth/ln-service#getconnectedwatchtowers):
     List watchtowers that were added
+- [getEphemeralChannelIds](https://github.com/alexbosworth/ln-service#getephemeralchannelids):
+    List other channel ids for channels
 - [getFailedPayments](https://github.com/alexbosworth/ln-service#getfailedpayments): List out
     past payments that failed.
 - [getFeeRates](https://github.com/alexbosworth/ln-service#getfeerates): List routing fee rates

package/bolt00/mtokens_amount.js

@@ -1,3 +1,4 @@
+const isNumber = n => !isNaN(n);
 const tokensAsMtokens = tokens => (BigInt(tokens) * BigInt(1e3)).toString();
 
 /** Derive millitokens from tokens and mtokens
@@ -20,6 +21,10 @@ module.exports = ({mtokens, tokens}) => {
     return {};
   }
 
+  if (!mtokens && !isNumber(tokens)) {
+    throw new Error('ExpectedEitherTokensNumberOrMtokensStringForAmountValue');
+  }
+
   // Exit early when there is only tokens set
   if (!mtokens) {
     return {mtokens: tokensAsMtokens(tokens)};

package/grpc/protos/lightning.proto

@@ -570,6 +570,13 @@ service Lightning {
     */
     rpc SubscribeCustomMessages (SubscribeCustomMessagesRequest)
         returns (stream CustomMessage);
+
+    /* lncli: `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).
+    */
+    rpc ListAliases (ListAliasesRequest) returns (ListAliasesResponse);
 }
 
 message SubscribeCustomMessagesRequest {
@@ -915,6 +922,14 @@ message ChannelAcceptRequest {
 
     // The commitment type the initiator wishes to use for the proposed channel.
     CommitmentType commitment_type = 14;
+
+    // Whether the initiator wants to open a zero-conf channel via the channel
+    // type.
+    bool wants_zero_conf = 15;
+
+    // Whether the initiator wants to use the scid-alias channel type. This is
+    // separate from the feature bit.
+    bool wants_scid_alias = 16;
 }
 
 message ChannelAcceptResponse {
@@ -975,6 +990,13 @@ message ChannelAcceptResponse {
     The number of confirmations we require before we consider the channel open.
     */
     uint32 min_accept_depth = 10;
+
+    /*
+    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.
+    */
+    bool zero_conf = 11;
 }
 
 message ChannelPoint {
@@ -1458,6 +1480,18 @@ message Channel {
 
     // List constraints for the remote node.
     ChannelConstraints remote_constraints = 30;
+
+    /*
+    This lists out the set of alias short channel ids that exist for a channel.
+    This may be empty.
+    */
+    repeated uint64 alias_scids = 31;
+
+    // Whether or not this is a zero-conf channel.
+    bool zero_conf = 32;
+
+    // This is the confirmed / on-chain zero-conf SCID.
+    uint64 zero_conf_confirmed_scid = 33;
 }
 
 message ListChannelsRequest {
@@ -1477,6 +1511,22 @@ message ListChannelsResponse {
     repeated Channel channels = 11;
 }
 
+message AliasMap {
+    /*
+    For non-zero-conf channels, this is the confirmed SCID. Otherwise, this is
+    the first assigned "base" alias.
+    */
+    uint64 base_scid = 1;
+
+    // The set of all aliases stored for the base SCID.
+    repeated uint64 aliases = 2;
+}
+message ListAliasesRequest {
+}
+message ListAliasesResponse {
+    repeated AliasMap alias_maps = 1;
+}
+
 enum Initiator {
     INITIATOR_UNKNOWN = 0;
     INITIATOR_LOCAL = 1;
@@ -1541,6 +1591,15 @@ message ChannelCloseSummary {
     Initiator close_initiator = 12;
 
     repeated Resolution resolutions = 13;
+
+    /*
+    This lists out the set of alias short channel ids that existed for the
+    closed channel. This may be empty.
+    */
+    repeated uint64 alias_scids = 14;
+
+    //  The confirmed SCID for a zero-conf channel.
+    uint64 zero_conf_confirmed_scid = 15 [jstype = JS_STRING];
 }
 
 enum ResolutionType {
@@ -2097,6 +2156,17 @@ message OpenChannelRequest {
     the remote peer supports explicit channel negotiation.
     */
     CommitmentType commitment_type = 18;
+
+    /*
+    If this is true, then a zero-conf channel open will be attempted.
+    */
+    bool zero_conf = 19;
+
+    /*
+    If this is true, then an option-scid-alias channel-type open will be
+    attempted.
+    */
+    bool scid_alias = 20;
 }
 message OpenStatusUpdate {
     oneof update {

package/grpc/protos/signer.proto

@@ -320,7 +320,10 @@ message InputScriptResp {
 }
 
 message SignMessageReq {
-    // The message to be signed.
+    /*
+    The message to be signed. When using REST, this field must be encoded as
+    base64.
+    */
     bytes msg = 1;
 
     // The key locator that identifies which key to use for signing.
@@ -331,9 +334,21 @@ message SignMessageReq {
 
     /*
     Use the compact (pubkey recoverable) format instead of the raw lnwire
-    format.
+    format. This option cannot be used with Schnorr signatures.
     */
     bool compact_sig = 4;
+
+    /*
+    Use Schnorr signature. This option cannot be used with compact format.
+    */
+    bool schnorr_sig = 5;
+
+    /*
+    The optional Taproot tweak bytes to apply to the private key before creating
+    a Schnorr signature. The private key is tweaked as described in BIP-341:
+    privKey + h_tapTweak(internalKey || tapTweak)
+    */
+    bytes schnorr_sig_tap_tweak = 6;
 }
 message SignMessageResp {
     /*
@@ -343,17 +358,28 @@ message SignMessageResp {
 }
 
 message VerifyMessageReq {
-    // The message over which the signature is to be verified.
+    // The message over which the signature is to be verified. When using
+    // REST, this field must be encoded as base64.
     bytes msg = 1;
 
     /*
     The fixed-size LN wire encoded signature to be verified over the given
-    message.
+    message. When using REST, this field must be encoded as base64.
     */
     bytes signature = 2;
 
-    // The public key the signature has to be valid for.
+    /*
+    The public key the signature has to be valid for. When using REST, this
+    field must be encoded as base64. If the is_schnorr_sig option is true, then
+    the public key is expected to be in the 32-byte x-only serialization
+    according to BIP-340.
+    */
     bytes pubkey = 3;
+
+    /*
+    Specifies if the signature is a Schnorr signature.
+    */
+    bool is_schnorr_sig = 4;
 }
 message VerifyMessageResp {
     // Whether the signature was valid over the given message.

package/index.js

@@ -41,6 +41,7 @@ const {getChannelBalance} = require('./lnd_methods');
 const {getChannels} = require('./lnd_methods');
 const {getClosedChannels} = require('./lnd_methods');
 const {getConnectedWatchtowers} = require('./lnd_methods');
+const {getEphemeralChannelIds} = require('./lnd_methods');
 const {getFailedPayments} = require('./lnd_methods');
 const {getFeeRates} = require('./lnd_methods');
 const {getForwardingConfidence} = require('./lnd_methods');
@@ -183,11 +184,12 @@ module.exports = {
   getChainFeeEstimate,
   getChainFeeRate,
   getChainTransactions,
-  getChannelBalance,
   getChannel,
+  getChannelBalance,
   getChannels,
   getClosedChannels,
   getConnectedWatchtowers,
+  getEphemeralChannelIds,
   getFailedPayments,
   getFeeRates,
   getForwardingConfidence,

package/lnd_methods/index.js

@@ -39,6 +39,7 @@ const {getChannelBalance} = require('./offchain');
 const {getChannels} = require('./offchain');
 const {getClosedChannels} = require('./offchain');
 const {getConnectedWatchtowers} = require('./offchain');
+const {getEphemeralChannelIds} = require('./offchain');
 const {getFailedPayments} = require('./offchain');
 const {getFeeRates} = require('./offchain');
 const {getForwardingConfidence} = require('./offchain');
@@ -182,6 +183,7 @@ module.exports = {
   getChannels,
   getClosedChannels,
   getConnectedWatchtowers,
+  getEphemeralChannelIds,
   getFailedPayments,
   getFeeRates,
   getForwardingConfidence,

package/lnd_methods/info/get_network_graph.d.ts

@@ -8,7 +8,7 @@ export type GetNetworkGraphResult = {
     /** Standard Format Channel Id */
     id: string;
     policies: {
-      /** Bae Fee Millitokens */
+      /** Base Fee Millitokens */
       base_fee_mtokens?: string;
       /** CLTV Height Delta */
       cltv_delta?: number;

package/lnd_methods/macaroon/methods.json

@@ -157,6 +157,10 @@
     "methods": ["ListTowers", "Policy", "Stats"],
     "type": "tower_client"
   },
+  "getEphemeralChannelIds": {
+    "method": "ListAliases",
+    "type": "default"
+  },
   "getFailedPayments": {
     "method": "ListPayments",
     "type": "default"

package/lnd_methods/offchain/get_channels.js

@@ -15,6 +15,8 @@ const type = 'default';
   `in_channel`, `in_payment`, `is_forward`, `out_channel`, `out_payment`,
   `payment` are not supported on LND 0.11.1 and below
 
+  `is_trusted_funding` is not supported on LND 0.15.0 and below
+
   {
     [is_active]: <Limit Results To Only Active Channels Bool> // false
     [is_offline]: <Limit Results To Only Offline Channels Bool> // false
@@ -38,6 +40,7 @@ const type = 'default';
       is_opening: <Channel Is Opening Bool>
       is_partner_initiated: <Channel Partner Opened Channel Bool>
       is_private: <Channel Is Private Bool>
+      [is_trusted_funding]: <Funding Output is Trusted Bool>
       local_balance: <Local Balance Tokens Number>
       [local_csv]: <Local CSV Blocks Delay Number>
       [local_dust]: <Local Non-Enforceable Amount Tokens Number>
@@ -46,6 +49,7 @@ const type = 'default';
       [local_max_pending_mtokens]: <Local Maximum Pending Millitokens String>
       [local_min_htlc_mtokens]: <Local Minimum HTLC Millitokens String>
       local_reserve: <Local Reserved Tokens Number>
+      other_ids: [<Other Channel Id String>]
       partner_public_key: <Channel Partner Public Key String>
       past_states: <Total Count of Past Channel States Number>
       pending_payments: [{

package/lnd_methods/offchain/get_closed_channels.js

@@ -17,6 +17,8 @@ const outpointSeparator = ':';
 
   Requires `offchain:read` permission
 
+  `other_ids is not supported on LND 0.15.0 and below
+
   {
     [is_breach_close]: <Only Return Breach Close Channels Bool>
     [is_cooperative_close]: <Only Return Cooperative Close Channels Bool>
@@ -54,6 +56,7 @@ const outpointSeparator = ':';
       [is_partner_closed]: <Channel Was Closed By Channel Peer Bool>
       [is_partner_initiated]: <Channel Was Initiated By Channel Peer Bool>
       is_remote_force_close: <Is Remote Force Close Bool>
+      other_ids: [<Other Channel Id String>]
       partner_public_key: <Partner Public Key Hex String>
       transaction_id: <Channel Funding Transaction Id Hex String>
       transaction_vout: <Channel Funding Output Index Number>
@@ -101,6 +104,10 @@ module.exports = (args, cbk) => {
       // Map channels
       mapChannels: ['getClosedChannels', ({getClosedChannels}, cbk) => {
         return asyncMapSeries(getClosedChannels, (chan, cbk) => {
+          if (!isArray(chan.alias_scids)) {
+            return cbk([503, 'ExpectedArrayOfAliasShortChannelIds']);
+          }
+
           if (!chan.capacity) {
             return cbk([503, 'ExpectedCloseChannelCapacity']);
           }
@@ -133,6 +140,10 @@ module.exports = (args, cbk) => {
             return cbk([503, 'ExpectedFinalTimeLockedBalanceForClosedChan']);
           }
 
+          const otherIds = chan.alias_scids
+            .filter(n => n !== chan.zero_conf_confirmed_scid)
+            .map(number => chanFormat({number}));
+
           const closer = chan.close_initiator;
           const finalTimeLock = Number(chan.time_locked_balance);
           const hasCloseTx = chan.closing_tx_hash !== emptyTxId;
@@ -141,11 +152,14 @@ module.exports = (args, cbk) => {
           let isPartnerClosed;
           let isPartnerInitiated;
           const [txId, vout] = chan.channel_point.split(outpointSeparator);
+          const zeroConfId = chan.zero_conf_confirmed_scid;
 
-          const chanId = !hasId ? null : chanFormat({number: chan.chan_id});
           const closeTxId = !hasCloseTx ? undefined : chan.closing_tx_hash;
           const isLocalCooperativeClose = closer === 'INITIATOR_LOCAL';
           const isRemoteCooperativeClose = closer === 'INITIATOR_REMOTE';
+          const number = !!Number(zeroConfId) ? zeroConfId : chan.chan_id;
+
+          const chanId = !hasId ? null : chanFormat({number});
 
           // Try and determine if the channel was opened by our peer
           if (chan.open_initiator === 'INITIATOR_LOCAL') {
@@ -197,6 +211,7 @@ module.exports = (args, cbk) => {
             is_partner_closed: isPartnerClosed,
             is_partner_initiated: isPartnerInitiated,
             is_remote_force_close: chan.close_type === 'REMOTE_FORCE_CLOSE',
+            other_ids: otherIds.map(n => n.channel),
             partner_public_key: chan.remote_pubkey,
             transaction_id: txId,
             transaction_vout: Number(vout),

package/lnd_methods/offchain/get_ephemeral_channel_ids.js

@@ -0,0 +1,86 @@
+const asyncAuto = require('async/auto');
+const {chanFormat} = require('bolt07');
+const {returnResult} = require('asyncjs-util');
+
+const {isLnd} = require('./../../lnd_requests');
+
+const {isArray} = Array;
+const method = 'listAliases';
+const notSupported = /unknown/;
+const type = 'default';
+
+/** Get ephemeral channel ids
+
+  Requires `offchain:read` permission
+
+  This method is not supported on LND 0.15.0 and below
+
+  {
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    channels: [{
+      other_ids: [<Channel Identifier String>]
+      reference_id: <Top Level Channel Identifier String>
+    }]
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isLnd({method, type, lnd: args.lnd})) {
+          return cbk([400, 'ExpectedAuthenticatedLndToGetChannelIds']);
+        }
+
+        return cbk();
+      },
+
+      // Get the list of channel ids
+      getChannelIds: ['validate', ({}, cbk) => {
+        return args.lnd[type][method]({}, (err, res) => {
+          if (!!err && notSupported.test(err.details)) {
+            return cbk([501, 'ListAliasesMethodNotSupported']);
+          }
+
+          if (!!err) {
+            return cbk([503, 'UnexpectedGetChannelIdsError', {err}]);
+          }
+
+          if (!res || !isArray(res.alias_maps)) {
+            return cbk([503, 'ExpectedChannelMapsArray']);
+          }
+
+          try {
+            const channels = res.alias_maps.map(map => {
+              if (!isArray(map.aliases)) {
+                throw new Error('ExpectedArrayOfAliasesInAliasMap');
+              }
+
+              if (!map.base_scid) {
+                throw new Error('ExpectedBaseScidInAliasMap');
+              }
+
+              const otherIds = map.aliases
+                .filter(n => n !== map.base_scid)
+                .map(number => chanFormat({number}).channel);
+
+              return {
+                other_ids: otherIds,
+                reference_id: chanFormat({number: map.base_scid}).channel,
+              };
+            });
+
+            return cbk(null, {channels});
+          } catch (err) {
+            return cbk([503, err.message]);
+          }
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'getChannelIds'}, cbk));
+  });
+};

package/lnd_methods/offchain/index.js

@@ -15,6 +15,7 @@ const getChannelBalance = require('./get_channel_balance');
 const getChannels = require('./get_channels');
 const getClosedChannels = require('./get_closed_channels');
 const getConnectedWatchtowers = require('./get_connected_watchtowers');
+const getEphemeralChannelIds = require('./get_ephemeral_channel_ids');
 const getFailedPayments = require('./get_failed_payments');
 const getFeeRates = require('./get_fee_rates');
 const getForwardingConfidence = require('./get_forwarding_confidence');
@@ -71,6 +72,7 @@ module.exports = {
   getChannels,
   getClosedChannels,
   getConnectedWatchtowers,
+  getEphemeralChannelIds,
   getFailedPayments,
   getFeeRates,
   getForwardingConfidence,

package/lnd_methods/offchain/subscribe_to_channels.js

@@ -29,6 +29,8 @@ const updateOpening = 'pending_open_channel';
     lnd: <Authenticated LND API Object>
   }
 
+  `is_trusted_funding`, `other_ids` are not supported on LND 0.15.0 and below
+
   @throws
   <Error>
 
@@ -69,6 +71,7 @@ const updateOpening = 'pending_open_channel';
     is_partner_closed: <Channel Was Closed By Channel Peer Bool>
     is_partner_initiated: <Channel Was Initiated By Channel Peer Bool>
     is_remote_force_close: <Is Remote Force Close Bool>
+    other_ids: [<Other Channel Id String>]
     partner_public_key: <Partner Public Key Hex String>
     transaction_id: <Channel Funding Transaction Id Hex String>
     transaction_vout: <Channel Funding Output Index Number>
@@ -87,6 +90,7 @@ const updateOpening = 'pending_open_channel';
     is_opening: <Channel Is Opening Bool>
     is_partner_initiated: <Channel Partner Opened Channel Bool>
     is_private: <Channel Is Private Bool>
+    [is_trusted_funding]: <Funding Output is Trusted Bool>
     local_balance: <Local Balance Tokens Number>
     local_given: <Local Initially Pushed Tokens Number>
     local_reserve: <Local Reserved Tokens Number>

package/lnd_methods/offchain/subscribe_to_open_requests.js

@@ -19,6 +19,8 @@ const type = 'default';
 
   LND 0.11.1 and below do not support `accept` or `reject` arguments
 
+  LND 0.15.0 and below do not support `is_trusted_funding`
+
   {
     lnd: <Authenticated LND API Object>
   }
@@ -33,6 +35,7 @@ const type = 'default';
   {
     accept: <Accept Request Function> ({
       [cooperative_close_address]: <Restrict Coop Close To Address String>
+      [is_trusted_funding]: <Accept Funding as Trusted Bool>
       [min_confirmations]: <Required Confirmations Before Channel Open Number>
       [remote_csv]: <Peer Unilateral Balance Output CSV Delay Number>
       [remote_reserve]: <Minimum Tokens Peer Must Keep On Their Side Number>
@@ -46,6 +49,7 @@ const type = 'default';
     csv_delay: <CSV Delay Blocks Number>
     id: <Request Id Hex String>
     is_private: <Incoming Channel Is Private Bool>
+    is_trusted_funding: <Request Immediate Trusted Funding Bool>
     local_balance: <Channel Local Tokens Balance Number>
     local_reserve: <Channel Local Reserve Tokens Number>
     max_pending_mtokens: <Maximum Millitokens Pending In Channel String>
@@ -94,6 +98,7 @@ module.exports = ({lnd}) => {
             accept: true,
             csv_delay: params.remote_csv || undefined,
             in_flight_max_msat: params.remote_max_pending_mtokens || undefined,
+            zero_conf: params.is_trusted_funding || undefined,
             max_htlc_count: params.remote_max_htlcs || undefined,
             min_accept_depth: params.min_confirmations || undefined,
             min_htlc_in: params.remote_min_htlc_mtokens || undefined,
@@ -108,6 +113,7 @@ module.exports = ({lnd}) => {
         csv_delay: request.csv_delay,
         id: request.id,
         is_private: request.is_private,
+        is_trusted_funding: request.is_trusted_funding,
         local_balance: request.local_balance,
         local_reserve: request.local_reserve,
         max_pending_mtokens: request.max_pending_mtokens,

package/lnd_methods/onchain/open_channels.js

@@ -32,12 +32,17 @@ const type = 'default';
   Use `is_avoiding_broadcast` only when self-publishing the raw transaction
   after the funding step.
 
+  `is_trusted_funding` is not supported on LND 0.15.0 and below and requires
+  `--protocol.option-scid-alias` and `--protocol.zero-conf` set on both sides
+  as well as a channel open request listener to accept the trusted funding.
+
   {
     channels: [{
       capacity: <Channel Capacity Tokens Number>
       [cooperative_close_address]: <Restrict Coop Close To Address String>
       [give_tokens]: <Tokens to Gift To Partner Number> // Defaults to zero
       [is_private]: <Channel is Private Bool> // Defaults to false
+      [is_trusted_funding]: <Peer Should Avoid Waiting For Confirmation Bool>
       [min_htlc_mtokens]: <Minimum HTLC Millitokens String>
       [partner_csv_delay]: <Peer Output CSV Delay Number>
       partner_public_key: <Public Key Hex String>
@@ -91,6 +96,7 @@ module.exports = (args, cbk) => {
           cooperative_close_address: channel.cooperative_close_address,
           give_tokens: channel.give_tokens,
           is_private: channel.is_private,
+          is_trusted_funding: channel.is_trusted_funding,
           min_htlc_mtokens: channel.min_htlc_mtokens,
           partner_public_key: channel.partner_public_key,
           partner_csv_delay: channel.partner_csv_delay,
@@ -107,6 +113,7 @@ module.exports = (args, cbk) => {
 
           const channelOpen = args.lnd[type][method]({
             close_address: channel.cooperative_close_address || undefined,
+            commitment_type: channel.is_trusted_funding ? 'ANCHORS' : undefined,
             funding_shim: {
               psbt_shim: {
                 no_publish: !!isSelfPublish || !channel.id.equals(lastChannel),
@@ -119,6 +126,8 @@ module.exports = (args, cbk) => {
             private: !!channel.is_private,
             push_sat: channel.give_tokens || undefined,
             remote_csv_delay: channel.partner_csv_delay || undefined,
+            scid_alias: channel.is_trusted_funding && channel.is_private,
+            zero_conf: channel.is_trusted_funding || undefined,
           });
 
           const done = (err, res) => {

package/lnd_responses/channel_accept_as_open_request.js

@@ -23,6 +23,7 @@ const weightPerVByte = 4;
     node_pubkey: <Peer Public Key Bytes Buffer Object>
     pending_chan_id: <Temporary Pending Id Bytes Buffer Object>
     push_amt: <Gifted Millitokens From Peer String>
+    wants_zero_conf: <Request Is Trusted Funding Bool>
   }
 
   @throws
@@ -36,6 +37,7 @@ const weightPerVByte = 4;
     csv_delay: <CSV Delay Blocks Number>
     id: <Request Id Hex String>
     is_private: <Incoming Channel Is Private Bool>
+    is_trusted_funding: <Accept Funding as Trusted Bool>
     local_balance: <Channel Local Tokens Balance Number>
     local_reserve: <Channel Local Reserve Tokens Number>
     max_pending_mtokens: <Maximum Millitokens Pending In Channel String>
@@ -115,6 +117,7 @@ module.exports = data => {
     csv_delay: data.csv_delay,
     id: bufferAsHex(data.pending_chan_id),
     is_private: !(data.channel_flags & privateChannel),
+    is_trusted_funding: !!data.wants_zero_conf,
     local_balance: millitokensAsTokens(data.push_amt),
     local_reserve: Number(data.channel_reserve),
     max_pending_mtokens: data.max_value_in_flight,

package/lnd_responses/rpc_channel_as_channel.js

@@ -12,6 +12,7 @@ const outpointDelimiter = ':';
 
   {
     active: <Channel Is Active Bool>
+    alias_scids: [<Channel Id Number String>]
     capacity: <Capacity Tokens String>
     chan_id: <Numeric Format Channel String>
     channel_point: <Channel Funding Outpoint String>
@@ -60,6 +61,7 @@ const outpointDelimiter = ':';
     total_satoshis_sent: <Total Tokens Transferred Outbound String>
     unsettled_balance: <Balance In Transaction Tokens String>
     uptime: <Channel Internal Monitoring Channel Active Seconds Number>
+    zero_conf_confirmed_scid: <Trusted Channel Confirmed Id Number String>
   }
 
   @throws
@@ -78,6 +80,7 @@ const outpointDelimiter = ':';
     is_opening: <Channel Is Opening Bool>
     is_partner_initiated: <Channel Partner Opened Channel Bool>
     is_private: <Channel Is Private Bool>
+    [is_trusted_funding]: <Funding Output is Trusted Bool>
     local_balance: <Local Balance Tokens Number>
     local_csv: <Local CSV Blocks Delay Number>
     local_dust: <Remote Non-Enforceable Amount Tokens Number>
@@ -86,6 +89,7 @@ const outpointDelimiter = ':';
     local_max_pending_mtokens: <Local Maximum Pending Millitokens String>
     local_min_htlc_mtokens: <Local Minimum HTLC Millitokens String>
     local_reserve: <Local Reserved Tokens Number>
+    other_ids: [<Other Channel Id String>]
     partner_public_key: <Channel Partner Public Key String>
     past_states: <Total Count of Past States Number>
     pending_payments: [{
@@ -122,6 +126,10 @@ module.exports = args => {
     throw new Error('ExpectedChannelActiveStateInChannelMessage');
   }
 
+  if (!isArray(args.alias_scids)) {
+    throw new Error('ExpectedArrayOfAliasShortChannelIdsInChannelMessage');
+  }
+
   if (args.capacity === undefined) {
     throw new Error('ExpectedChannelCapacityInChannelMessage');
   }
@@ -210,21 +218,28 @@ module.exports = args => {
   const pushAmount = Number(args.push_amount_sat) || Number();
   const [transactionId, vout] = args.channel_point.split(outpointDelimiter);
   const uptime = Number(args.uptime) * msPerSec;
+  const zeroConfRealId = args.zero_conf_confirmed_scid;
 
+  const channelId = !!Number(zeroConfRealId) ? zeroConfRealId : args.chan_id;
   const downtime = Number(args.lifetime) * msPerSec - uptime;
 
+  const otherIds = args.alias_scids
+    .filter(n => n !== channelId)
+    .map(number => chanFormat({number}));
+
   return {
     capacity: Number(args.capacity),
     commit_transaction_fee: Number(args.commit_fee),
     commit_transaction_weight: commitWeight,
     cooperative_close_address: args.close_address || undefined,
     cooperative_close_delay_height: height,
-    id: chanFormat({number: args.chan_id}).channel,
+    id: chanFormat({number: channelId}).channel,
     is_active: args.active,
     is_closing: false,
     is_opening: false,
     is_partner_initiated: !args.initiator,
     is_private: args.private,
+    is_trusted_funding: args.zero_conf || undefined,
     local_balance: Number(args.local_balance),
     local_csv: own.csv_delay,
     local_dust: Number(own.dust_limit_sat),
@@ -233,6 +248,7 @@ module.exports = args => {
     local_max_pending_mtokens: own.max_pending_amt_msat,
     local_min_htlc_mtokens: own.min_htlc_msat,
     local_reserve: Number(own.chan_reserve_sat),
+    other_ids: otherIds.map(n => n.channel),
     partner_public_key: args.remote_pubkey,
     past_states: Number(args.num_updates),
     pending_payments: args.pending_htlcs.map(rpcHtlcAsPayment),

package/lnd_responses/rpc_closed_channel_as_closed.js

@@ -9,6 +9,7 @@ const emptyTxId = Buffer.alloc(32).toString('hex');
 const fundingCanceled = 'FUNDING_CANCELED';
 const initiatorLocal = 'INITIATOR_LOCAL';
 const initiatorRemote = 'INITIATOR_REMOTE';
+const {isArray} = Array;
 const local = 'LOCAL';
 const localForceClose = 'LOCAL_FORCE_CLOSE';
 const outpointSeparator = ':';
@@ -18,6 +19,7 @@ const remoteForceClose = 'REMOTE_FORCE_CLOSE';
 /** RPC closed local channel as close details
 
   {
+    alias_scids: [<Channel Id Number String>]
     capacity: <Channel Capacity Tokens String>
     chan_id: <Numeric Format Channel Id String>
     channel_point: <Channel Funding Outpoint String>
@@ -39,6 +41,7 @@ const remoteForceClose = 'REMOTE_FORCE_CLOSE';
     }]
     settled_balance: <Channel Close Settle Balance Tokens String>
     time_locked_balance: <Channel Time Locked Balance Tokens String>
+    zero_conf_confirmed_scid: <Trusted Channel Confirmed Id Number String>
   }
 
   @throws
@@ -71,6 +74,7 @@ const remoteForceClose = 'REMOTE_FORCE_CLOSE';
     [is_partner_closed]: <Channel Was Closed By Channel Peer Bool>
     [is_partner_initiated]: <Channel Was Initiated By Channel Peer Bool>
     is_remote_force_close: <Is Remote Force Close Bool>
+    other_ids: [<Other Channel Id String>]
     partner_public_key: <Partner Public Key Hex String>
     transaction_id: <Channel Funding Transaction Id Hex String>
     transaction_vout: <Channel Funding Output Index Number>
@@ -81,6 +85,10 @@ module.exports = chan => {
     throw new Error('ExpectedChannelCloseDetailsToDeriveClosedChannel');
   }
 
+  if (!isArray(chan.alias_scids)) {
+    throw new Error('ExpectedArrayOfAliasShortChannelIdsInClosedChannel');
+  }
+
   if (!chan.capacity) {
     throw new Error('ExpectedCloseChannelCapacity');
   }
@@ -113,6 +121,10 @@ module.exports = chan => {
     throw new Error('ExpectedFinalTimeLockedBalanceForClosedChan');
   }
 
+  const otherIds = chan.alias_scids
+    .filter(n => n !== chan.zero_conf_confirmed_scid)
+    .map(number => chanFormat({number}));
+
   const closer = chan.close_initiator;
   const finalTimeLock = Number(chan.time_locked_balance);
   const hasCloseTx = chan.closing_tx_hash !== emptyTxId;
@@ -121,11 +133,14 @@ module.exports = chan => {
   let isPartnerClosed;
   let isPartnerInitiated;
   const [txId, vout] = chan.channel_point.split(outpointSeparator);
+  const zeroConfId = chan.zero_conf_confirmed_scid;
 
-  const chanId = !hasId ? null : chanFormat({number: chan.chan_id});
   const closeTxId = !hasCloseTx ? undefined : chan.closing_tx_hash;
   const isLocalCooperativeClose = closer === initiatorLocal;
   const isRemoteCooperativeClose = closer === initiatorRemote;
+  const number = !!Number(zeroConfId) ? zeroConfId : chan.chan_id;
+
+  const chanId = !hasId ? null : chanFormat({number});
 
   // Try and determine if the channel was opened by our peer
   if (chan.open_initiator === local) {
@@ -170,6 +185,7 @@ module.exports = chan => {
     is_partner_closed: isPartnerClosed,
     is_partner_initiated: isPartnerInitiated,
     is_remote_force_close: chan.close_type === remoteForceClose,
+    other_ids: otherIds.map(n => n.channel),
     partner_public_key: chan.remote_pubkey,
     transaction_id: txId,
     transaction_vout: Number(vout),

package/package.json

@@ -7,10 +7,10 @@
     "url": "https://github.com/alexbosworth/lightning/issues"
   },
   "dependencies": {
-    "@grpc/grpc-js": "1.6.8",
-    "@grpc/proto-loader": "0.7.0",
+    "@grpc/grpc-js": "1.6.10",
+    "@grpc/proto-loader": "0.7.2",
     "@types/express": "4.17.13",
-    "@types/node": "18.6.3",
+    "@types/node": "18.7.8",
     "@types/request": "2.48.8",
     "@types/ws": "8.5.3",
     "async": "3.2.4",
@@ -26,7 +26,7 @@
     "invoices": "2.1.0",
     "psbt": "2.7.1",
     "tiny-secp256k1": "2.2.1",
-    "type-fest": "2.18.0"
+    "type-fest": "2.18.1"
   },
   "description": "Lightning Network client library",
   "devDependencies": {
@@ -59,5 +59,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "5.16.6"
+  "version": "5.17.0"
 }

package/test/bolt00/test_mtokens_amount.js

@@ -8,11 +8,21 @@ const tests = [
     description: 'Default mtokens is undefined',
     expected: {},
   },
+  {
+    args: {tokens: 0},
+    description: 'Tokens can be zero',
+    expected: {mtokens: '0'},
+  },
   {
     args: {tokens: 1},
     description: 'Tokens are converted to mtokens',
     expected: {mtokens: '1000'},
   },
+  {
+    args: {tokens: 'invalid number'},
+    description: 'Tokens must be a valid number',
+    error: 'ExpectedEitherTokensNumberOrMtokensStringForAmountValue',
+  },
   {
     args: {mtokens: '1000'},
     description: 'Mtokens are returned',

package/test/lnd_methods/offchain/test_get_channels.js

@@ -15,6 +15,7 @@ const makeExpected = overrides => {
     is_opening: false,
     is_partner_initiated: false,
     is_private: true,
+    is_trusted_funding: undefined,
     local_balance: 1,
     local_csv: 1,
     local_dust: 1,
@@ -23,6 +24,7 @@ const makeExpected = overrides => {
     local_max_htlcs: 1,
     local_max_pending_mtokens: '1',
     local_reserve: 1,
+    other_ids: [],
     partner_public_key: 'b',
     past_states: 1,
     pending_payments: [{
@@ -62,6 +64,7 @@ const makeExpected = overrides => {
 const makeLnd = overrides => {
   const channel = {
     active: true,
+    alias_scids: [],
     capacity: 1,
     chan_id: '1',
     channel_point: '00:1',

package/test/lnd_methods/offchain/test_get_closed_channels.js

@@ -4,6 +4,7 @@ const {getClosedChannels} = require('./../../../');
 
 const makeLnd = (err, override, response) => {
   const channel = {
+    alias_scids: [],
     capacity: '1',
     chan_id: '1',
     channel_point: '00:1',
@@ -56,6 +57,7 @@ const makeExpectedChannel = ({override}) => {
     is_partner_closed: true,
     is_partner_initiated: false,
     is_remote_force_close: false,
+    other_ids: [],
     partner_public_key: 'b',
     transaction_id: '00',
     transaction_vout: 1,
@@ -87,6 +89,11 @@ const tests = [
     description: 'A response with channels is expected',
     error: [503, 'ExpectedChannels'],
   },
+  {
+    args: makeArgs({override: {lnd: makeLnd(null, {alias_scids: undefined})}}),
+    description: 'Alias scids are expected',
+    error: [503, 'ExpectedArrayOfAliasShortChannelIds'],
+  },
   {
     args: makeArgs({override: {lnd: makeLnd(null, {capacity: undefined})}}),
     description: 'Capacity is expected',
@@ -144,6 +151,22 @@ const tests = [
     description: 'Closed channels are returned',
     expected: {channels: [makeExpectedChannel({})]},
   },
+  {
+    args: makeArgs({
+      override: {
+        lnd: makeLnd(null, {
+          alias_scids: ['2', '3'],
+          zero_conf_confirmed_scid: '2',
+        }),
+      },
+    }),
+    description: 'Closed channels with alias scids is returned',
+    expected: {
+      channels: [
+        makeExpectedChannel({override: {id: '0x0x2', other_ids: ['0x0x3']}}),
+      ],
+    },
+  },
   {
     args: makeArgs({
       override: {lnd: makeLnd(null, {close_type: 'REMOTE_FORCE_CLOSE'})},

package/test/lnd_methods/offchain/test_get_ephemeral_channel_ids.js

@@ -0,0 +1,68 @@
+const {test} = require('@alexbosworth/tap');
+
+const {getEphemeralChannelIds} = require('./../../../lnd_methods');
+
+const makeLnd = ({err, res}) => {
+  const response = {alias_maps: [{aliases: ['1', '2'], base_scid: '1'}]};
+
+  const r = res !== undefined ? res : response;
+
+  return {default: {listAliases: ({}, cbk) => cbk(err, r)}};
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'LND object is required',
+    error: [400, 'ExpectedAuthenticatedLndToGetChannelIds'],
+  },
+  {
+    args: {lnd: makeLnd({err: {details: 'unknown'}})},
+    description: 'Not supported error is returned',
+    error: [501, 'ListAliasesMethodNotSupported'],
+  },
+  {
+    args: {lnd: makeLnd({err: 'err'})},
+    description: 'Unknown error is returned',
+    error: [503, 'UnexpectedGetChannelIdsError', {err: 'err'}],
+  },
+  {
+    args: {lnd: makeLnd({res: null})},
+    description: 'A response is expected',
+    error: [503, 'ExpectedChannelMapsArray'],
+  },
+  {
+    args: {lnd: makeLnd({res: {}})},
+    description: 'A response array is expected',
+    error: [503, 'ExpectedChannelMapsArray'],
+  },
+  {
+    args: {lnd: makeLnd({res: {alias_maps: [{}]}})},
+    description: 'Alias maps array is expected',
+    error: [503, 'ExpectedArrayOfAliasesInAliasMap'],
+  },
+  {
+    args: {lnd: makeLnd({res: {alias_maps: [{aliases: []}]}})},
+    description: 'A base scid is expected',
+    error: [503, 'ExpectedBaseScidInAliasMap'],
+  },
+  {
+    args: {lnd: makeLnd({})},
+    description: 'Channel ids are returned',
+    expected: {channels: [{other_ids: ['0x0x2'], reference_id: '0x0x1'}]},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, rejects, strictSame}) => {
+    if (!!error) {
+      await rejects(getEphemeralChannelIds(args), error, 'Got expected error');
+    } else {
+      const res = await getEphemeralChannelIds(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/lnd_methods/offchain/test_subscribe_to_channels.js

@@ -32,6 +32,7 @@ const makeLnd = ({data, err}) => {
 
           emitter.emit('data', {
             closed_channel: {
+              alias_scids: [],
               capacity: '1',
               chan_id: '1',
               channel_point: '00:0',
@@ -57,6 +58,7 @@ const makeLnd = ({data, err}) => {
           emitter.emit('data', {
             open_channel: {
               active: false,
+              alias_scids: [],
               capacity: '1',
               chan_id: '1',
               channel_point: `${Buffer.alloc(32).toString('hex')}:0`,
@@ -221,6 +223,7 @@ const tests = [
             is_partner_closed: undefined,
             is_partner_initiated: false,
             is_remote_force_close: false,
+            other_ids: [],
             partner_public_key: '000000000000000000000000000000000000000000000000000000000000000000',
             transaction_id: '00',
             transaction_vout: 0,
@@ -248,6 +251,7 @@ const tests = [
             is_opening: false,
             is_partner_initiated: false,
             is_private: false,
+            is_trusted_funding: undefined,
             local_balance: 1,
             local_csv: 1,
             local_dust: 1,
@@ -256,6 +260,7 @@ const tests = [
             local_max_pending_mtokens: '1',
             local_min_htlc_mtokens: '1',
             local_reserve: 1,
+            other_ids: [],
             partner_public_key: '000000000000000000000000000000000000000000000000000000000000000000',
             past_states: 1,
             pending_payments: [],

package/test/lnd_methods/offchain/test_subscribe_to_open_requests.js

@@ -82,6 +82,7 @@ const tests = [
             csv_delay: 1,
             id: '0000000000000000000000000000000000000000000000000000000000000000',
             is_private: true,
+            is_trusted_funding: false,
             local_balance: 1,
             local_reserve: 1,
             max_pending_mtokens: '1000',

package/test/lnd_responses/test_channel_accept_as_open_request.js

@@ -35,6 +35,7 @@ const tests = [
       csv_delay: 1,
       id: Buffer.alloc(32).toString('hex'),
       is_private: true,
+      is_trusted_funding: false,
       local_balance: 1,
       local_reserve: 1,
       max_pending_mtokens: '1000',

package/test/lnd_responses/test_rpc_channel_as_channel.js

@@ -5,6 +5,7 @@ const {rpcChannelAsChannel} = require('./../../lnd_responses');
 const makeArgs = overrides => {
   const args = {
     active: true,
+    alias_scids: [],
     capacity: '1',
     chan_id: '1',
     channel_point: '00:1',
@@ -73,6 +74,7 @@ const makeExpected = overrides => {
     is_opening: false,
     is_partner_initiated: true,
     is_private: true,
+    is_trusted_funding: undefined,
     local_balance: 1,
     local_csv: 1,
     local_dust: 1,
@@ -81,6 +83,7 @@ const makeExpected = overrides => {
     local_max_pending_mtokens: '1',
     local_min_htlc_mtokens: '1',
     local_reserve: 1,
+    other_ids: [],
     partner_public_key: '00',
     past_states: 1,
     pending_payments: [{
@@ -123,6 +126,11 @@ const tests = [
     description: 'Channel active is expected',
     error: 'ExpectedChannelActiveStateInChannelMessage',
   },
+  {
+    args: makeArgs({alias_scids: undefined}),
+    description: 'Alias scids are expected',
+    error: 'ExpectedArrayOfAliasShortChannelIdsInChannelMessage',
+  },
   {
     args: makeArgs({capacity: undefined}),
     description: 'Channel capacity is expected',
@@ -228,6 +236,11 @@ const tests = [
     description: 'RPC channel is mapped to channel',
     expected: makeExpected({}),
   },
+  {
+    args: makeArgs({alias_scids: ['2', '3'], zero_conf_confirmed_scid: '2'}),
+    description: 'RPC channel is mapped to channel with scids',
+    expected: makeExpected({id: '0x0x2', other_ids: ['0x0x3']}),
+  },
   {
     args: makeArgs({commitment_type: 'STATIC_REMOTE_KEY', initiator: true}),
     description: 'Initiated RPC channel is mapped to channel',

package/test/lnd_responses/test_rpc_closed_channel_as_closed.js

@@ -4,6 +4,7 @@ const {rpcClosedChannelAsClosed} = require('./../../lnd_responses');
 
 const makeArgs = overrides => {
   const args = {
+    alias_scids: [],
     capacity: '1',
     chan_id: '1',
     channel_point: '0102:0',
@@ -59,6 +60,7 @@ const makeExpected = overrides => {
     is_partner_closed: false,
     is_partner_initiated: undefined,
     is_remote_force_close: false,
+    other_ids: [],
     partner_public_key: Buffer.alloc(33).toString('hex'),
     transaction_id: '0102',
     transaction_vout: 0,
@@ -75,6 +77,11 @@ const tests = [
     description: 'Channel close details expected',
     error: 'ExpectedChannelCloseDetailsToDeriveClosedChannel',
   },
+  {
+    args: makeArgs({alias_scids: undefined}),
+    description: 'Alias scids are expected',
+    error: 'ExpectedArrayOfAliasShortChannelIdsInClosedChannel',
+  },
   {
     args: makeArgs({capacity: undefined}),
     description: 'Channel capacity is expected',
@@ -120,6 +127,14 @@ const tests = [
     description: 'Local channel closed mapped to closed channel',
     expected: makeExpected({}),
   },
+  {
+    args: makeArgs({
+      alias_scids: ['2', '3'],
+      zero_conf_confirmed_scid: '2',
+    }),
+    description: 'Alias scids are mapped to other ids',
+    expected: makeExpected({id: '0x0x2', other_ids: ['0x0x3']}),
+  },
   {
     args: makeArgs({
       close_initiator: 'REMOTE',