ln-service 53.17.5 → 53.20.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Versions
 
+## 53.20.0
+
+- `closeChannel`: Add support for `max_tokens_per_vbyte` to set max fee rate
+- `getChainTransactions`: Add `inputs` support for previous outpoints
+- `subscribeToTransactions`: Add `inputs` support for previous outpoints
+
+## 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

@@ -13,7 +13,6 @@ Supported LND versions:
 - v0.14.0-beta to v0.14.3-beta
 - v0.13.0-beta to v0.13.4-beta
 - v0.12.0-beta to v0.12.1-beta
-- v0.11.0-beta to v0.11.1-beta
 
 For typescript-ready methods, check out https://github.com/alexbosworth/lightning#readme
 
@@ -151,6 +150,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
@@ -528,17 +528,23 @@ Either an id or a transaction id / transaction output index is required
 
 If cooperatively closing, pass a public key and socket to connect
 
-Requires `info:read`, `offchain:write`, `onchain:write`, `peers:write` permissions
+`max_tokens_per_vbyte` will be ignored when closing a peer initiated channel
+
+Requires `info:read`, `offchain:write`, `onchain:write`, `peers:write`
+permissions
+
+`max_tokens_per_vbyte` is not supported in LND 0.15.0 and below
 
     {
       [address]: <Request Sending Local Channel Funds To Address String>
       [id]: <Standard Format Channel Id String>
       [is_force_close]: <Is Force Close Bool>
       lnd: <Authenticated LND API Object>
+      [max_tokens_per_vbyte]: <Fail Cooperative Close Above Fee Rate Number>
       [public_key]: <Peer Public Key String>
       [socket]: <Peer Socket String>
       [target_confirmations]: <Confirmation Target Number>
-      [tokens_per_vbyte]: <Tokens Per Virtual Byte Number>
+      [tokens_per_vbyte]: <Target Tokens Per Virtual Byte Number>
       [transaction_id]: <Transaction Id Hex String>
       [transaction_vout]: <Transaction Output Index Number>
     }
@@ -1485,10 +1491,12 @@ Get chain transactions.
 
 Requires `onchain:read` permission
 
+`inputs` are not supported on LND 0.15.0 and below
+
     {
       [after]: <Confirmed After Current Best Chain Block Height Number>
       [before]: <Confirmed Before Current Best Chain Block Height Number>
-      lnd: <Authenticated LND Object>
+      lnd: <Authenticated LND API Object>
     }
 
     @returns via cbk or Promise
@@ -1501,6 +1509,11 @@ Requires `onchain:read` permission
         [description]: <Transaction Label String>
         [fee]: <Fees Paid Tokens Number>
         id: <Transaction Id String>
+        inputs: [{
+          is_local: <Spent Outpoint is Local Bool>
+          transaction_id: <Transaction Id Hex String>
+          transaction_vout: <Transaction Output Index Number>
+        }]
         is_confirmed: <Is Confirmed Bool>
         is_outgoing: <Transaction Outbound Bool>
         output_addresses: [<Address String>]
@@ -1602,6 +1615,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,6 +1640,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_csv]: <Local CSV Blocks Delay Number>
         [local_dust]: <Local Non-Enforceable Amount Tokens Number>
@@ -1633,6 +1649,7 @@ Requires `offchain:read` permission
         [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 +1699,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 +1738,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 +1796,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 +1909,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 +3608,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 +4747,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 +5070,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 +5116,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 +5135,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 +5524,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>
     }
@@ -6553,6 +6627,8 @@ Subscribe to transactions
 
 Requires `onchain:read` permission
 
+`inputs` are not supported on LND 0.15.0 and below
+
     {
       lnd: <Authenticated LND API Object>
     }
@@ -6571,6 +6647,11 @@ Requires `onchain:read` permission
       created_at: <Created ISO 8601 Date String>
       [fee]: <Fees Paid Tokens Number>
       id: <Transaction Id String>
+      inputs: [{
+        is_local: <Spent Outpoint is Local Bool>
+        transaction_id: <Transaction Id Hex String>
+        transaction_vout: <Transaction Output Index Number>
+      }]
       is_confirmed: <Is Confirmed Bool>
       is_outgoing: <Transaction Outbound Bool>
       output_addresses: [<Address String>]
@@ -7039,10 +7120,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

@@ -11,7 +11,7 @@
     "cors": "2.8.5",
     "express": "4.18.1",
     "invoices": "2.1.0",
-    "lightning": "5.16.6",
+    "lightning": "5.19.0",
     "macaroon": "3.0.4",
     "morgan": "1.10.0",
     "ws": "8.8.1"
@@ -28,9 +28,9 @@
     "bn.js": "5.2.1",
     "bs58check": "2.1.2",
     "ecpair": "2.0.1",
-    "ln-docker-daemons": "2.3.2",
+    "ln-docker-daemons": "2.3.4",
     "p2tr": "1.3.1",
-    "portfinder": "1.0.28",
+    "portfinder": "1.0.32",
     "psbt": "2.7.1",
     "rimraf": "3.0.2",
     "secp256k1": "4.0.3",
@@ -56,7 +56,6 @@
     "url": "https://github.com/alexbosworth/ln-service.git"
   },
   "scripts": {
-    "integration-test-daily-lnd-build": "DOCKER_LND_VERSION=daily-testing-only npm run test",
     "integration-test-0.15.0": "DOCKER_LND_VERSION=v0.15.0-beta npm run test",
     "integration-test-0.14.3": "DOCKER_LND_VERSION=v0.14.3-beta npm run test",
     "integration-test-0.14.2": "DOCKER_LND_VERSION=v0.14.2-beta npm run test",
@@ -71,5 +70,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.5"
+  "version": "53.20.0"
 }

package/test/integration/test_add_peer.js

@@ -8,7 +8,7 @@ const {getPeers} = require('./../../');
 
 const interval = 100;
 const size = 2;
-const times = 2000;
+const times = 4000;
 const timeout = 100;
 
 // Adding peers should result in a connected peer

package/test/integration/test_delete_pending_channel.js

@@ -18,6 +18,7 @@ const {fundPsbt} = require('./../../');
 const {getChainBalance} = require('./../../');
 const {getChannels} = require('./../../');
 const {getLockedUtxos} = require('./../../');
+const {getMasterPublicKeys} = require('./../../');
 const {getPendingChannels} = require('./../../');
 const {openChannels} = require('./../../');
 const {signPsbt} = require('./../../');
@@ -41,6 +42,17 @@ test(`Forfeit pending channel`, async ({end, equal, strictSame}) => {
 
   const {generate, lnd} = control;
 
+  try {
+    const {keys} = await getMasterPublicKeys({lnd});
+  } catch (err) {
+    // LND 0.13.3 and below should not be tested
+    strictSame(err, [501, 'GetMasterPublicKeysMethodNotSupported'], 'Got err');
+
+    await kill({});
+
+    return end();
+  }
+
   try {
     await control.generate({count});
 

package/test/integration/test_get_chain_transactions.js

@@ -20,12 +20,16 @@ test(`Get chain transactions`, async ({end, equal, strictSame}) => {
   // Generate some funds for LND
   await generate({count});
 
-  await asyncRetry({interval: 10, times: 1000}, async () => {
+  await asyncRetry({interval: 10, times: 2000}, async () => {
     const wallet = await getWalletInfo({lnd});
 
     if (!wallet.is_synced_to_chain) {
       throw new Error('ExpectedWalletSyncedToChain');
     }
+
+    if (wallet.current_block_height !== count + 1) {
+      throw new Error('ExpectedFullySyncedToChain');
+    }
   });
 
   // Wait for generation to be over

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');
@@ -217,14 +219,14 @@ test(`Get closed channels`, async ({end, equal}) => {
   equal(!!settleHtlc.transaction_id, true, 'Output tx id');
   equal(settleHtlc.transaction_vout !== undefined, true, 'Output tx vout');
 
-  const alsoDead = await asyncRetry({interval: 2000, times: 99}, async () => {
+  const alsoDead = await asyncRetry({interval: 20, times: 7000}, async () => {
     const {channels} = await getClosedChannels({lnd: target.lnd});
 
     if (channels.length === [toForceClose, channelOpen].length) {
       return channels;
     }
 
-    await target.generate({count: 100});
+    await target.generate({});
 
     throw new Error('WaitingForTargetForceClose');
   });

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,248 @@
+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, match, 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');
+    match(channel.id, /16000000x0/, '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 event ephemeral ids');
+    match(event.id, /16000000x0/, 'Channel event id is faked');
+    equal(event.is_trusted_funding, true, 'Channel event 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');
+    equal(confirmed.other_ids.length, 1, 'Got ephemeral id');
+
+    const [otherId] = confirmed.other_ids;
+
+    match(otherId, /16000000x0/, 'Got ephemeral id');
+
+    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;
+    });
+
+    equal(privateConfirmed.other_ids.length, 1, 'Got private ephemeral ids');
+
+    const [privateOtherId] = privateConfirmed.other_ids;
+
+    match(privateOtherId, /16000000x0/, '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});
+
+    equal(ephemeralIds.channels.length, 2, 'Got ephemeral channel ids');
+
+    const [firstChannel, secondChannel] = ephemeralIds.channels;
+
+    match(firstChannel.reference_id, /16000000x0/, 'Got first channel id');
+    match(secondChannel.reference_id, /16000000x0/, 'Got second channel id');
+  } 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/routerrpc-integration/test_multipath_payment.js

@@ -1,7 +1,10 @@
+const asyncRetry = require('async/retry');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {createInvoice} = require('./../../');
+const {getChannelBalance} = require('./../../');
+const {getChannels} = require('./../../');
 const {getInvoice} = require('./../../');
 const {getRouteToDestination} = require('./../../');
 const {parsePaymentRequest} = require('./../../');
@@ -13,8 +16,11 @@ const {waitForRoute} = require('./../macros');
 const all = promise => Promise.all(promise);
 const capacity = 1e6;
 const {ceil} = Math;
+const interval = 10;
+const maturity = 100;
 const {round} = Math;
 const size = 2;
+const times = 2000;
 
 // Paying using multiple paths should execute the payment across paths
 test(`Pay with multiple paths`, async ({end, equal, rejects, strictSame}) => {
@@ -22,22 +28,50 @@ test(`Pay with multiple paths`, async ({end, equal, rejects, strictSame}) => {
 
   const [{generate, lnd}, target] = nodes;
 
-  await generate({count: 400});
+  await generate({count: maturity});
 
   const channel1 = await setupChannel({
     capacity,
     generate,
     lnd,
+    hidden: true,
     to: target,
   });
 
+  await asyncRetry({interval, times}, async () => {
+    const {channels} = await getChannels({lnd});
+
+    await generate({});
+
+    if (!channels.length) {
+      throw new Error('ExpectedChannelCreated');
+    }
+  });
+
   const channel2 = await setupChannel({
     capacity,
     generate,
     lnd,
+    hidden: true,
     to: target,
   });
 
+  await asyncRetry({interval, times}, async () => {
+    const {channels} = await getChannels({lnd, is_active: true});
+
+    await generate({});
+
+    if (channels.length < size) {
+      throw new Error('ExpectedSecondChannelCreated');
+    }
+
+    const balance = await getChannelBalance({lnd});
+
+    if (balance.channel_balance < capacity) {
+      throw new Error('ExpectedChannelBalancePresent');
+    }
+  });
+
   const channels = [channel1, channel2];
 
   const payParts = [
@@ -50,15 +84,23 @@ test(`Pay with multiple paths`, async ({end, equal, rejects, strictSame}) => {
   const {request} = await createInvoice({tokens, lnd: target.lnd});
 
   // Payment should fail with only 1 path
-  try {
-    await payViaPaymentRequest({lnd, request, max_paths: [channel1].length});
-  } catch (err) {
-    strictSame(
-      err,
-      [503, 'PaymentPathfindingFailedToFindPossibleRoute'],
-      'No path'
-    );
-  }
+  await asyncRetry({interval, times}, async () => {
+    try {
+      await payViaPaymentRequest({lnd, request, max_paths: [channel1].length});
+    } catch (err) {
+      const [, message] = err;
+
+      if (message !== 'PaymentPathfindingFailedToFindPossibleRoute') {
+        throw err;
+      }
+
+      strictSame(
+        err,
+        [503, 'PaymentPathfindingFailedToFindPossibleRoute'],
+        'No path'
+      );
+    }
+  });
 
   // Payment should succeed with 2 paths
   try {

package/test/routerrpc-integration/test_subscribe_to_forward_requests.js

@@ -75,10 +75,15 @@ test(`Subscribe to requests`, async ({end, equal, rejects, strictSame}) => {
 
     await once(pay, 'failed');
 
+    equal(failures.length, 1, 'Got a failure');
+
+    const [failed] = failures;
+
+    delete failed.channel;
+
     strictSame(
-      failures,
-      [{
-        channel: channel.id,
+      failed,
+      {
         index: 1,
         mtokens: '101000',
         public_key: target.id,
@@ -114,7 +119,7 @@ test(`Subscribe to requests`, async ({end, equal, rejects, strictSame}) => {
           tokens: 101,
           total_mtokens: '100000',
         },
-      }],
+      },
       'Failure is emitted'
     );
 
@@ -135,10 +140,13 @@ test(`Subscribe to requests`, async ({end, equal, rejects, strictSame}) => {
       equal(!!pending.created_at, true, 'Has creation date');
       equal(pending.id, invoice.id, 'Payment id is present');
       equal(pending.mtokens, invoice.mtokens, 'Pending payment mtokens');
+      equal(pending.paths.length, 1, 'Path is present');
+
+      const [path] = pending.paths;
 
       strictSame(
-        pending.paths,
-        [{
+        path,
+        {
           fee: 1,
           fee_mtokens: '1000',
           hops: [
@@ -168,7 +176,7 @@ test(`Subscribe to requests`, async ({end, equal, rejects, strictSame}) => {
           timeout: height + 40 + 43,
           tokens: 101,
           total_mtokens: '100000',
-        }],
+        },
         'Paths are present'
       );
 

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();

package/test/walletrpc-integration/test_sign_psbt.js

@@ -10,7 +10,6 @@ const {broadcastChainTransaction} = require('./../../');
 const {createChainAddress} = require('./../../');
 const {fundPsbt} = require('./../../');
 const {getChainBalance} = require('./../../');
-const {getChainTransactions} = require('./../../');
 const {getUtxos} = require('./../../');
 const {sendToChainAddress} = require('./../../');
 const {signPsbt} = require('./../../');