ln-service 53.17.4 → 53.19.0

package/CHANGELOG.md

@@ -1,6 +1,20 @@
 # Versions
 
-## 53.17.4
+## 53.19.0
+
+- `signBytes`: Add `type` and support for specifying `schnorr` type signing
+- `verifyBytesSignature`: Add support for verifying Schnorr signatures
+
+## 53.18.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`
+
+## 53.17.5
 
 - `signTransaction`: Add `root_hash` to support Taproot signatures with scripts
 

package/README.md

@@ -151,6 +151,7 @@ for `unlocker` methods.
 - [getChannels](#getchannels) - Get all open channels
 - [getClosedChannels](#getclosedchannels) - Get previously open channels
 - [getConnectedWatchtowers](#getconnectedwatchtowers) - Get connected towers
+- [getEphemeralChannelIds](#getephemeralchannelids) - Get other channel ids
 - [getFailedPayments](#getfailedpayments) - Get payments that were failed back
 - [getFeeRates](#getfeerates) - Get current routing fee rates
 - [getForwardingConfidence](#getforwardingconfidence) - Get pairwise confidence
@@ -1602,6 +1603,8 @@ Requires `offchain:read` permission
 `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
@@ -1625,14 +1628,16 @@ Requires `offchain:read` permission
         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>
+        [local_dust]: <Local Non-Enforceable Amount Tokens Number>
         [local_given]: <Local Initially Pushed Tokens Number>
         [local_max_htlcs]: <Local Maximum Attached HTLCs Number>
         [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: [{
@@ -1682,6 +1687,8 @@ Multiple close type flags are supported.
 
 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>
@@ -1719,6 +1726,7 @@ Requires `offchain:read` permission
         [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>
@@ -1776,6 +1784,35 @@ const {getConnectedWatchtowers} = require('ln-service');
 const {towers} = (await getConnectedWatchtowers({lnd}));
 ```
 
+### getEphemeralChannelIds
+
+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>
+      }]
+    }
+
+Example:
+
+```node
+const {getEphemeralChannelIds} = require('ln-service');
+
+// Get the list of ephemeral ids related to channels
+const {channels} = await getEphemeralChannelIds({lnd});
+```
+
 ### getFailedPayments
 
 Get failed payments made through channels.
@@ -1860,6 +1897,15 @@ Requires `offchain:read` permission
       [next]: <Next Opaque Paging Token String>
     }
 
+Example:
+
+```node
+const {getFailedPayments} = require('ln-service');
+
+// Get the list of failed payments
+const {payments} = await getFailedPayments({lnd});
+```
+
 ### getFeeRates
 
 Get a rundown on fees for channels
@@ -3550,12 +3596,17 @@ channel that was not funded.
 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>
@@ -4684,15 +4735,20 @@ await settleHodlInvoice({lnd, secret});
 
 Sign a sha256 hash of arbitrary bytes
 
+Supported signature types: `ecdsa`, `schnorr`
+
 Requires LND built with `signrpc` build tag
 
 Requires `signer:generate` permission
 
+`schnorr` signature type is not supported on LND 0.15.0 and below
+
     {
       key_family: <Key Family Number>
       key_index: <Key Index Number>
       lnd: <Authenticated LND gRPC API Object>
       preimage: <Bytes To Hash and Sign Hex Encoded String>
+      [type]: <Signature Type String>
     }
 
     @returns via cbk or Promise
@@ -5002,6 +5058,8 @@ Subscribe to channel updates
 
 Requires `offchain:read` permission
 
+`is_trusted_funding`, `other_ids` are not supported on LND 0.15.0 and below
+
     {
       lnd: <Authenticated LND API Object>
     }
@@ -5046,6 +5104,7 @@ Requires `offchain:read` permission
       [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>
@@ -5064,6 +5123,7 @@ Requires `offchain:read` permission
       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>
@@ -5452,6 +5512,8 @@ listeners to `channel_request`
 
 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>
     }
@@ -7039,10 +7101,14 @@ const isValid = (await verifyBackups({backup, channels, lnd})).is_valid;
 
 Verify signature of arbitrary bytes
 
+When passing a schnorr signature, a BIP-340 x-only public key should be given
+
 Requires LND built with `signrpc` build tag
 
 Requires `signer:read` permission
 
+Validating `schnorr` signatures is unsupported in LND 0.15.0 and below
+
     {
       lnd: <Authenticated LND API Object>
       preimage: <Message Preimage Bytes Hex Encoded String>

package/index.js

@@ -42,6 +42,7 @@ const {getChannelBalance} = require('lightning');
 const {getChannels} = require('lightning');
 const {getClosedChannels} = require('lightning');
 const {getConnectedWatchtowers} = require('lightning');
+const {getEphemeralChannelIds} = require('lightning');
 const {getFailedPayments} = require('lightning');
 const {getFeeRates} = require('lightning');
 const {getForwardingConfidence} = require('lightning');
@@ -191,6 +192,7 @@ module.exports = {
   getChannels,
   getClosedChannels,
   getConnectedWatchtowers,
+  getEphemeralChannelIds,
   getFailedPayments,
   getFeeRates,
   getForwardingConfidence,

package/package.json

@@ -10,11 +10,11 @@
     "bolt07": "1.8.2",
     "cors": "2.8.5",
     "express": "4.18.1",
-    "invoices": "2.0.7",
-    "lightning": "5.16.3",
+    "invoices": "2.1.0",
+    "lightning": "5.18.0",
     "macaroon": "3.0.4",
     "morgan": "1.10.0",
-    "ws": "8.8.0"
+    "ws": "8.8.1"
   },
   "description": "Interaction helper for your Lightning Network daemon",
   "devDependencies": {
@@ -24,14 +24,14 @@
     "asyncjs-util": "1.2.10",
     "bip32": "3.0.1",
     "bip66": "1.1.5",
-    "bitcoinjs-lib": "6.0.1",
+    "bitcoinjs-lib": "6.0.2",
     "bn.js": "5.2.1",
     "bs58check": "2.1.2",
     "ecpair": "2.0.1",
-    "ln-docker-daemons": "2.3.2",
+    "ln-docker-daemons": "2.3.3",
     "p2tr": "1.3.1",
-    "portfinder": "1.0.28",
-    "psbt": "2.6.0",
+    "portfinder": "1.0.32",
+    "psbt": "2.7.1",
     "rimraf": "3.0.2",
     "secp256k1": "4.0.3",
     "tiny-secp256k1": "2.2.1",
@@ -71,5 +71,5 @@
     "integration-test-0.12.0": "DOCKER_LND_VERSION=v0.12.0-beta npm run test",
     "test": "echo $DOCKER_LND_VERSION && tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 200 test/autopilotrpc-integration/*.js test/chainrpc-integration/*.js test/integration/*.js test/invoicesrpc-integration/*.js test/peersrpc-integration/*.js test/routerrpc-integration/*.js test/signerrpc-integration/*.js test/tower_clientrpc-integration/*.js test/tower_serverrpc-integration/*.js test/walletrpc-integration/*.js"
   },
-  "version": "53.17.4"
+  "version": "53.19.0"
 }

package/test/integration/test_get_closed_channels.js

@@ -72,11 +72,13 @@ test(`Get closed channels`, async ({end, equal}) => {
 
   equal(channels.length, [channelOpen].length, 'Channel close listed');
 
+  const spend = maxChanTokens - channel.final_local_balance;
+
   // LND 0.11.1 and below do not use anchors
   if (isAnchors) {
-    equal(maxChanTokens - channel.final_local_balance, 2810, 'Final');
+    equal([53345, 2810].includes(spend), true, 'Final');
   } else {
-    equal(maxChanTokens - channel.final_local_balance, 9050, 'Final');
+    equal(spend, 9050, 'Final');
   }
 
   equal(channel.capacity, maxChanTokens, 'Channel capacity reflected');

package/test/integration/test_get_node.js

@@ -56,8 +56,6 @@ test(`Get node`, async ({end, equal, strictSame}) => {
       });
     });
 
-    await delay(3000);
-
     const node = await getNode({lnd, public_key: id});
 
     {

package/test/integration/test_get_pending_coop.js

@@ -17,60 +17,64 @@ test(`Get pending channels`, async ({end, equal}) => {
 
   const [{generate, lnd}, target] = nodes;
 
-  const {features} = await getWalletInfo({lnd});
+  try {
+    const {features} = await getWalletInfo({lnd});
 
-  const isAnchors = !!features.find(n => n.bit === anchorsFeatureBit);
+    const isAnchors = !!features.find(n => n.bit === anchorsFeatureBit);
 
-  // Target starts a channel with control
-  const coopChan = await setupChannel({generate, give, lnd, to: target});
+    // Target starts a channel with control
+    const coopChan = await setupChannel({generate, give, lnd, to: target});
 
-  // Target closes the channel
-  const niceClose = await closeChannel({
-    lnd: target.lnd,
-    tokens_per_vbyte: defaultFee,
-    transaction_id: coopChan.transaction_id,
-    transaction_vout: coopChan.transaction_vout,
-  });
+    // Target closes the channel
+    const niceClose = await closeChannel({
+      lnd: target.lnd,
+      tokens_per_vbyte: 100,
+      transaction_id: coopChan.transaction_id,
+      transaction_vout: coopChan.transaction_vout,
+    });
 
-  // Control views their pending channels
-  const {channel} = await waitForPendingChannel({
-    lnd,
-    id: coopChan.transaction_id,
-  });
+    // Control views their pending channels
+    const {channel} = await waitForPendingChannel({
+      lnd,
+      id: coopChan.transaction_id,
+    });
 
-  if (channel.is_partner_initiated !== undefined) {
-    equal(channel.is_partner_initiated, false, 'Channel was initiated');
-  }
+    if (channel.is_partner_initiated !== undefined) {
+      equal(channel.is_partner_initiated, false, 'Channel was initiated');
+    }
 
-  // LND 0.11.1 and below do not support anchor channels
-  if (isAnchors) {
-    equal(channel.local_balance, 986530, 'Original balance');
-    equal(channel.pending_balance, 986530, 'Waiting on balance');
-  } else {
-    equal(channel.local_balance, 980950, 'Original balance');
-    equal(channel.pending_balance, 980950, 'Waiting on balance');
-  }
+    // LND 0.11.1 and below do not support anchor channels
+    if (isAnchors) {
+      equal(channel.local_balance, 986530, 'Original balance');
+      equal(channel.pending_balance, 986530, 'Waiting on balance');
+    } else {
+      equal(channel.local_balance, 980950, 'Original balance');
+      equal(channel.pending_balance, 980950, 'Waiting on balance');
+    }
 
-  equal(channel.capacity, 1000000, 'Got channel capacity');
-  equal(channel.close_transaction_id, undefined, 'No close tx id');
-  equal(channel.is_active, false, 'Ended');
-  equal(channel.is_closing, true, 'Closing');
-  equal(channel.is_opening, false, 'Not Opening');
-  equal(channel.local_reserve, 10000, 'Local reserve');
-  equal(channel.partner_public_key, target.id, 'Target public key');
-  equal(channel.pending_payments, undefined, 'No pending payments');
-  equal(channel.received, 0, 'Never received');
-  equal(channel.recovered_tokens, undefined, 'Nothing to recover in sweep');
-  equal(channel.remote_reserve, 10000, 'Remote reserve');
-  equal(channel.sent, 0, 'Never sent anything');
-  equal(channel.timelock_expiration, undefined, 'No timelock in coop mode');
-  equal(channel.transaction_fee, null, 'No transaction fee data');
-  equal(channel.transaction_id, coopChan.transaction_id, 'funding tx id');
-  equal(channel.transaction_vout, coopChan.transaction_vout, 'funding vout');
-  equal(channel.transaction_weight, null, 'No funding tx weight data');
+    equal(channel.capacity, 1000000, 'Got channel capacity');
+    equal(channel.close_transaction_id, undefined, 'No close tx id');
+    equal(channel.is_active, false, 'Ended');
+    equal(channel.is_closing, true, 'Closing');
+    equal(channel.is_opening, false, 'Not Opening');
+    equal(channel.local_reserve, 10000, 'Local reserve');
+    equal(channel.partner_public_key, target.id, 'Target public key');
+    equal(channel.pending_payments, undefined, 'No pending payments');
+    equal(channel.received, 0, 'Never received');
+    equal(channel.recovered_tokens, undefined, 'Nothing to recover in sweep');
+    equal(channel.remote_reserve, 10000, 'Remote reserve');
+    equal(channel.sent, 0, 'Never sent anything');
+    equal(channel.timelock_expiration, undefined, 'No timelock in coop mode');
+    equal(channel.transaction_fee, null, 'No transaction fee data');
+    equal(channel.transaction_id, coopChan.transaction_id, 'funding tx id');
+    equal(channel.transaction_vout, coopChan.transaction_vout, 'funding vout');
+    equal(channel.transaction_weight, null, 'No funding tx weight data');
 
-  if (!!channel.remote_balance) {
-    equal(channel.remote_balance, give, 'Opposing channel balance');
+    if (!!channel.remote_balance) {
+      equal(channel.remote_balance, give, 'Opposing channel balance');
+    }
+  } catch (err) {
+    equal(err, null, 'Expected no error');
   }
 
   await kill({});

package/test/integration/test_propose_channel.js

@@ -334,7 +334,7 @@ test(`Propose a channel with a coop delay`, async ({end, equal, ok}) => {
     });
 
     const coopCloseAddress = await createChainAddress({
-      format: 'np2wpkh',
+      format: 'p2wpkh',
       lnd: control.lnd,
     });
 

package/test/integration/test_remove_peer.js

@@ -6,7 +6,9 @@ const {addPeer} = require('./../../');
 const {getPeers} = require('./../../');
 const {removePeer} = require('./../../');
 
+const interval = 10;
 const size = 2;
+const times = 2000;
 
 // Removing peers should result in a removed peer
 test(`Remove a peer`, async ({end, equal}) => {
@@ -15,7 +17,7 @@ test(`Remove a peer`, async ({end, equal}) => {
   const [{id, lnd}, target] = nodes;
 
   try {
-    await asyncRetry({interval: 10, times: 2000}, async () => {
+    await asyncRetry({interval, times}, async () => {
       await addPeer({lnd, public_key: target.id, socket: target.socket});
     });
 
@@ -27,9 +29,15 @@ test(`Remove a peer`, async ({end, equal}) => {
 
     await removePeer({lnd, public_key: targetPeer.public_key});
 
-    const postRemovalPeers = await getPeers({lnd});
+    await asyncRetry({interval, times}, async () => {
+      const postRemovalPeers = await getPeers({lnd});
 
-    equal(postRemovalPeers.peers.length, [].length, 'Peer is removed');
+      if (!!postRemovalPeers.peers.length) {
+        throw new Error('ExpectedPeerRemoved');
+      }
+
+      equal(postRemovalPeers.peers.length, [].length, 'Peer is removed');
+    });
   } catch (err) {
     equal(err, null, 'Expected no error');
   }

package/test/integration/test_subscribe_to_channels.js

@@ -148,7 +148,9 @@ test('Subscribe to channels', async ({end, equal, fail}) => {
   const closeEvent = channelClosed.pop();
 
   if (isAnchors) {
-    equal(closeEvent.final_local_balance, 897190, 'Close final local balance');
+    const final = closeEvent.final_local_balance;
+
+    equal([897190, 846655].includes(final), true, 'Close final local balance');
   } else {
     equal(closeEvent.final_local_balance, 890950, 'Close final local balance');
   }

package/test/integration/test_trusted_funding.js

@@ -0,0 +1,244 @@
+const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+
+const {addPeer} = require('./../../');
+const {broadcastChainTransaction} = require('./../../');
+const {closeChannel} = require('./../../');
+const {createInvoice} = require('./../../');
+const {fundPendingChannels} = require('./../../');
+const {fundPsbt} = require('./../../');
+const {getChannels} = require('./../../');
+const {getClosedChannels} = require('./../../');
+const {getEphemeralChannelIds} = require('./../../');
+const {getPendingChannels} = require('./../../');
+const {openChannels} = require('./../../');
+const {pay} = require('./../../');
+const {signPsbt} = require('./../../');
+const {subscribeToChannels} = require('./../../');
+const {subscribeToOpenRequests} = require('./../../');
+
+const capacity = 1e6;
+const interval = 10;
+const maturity = 100;
+const size = 2;
+const times = 2000;
+
+// Opening unconfirmed channels should in immediate channel opening
+test(`Open unconfirmed channels`, async ({end, equal, strictSame}) => {
+  // Unconfirmed channels are not supported on LND 0.15.0 and below
+  {
+    const {kill, nodes} = await spawnLightningCluster({});
+
+    const [{lnd}] = nodes;
+
+    try {
+      await getEphemeralChannelIds({lnd});
+    } catch (err) {
+      strictSame(err, [501, 'ListAliasesMethodNotSupported']);
+
+      await kill({});
+
+      return end();
+    }
+  }
+
+  const {kill, nodes} = await spawnLightningCluster({
+    size,
+    lnd_configuration: [
+      '--maxpendingchannels=10',
+      '--protocol.option-scid-alias',
+      '--protocol.zero-conf',
+    ],
+  });
+
+  const [{generate, lnd}, target] = nodes;
+
+  try {
+    // Make some funds to use
+    await generate({count: maturity});
+
+    // Connect to the peer
+    await addPeer({lnd, public_key: target.id, socket: target.socket});
+
+    // Wait for channel to be receptive to opens
+    await asyncRetry({interval, times}, async () => {
+      return await openChannels({
+        lnd,
+        channels: [{capacity, partner_public_key: target.id}],
+      });
+    });
+
+    const acceptSub = subscribeToOpenRequests({lnd: target.lnd});
+    const channelsSub = subscribeToChannels({lnd});
+
+    const closings = [];
+    const opened = [];
+
+    channelsSub.on('channel_closed', update => closings.push(update));
+    channelsSub.on('channel_opened', update => opened.push(update));
+
+    acceptSub.on('channel_request', request => {
+      equal(request.is_trusted_funding, true, 'Request is trusted funding');
+
+      return request.accept({is_trusted_funding: true});
+    });
+
+    // Propose the channel to the peer
+    const {pending} = await openChannels({
+      lnd,
+      channels: [{
+        capacity,
+        is_trusted_funding: true,
+        partner_public_key: target.id,
+      }],
+    });
+
+    // Setup funding to the 2:2 output
+    const fundTarget = await fundPsbt({lnd, outputs: pending});
+
+    // Sign the funding to the 2:2 output
+    const {psbt, transaction} = await signPsbt({lnd, psbt: fundTarget.psbt});
+
+    // Fund the channel
+    await fundPendingChannels({
+      lnd,
+      channels: pending.map(({id}) => id),
+      funding: psbt,
+    });
+
+    const invoice = await createInvoice({
+      lnd: target.lnd,
+      tokens: 100,
+    });
+
+    const channel = await asyncRetry({interval, times}, async () => {
+      const {channels} = await getChannels({lnd, is_active: true});
+
+      if (!channels.length) {
+        throw new Error('ExpectedTrustedChannelToAppear');
+      }
+
+      const [channel] = channels;
+
+      return channel;
+    });
+
+    // Make sure the channel reflects that it is trusted funding
+    strictSame(channel.other_ids, [], 'Got no ephemeral ids');
+    equal(channel.id, '16000000x0x0', 'Channel id is faked');
+    equal(channel.is_trusted_funding, true, 'Channel funding is trusted');
+
+    // Make sure the open channel event reflected that it was trusted funding
+    const [event] = opened;
+
+    strictSame(event.other_ids, [], 'Got no ephemeral ids');
+    equal(event.id, '16000000x0x0', 'Channel id is faked');
+    equal(event.is_trusted_funding, true, 'Channel funding is trusted');
+
+    // Make sure the channel can be used immediately
+    await pay({lnd, request: invoice.request});
+
+    // Generate the channel into a block
+    await broadcastChainTransaction({lnd, transaction});
+
+    const confirmed = await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      const [confirmed] = (await getChannels({lnd})).channels;
+
+      if (confirmed.id === channel.id) {
+        throw new Error('ExpectedChangeToRealChannelId');
+      }
+
+      return confirmed;
+    });
+
+    equal(confirmed.id, '102x1x0', 'Channel id is real now');
+    equal(confirmed.is_trusted_funding, true, 'Channel funding was trusted');
+    strictSame(confirmed.other_ids, ['16000000x0x0'], 'Got ephemeral ids');
+
+    await closeChannel({lnd, id: confirmed.id});
+
+    // Propose a private channel to the peer
+    const openPrivate = await asyncRetry({interval, times}, async () => {
+      return await openChannels({
+        lnd,
+        channels: [{
+          capacity,
+          is_private: true,
+          is_trusted_funding: true,
+          partner_public_key: target.id,
+        }],
+      });
+    });
+
+    // Setup funding to the 2:2 output for the private channel
+    const fundPrivate = await fundPsbt({lnd, outputs: openPrivate.pending});
+
+    // Sign the private funding
+    const signedPrivate = await signPsbt({lnd, psbt: fundPrivate.psbt});
+
+    // Fund the private channel
+    await fundPendingChannels({
+      lnd,
+      channels: openPrivate.pending.map(({id}) => id),
+      funding: signedPrivate.psbt,
+    });
+
+    // Generate the channel into a block
+    await broadcastChainTransaction({
+      lnd,
+      transaction: signedPrivate.transaction,
+    });
+
+    const privateConfirmed = await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      const [confirmed] = (await getChannels({lnd})).channels;
+
+      const shut = await getClosedChannels({lnd});
+
+      if (!shut.channels.length) {
+        throw new Error('ExpectedClosedChannel');
+      }
+
+      if (!confirmed.other_ids.length) {
+        throw new Error('ExpectedChangeToRealPrivateChannelId');
+      }
+
+      return confirmed;
+    });
+
+    strictSame(privateConfirmed.other_ids, ['16000000x0x1'], 'Got private id');
+
+    const [closedChannel] = (await getClosedChannels({lnd})).channels;
+
+    equal(closedChannel.id, confirmed.id, 'Closed channel shows confirmed id');
+    strictSame(closedChannel.other_ids, confirmed.other_ids, 'Saved temp id');
+
+    const [closeEvent] = closings;
+
+    equal(closeEvent.id, confirmed.id, 'Closed event shows confirmed id');
+    strictSame(closeEvent.other_ids, confirmed.other_ids, 'Got temporary id');
+
+    const ephemeralIds = await getEphemeralChannelIds({lnd});
+
+    strictSame(
+      ephemeralIds,
+      {
+        channels: [
+          {other_ids: [], reference_id: '16000000x0x0'},
+          {other_ids: [], reference_id: '16000000x0x1'},
+        ],
+      },
+      'Ephemeral ids are returned'
+    );
+  } catch (err) {
+    equal(err, null, 'No error is reported');
+  } finally {
+    return await kill({});
+  }
+
+  return end();
+});

package/test/invoicesrpc-integration/test_get_sweep_transactions.js

@@ -26,9 +26,9 @@ const channelCapacityTokens = 1e6;
 const confirmationCount = 6;
 const defaultFee = 1e3;
 const give = 1e5;
-const interval = 200;
+const interval = 50;
 const size = 2;
-const times = 1000;
+const times = 10000;
 const tokens = 100;
 
 // Force close a channel and get the resulting sweep transaction
@@ -76,8 +76,15 @@ test(`Get sweep transactions`, async ({end, equal}) => {
       .map(n => n.tokens).sort();
 
     equal(transactions.length, 2, 'Got closed channel sweep');
-    equal(anchorTokens, 149, 'Sweep has tokens amount');
-    equal(sweepTokens, 890455, 'Sweep has tokens amount');
+
+    // LND 0.15.0 and before have different sweep tokens
+    if (sweepTokens === 890455) {
+      equal(anchorTokens, 149, 'Sweep has tokens amount');
+      equal(sweepTokens, 890455, 'Sweep has tokens amount');
+    } else {
+      equal(anchorTokens, 136, 'Sweep has tokens amount');
+      equal(sweepTokens, 889855, 'Sweep has tokens amount');
+    }
   } else {
     equal(transactions.length, [channel].length, 'Got closed channel sweep');
     equal(transaction.spends.length, 1, 'Sweep has spends');

package/test/signerrpc-integration/test_sign_bytes.js

@@ -51,6 +51,23 @@ test(`Sign bytes`, async ({end, equal}) => {
     equal(message, 'ExpectedSignerRpcLndBuildTagToSignBytes', 'Invalid LND');
   }
 
+  try {
+    const schnorr = await signBytes({
+      lnd,
+      key_family: 6,
+      key_index: 0,
+      preimage: Buffer.alloc(32).toString('hex'),
+      type: 'schnorr',
+    });
+
+    equal(schnorr.signature.length, 64 * 2, 'Got schnorr signature for bytes');
+  } catch (err) {
+    const [code, message] = Array.isArray(err) ? err : [];
+
+    equal(code, 503, 'A 503 code is thrown if schnorr is unsupported');
+    equal(message, 'UnexpectedSignatureLengthInSignBytesResponse', 'Sig len');
+  }
+
   await kill({});
 
   return end();

package/test/signerrpc-integration/test_verify_bytes_signature.js

@@ -72,6 +72,30 @@ test(`Verify bytes signature`, async ({end, equal}) => {
     equal(message, 'ExpectedSignerRpcLndBuildTagToSignBytes', 'Invalid LND');
   }
 
+  try {
+    const schnorr = await signBytes({
+      lnd,
+      key_family: 6,
+      key_index: 0,
+      preimage: Buffer.alloc(32).toString('hex'),
+      type: 'schnorr',
+    });
+
+    const validity = await verifyBytesSignature({
+      lnd,
+      preimage: Buffer.alloc(32).toString('hex'),
+      public_key: id.slice(2),
+      signature: schnorr.signature,
+    });
+
+    equal(validity.is_valid, true, 'Schnorr signature is valid');
+  } catch (err) {
+    const [code, message] = Array.isArray(err) ? err : [];
+
+    equal(code, 503, 'A 503 code is thrown if schnorr is unsupported');
+    equal(message, 'UnexpectedSignatureLengthInSignBytesResponse', 'Sig len');
+  }
+
   await kill({});
 
   return end();