ln-service 57.1.0 → 57.1.1

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## 57.1.1
+
+- Add support for LND 0.17.1
+
 ## 57.1.0
 
 - `getBlockHeader`: Add method to get the header portion of a block

package/README.md

@@ -9,7 +9,7 @@ through npm.
 
 Supported LND versions:
 
-- v0.17.0-beta
+- v0.17.0-beta to v0.17.1-beta
 - v0.16.0-beta to v0.16.4-beta
 - v0.15.2-beta to v0.15.5-beta
 - v0.14.4-beta to v0.14.5-beta

package/package.json

@@ -9,14 +9,14 @@
   "dependencies": {
     "bolt07": "1.8.4",
     "invoices": "3.0.0",
-    "lightning": "10.1.0",
+    "lightning": "10.1.2",
     "macaroon": "3.0.4"
   },
   "description": "Interaction helper for your Lightning Network daemon",
   "devDependencies": {
     "@alexbosworth/blockchain": "1.7.0",
     "@alexbosworth/node-fetch": "2.6.2",
-    "async": "3.2.4",
+    "async": "3.2.5",
     "asyncjs-util": "1.2.12",
     "bip32": "4.0.0",
     "bip66": "1.1.5",
@@ -24,7 +24,7 @@
     "bn.js": "5.2.1",
     "bs58check": "3.0.1",
     "ecpair": "2.1.0",
-    "ln-docker-daemons": "6.0.3",
+    "ln-docker-daemons": "6.0.5",
     "p2tr": "2.0.0",
     "portfinder": "1.0.32",
     "psbt": "3.0.0",
@@ -52,6 +52,7 @@
     "url": "https://github.com/alexbosworth/ln-service.git"
   },
   "scripts": {
+    "integration-test-0.17.1": "DOCKER_LND_VERSION=v0.17.1-beta npm run test",
     "integration-test-0.17.0": "DOCKER_LND_VERSION=v0.17.0-beta npm run test",
     "integration-test-0.16.4": "DOCKER_LND_VERSION=v0.16.4-beta npm run test",
     "integration-test-0.16.3": "DOCKER_LND_VERSION=v0.16.3-beta npm run test",
@@ -66,5 +67,5 @@
     "integration-test-0.14.4": "DOCKER_LND_VERSION=v0.14.4-beta npm run test",
     "test": "echo $DOCKER_LND_VERSION && node test/runner"
   },
-  "version": "57.1.0"
+  "version": "57.1.1"
 }

package/test/chainrpc-integration/test_subscribe_to_blocks.js

@@ -11,6 +11,7 @@ const {delay} = require('./../macros');
 const {generateBlocks} = require('./../macros');
 const {getHeight} = require('./../../');
 const {getChainBalance} = require('./../../');
+const {getWalletInfo} = require('./../../');
 const {subscribeToBlocks} = require('./../../');
 const {waitForTermination} = require('./../macros');
 
@@ -26,6 +27,17 @@ test(`Subscribe to blocks`, async () => {
 
   const [{generate, lnd}] = nodes;
 
+  // Try to make sure that the chain notifier RPC is ready
+  await asyncRetry({interval, times}, async () => {
+    const wallet = await getWalletInfo({lnd});
+
+    await generate({});
+
+    if (!wallet.is_synced_to_chain) {
+      throw new Error('NotSyncedToChain');
+    }
+  });
+
   const gotHeight = await asyncRetry({interval, times}, async () => {
     const subBlocks = subscribeToBlocks({lnd});
 

package/test/integration/test_add_peer.js

@@ -17,7 +17,7 @@ const timeout = 100;
 test(`Add a peer`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
-  const [{lnd}, target] = nodes;
+  const [{generate, lnd}, target] = nodes;
 
   try {
     const connectedKeys = (await getPeers({lnd})).peers.map(n => n.public_key);
@@ -29,6 +29,8 @@ test(`Add a peer`, async () => {
     );
 
     await asyncRetry({interval, times}, async () => {
+      await generate({});
+
       await addPeer({
         lnd,
         timeout,

package/test/integration/test_decode_payment_request.js

@@ -1,11 +1,16 @@
 const {strictEqual} = require('node:assert').strict;
 const test = require('node:test');
 
+const asyncRetry = require('async/retry');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 
 const {createInvoice} = require('./../../');
 const {decodePaymentRequest} = require('./../../');
 const {getIdentity} = require('./../../');
+const {getWalletInfo} = require('./../../');
+
+const interval = 50;
+const times = 4000;
 
 const tests = [
   {
@@ -24,7 +29,17 @@ const tests = [
 
 tests.forEach(({description, expected}) => {
   return test(description, async () => {
-    const [{kill, lnd}] = (await spawnLightningCluster({})).nodes;
+    const [{generate, kill, lnd}] = (await spawnLightningCluster({})).nodes;
+
+    await asyncRetry({interval, times}, async () => {
+      const wallet = await getWalletInfo({lnd});
+
+      await generate({});
+
+      if (!wallet.is_synced_to_chain) {
+        throw new Error('NotSyncedToChain');
+      }
+    });
 
     try {
       const {request} = await createInvoice({

package/test/integration/test_delete_pending_channel.js

@@ -19,6 +19,7 @@ const {getChannels} = require('./../../');
 const {getLockedUtxos} = require('./../../');
 const {getMasterPublicKeys} = require('./../../');
 const {getPendingChannels} = require('./../../');
+const {getWalletInfo} = require('./../../');
 const {openChannels} = require('./../../');
 const {signPsbt} = require('./../../');
 const {unlockUtxo} = require('./../../');
@@ -39,10 +40,18 @@ test(`Forfeit pending channel`, async t => {
 
   const {kill, nodes} = await spawnLightningCluster({size});
 
-  t.after(async () => await kill({}));
-
   const [{generate, lnd}, target, remote] = nodes;
 
+  await asyncRetry({interval, times}, async () => {
+    const wallet = await getWalletInfo({lnd});
+
+    await generate({});
+
+    if (!wallet.is_synced_to_chain) {
+      throw new Error('NotSyncedToChain');
+    }
+  });
+
   await generate({count});
 
   await asyncEach([target, remote], async node => {
@@ -63,7 +72,15 @@ test(`Forfeit pending channel`, async t => {
       lnd,
       is_avoiding_broadcast: true,
     },
-    cbk);
+    async (err, res) => {
+      await generate({});
+
+      await asyncEach([target, remote], async node => {
+        return await addPeer({lnd, public_key: node.id, socket: node.socket});
+      });
+
+      return cbk(err, res)
+    });
   });
 
   // Setup funding for the target
@@ -120,7 +137,7 @@ test(`Forfeit pending channel`, async t => {
     funding: signRemote.psbt,
   });
 
-  await delay(1000);
+  await delay(2000);
 
   const {transaction} = extractTransaction({ecp, psbt: signRemote.psbt});
 
@@ -179,5 +196,7 @@ test(`Forfeit pending channel`, async t => {
     deepEqual(err, [501, 'DeletePendingChannelMethodNotSupported']);
   }
 
+  await kill({});
+
   return;
 });

package/test/integration/test_get_chain_transactions.js

@@ -1,4 +1,4 @@
-const {strictEqual} = require('node:assert').strict;
+const {equal} = require('node:assert').strict;
 const test = require('node:test');
 
 const asyncRetry = require('async/retry');
@@ -28,6 +28,8 @@ test(`Get chain transactions`, async () => {
       throw new Error('ExpectedWalletSyncedToChain');
     }
 
+    await generate({});
+
     if (wallet.current_block_height < count + 1) {
       throw new Error('ExpectedFullySyncedToChain');
     }
@@ -48,37 +50,33 @@ test(`Get chain transactions`, async () => {
 
   const {transactions} = await getChainTransactions({lnd});
 
-  strictEqual(transactions.length > 1, true, 'Transaction found');
+  equal(transactions.length > 1, true, 'Transaction found');
 
   const [tx] = transactions;
 
-  strictEqual(!!tx.block_id, true, 'Transaction has block id');
-  strictEqual(!!tx.confirmation_count, true, 'Transaction confirm count');
-  strictEqual(!!tx.confirmation_height, true, 'Transaction confirm height');
-  strictEqual(!!tx.created_at, true, 'Transaction record create time');
-  strictEqual(tx.description, undefined, 'No tx description');
-  strictEqual(tx.fee, undefined, 'No transaction fee');
-  strictEqual(!!tx.id, true, 'Transaction id');
-  strictEqual(tx.is_confirmed, true, 'Transaction is confirmed');
-  strictEqual(tx.is_outgoing, false, 'Transaction is incoming');
-  strictEqual(tx.output_addresses.length, 1, 'Tx output address');
-  strictEqual(tx.tokens, 5000000000, 'Got coinbase reward tokens');
-  strictEqual(!!tx.transaction, true, 'Got transaction hex');
+  equal(!!tx.block_id, true, 'Transaction has block id');
+  equal(!!tx.confirmation_count, true, 'Transaction confirm count');
+  equal(!!tx.confirmation_height, true, 'Transaction confirm height');
+  equal(!!tx.created_at, true, 'Transaction record create time');
+  equal(tx.description, undefined, 'No tx description');
+  equal(tx.fee, undefined, 'No transaction fee');
+  equal(!!tx.id, true, 'Transaction id');
+  equal(tx.is_confirmed, true, 'Transaction is confirmed');
+  equal(tx.is_outgoing, false, 'Transaction is incoming');
+  equal(tx.output_addresses.length, 1, 'Tx output address');
+  equal(tx.tokens, 5000000000, 'Got coinbase reward tokens');
+  equal(!!tx.transaction, true, 'Got transaction hex');
 
   const onlyAfter = await getChainTransactions({
     lnd,
     after: tx.confirmation_height,
   });
 
-  strictEqual(onlyAfter.transactions.length, [].length, 'No txs after');
-
-  const [height] = transactions
-    .map(n => n.confirmation_height)
-    .sort((a, b) => a - b);
+  equal(onlyAfter.transactions.length, [].length, 'No txs after');
 
-  const onlyBefore = await getChainTransactions({lnd, before: height});
+  const onlyBefore = await getChainTransactions({lnd, before: 2});
 
-  strictEqual(onlyBefore.transactions.length, [].length, 'No tx before');
+  equal(onlyBefore.transactions.length < 100, true, 'Got before txs');
 
   const between = await getChainTransactions({
     lnd,
@@ -86,7 +84,7 @@ test(`Get chain transactions`, async () => {
     before: tx.confirmation_height + 1,
   });
 
-  strictEqual(between.transactions.length, [tx].length, 'One transaction');
+  equal(between.transactions.length, [tx].length, 'One transaction');
 
   await kill({});
 

package/test/integration/test_get_invoices.js

@@ -3,21 +3,36 @@ const {strictEqual} = require('node:assert').strict;
 const test = require('node:test');
 
 const asyncEach = require('async/each');
+const asyncRetry = require('async/retry');
+const {getWalletInfo} = require('./../../');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 
 const {cancelHodlInvoice} = require('./../../');
 const {createInvoice} = require('./../../');
 const {getInvoices} = require('./../../');
 
+const interval = 1000;
 const limit = 1;
+const times = 1000;
 
-// createInvoice should result in a created invoice
-test(`Create an invoice`, async () => {
+// Get invoices should result in a list of created invoices
+test(`Get invoices`, async () => {
   const {kill, nodes} = await spawnLightningCluster({});
 
   try {
     const [{generate, lnd}] = nodes;
 
+    // Make sure that target is synced to the chain otherwise invoice can halt
+    await asyncRetry({interval, times}, async () => {
+      const wallet = await getWalletInfo({lnd});
+
+      await generate({});
+
+      if (!wallet.is_synced_to_chain) {
+        throw new Error('WaitingForSyncToChain');
+      }
+    });
+
     const invoices = [
       await createInvoice({lnd, description: '3'}),
       await createInvoice({lnd, description: '2'}),

package/test/integration/test_get_node.js

@@ -30,12 +30,20 @@ test(`Get node`, async () => {
   const [{generate, id, lnd}, target, remote] = nodes;
 
   try {
-    const controlToTarget = await setupChannel({generate, lnd, to: target});
+    const controlToTarget = await asyncRetry({interval, times}, async () => {
+      await generate({});
 
-    const targetToRemote = await setupChannel({
-      generate: target.generate,
-      lnd: target.lnd,
-      to: remote,
+      return await setupChannel({generate, lnd, to: target});
+    });
+
+    const targetToRemote = await asyncRetry({interval, times}, async () => {
+      await target.generate({});
+
+      return await setupChannel({
+        generate: target.generate,
+        lnd: target.lnd,
+        to: remote,
+      });
     });
 
     await updateRoutingFees({
@@ -48,6 +56,8 @@ test(`Get node`, async () => {
     });
 
     await asyncRetry({interval, times}, async () => {
+      await generate({});
+
       await addPeer({
         lnd,
         public_key: remote.id,
@@ -95,11 +105,13 @@ test(`Get node`, async () => {
     strictEqual(!!socket.socket, true, 'Ip, port');
     strictEqual(socket.type, 'tcp', 'Socket type');
     strictEqual(node.updated_at.length, 24, 'Update date');
+
+    await kill({});
   } catch (err) {
+    await kill({});
+
     strictEqual(err, null, 'Expected no error');
   }
 
-  await kill({});
-
   return;
 });

package/test/integration/test_get_peers.js

@@ -15,10 +15,12 @@ const times = 2000;
 test('Get peers', async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
-  const [{lnd}, target] = nodes;
+  const [{generate, lnd}, target] = nodes;
 
   try {
     await asyncRetry({interval, times}, async () => {
+      await generate({});
+
       await addPeer({
         lnd,
         public_key: target.id,

package/test/integration/test_pay_private_invoice.js

@@ -11,6 +11,7 @@ const {decodePaymentRequest} = require('./../../');
 const {getChannel} = require('./../../');
 const {getInvoice} = require('./../../');
 const {getRouteToDestination} = require('./../../');
+const {getWalletInfo} = require('./../../');
 const {openChannel} = require('./../../');
 const {parsePaymentRequest} = require('./../../');
 const {pay} = require('./../../');
@@ -28,6 +29,16 @@ test(`Pay private invoice`, async () => {
   try {
     const [{generate, lnd}, target, remote] = nodes;
 
+    await asyncRetry({interval, times}, async () => {
+      const wallet = await getWalletInfo({lnd});
+
+      await generate({});
+
+      if (!wallet.is_synced_to_chain) {
+        throw new Error('NotSyncedToChain');
+      }
+    });
+
     const channel = await setupChannel({generate, lnd, to: target});
 
     const remoteChannel = await setupChannel({
@@ -38,6 +49,8 @@ test(`Pay private invoice`, async () => {
     });
 
     const invoice = await asyncRetry({interval, times}, async () => {
+      await generate({});
+
       const invoice = await createInvoice({
         tokens,
         is_including_private_channels: true,
@@ -62,6 +75,8 @@ test(`Pay private invoice`, async () => {
     const decodedRequest = await decodePaymentRequest({lnd, request});
 
     const route = await asyncRetry({interval, times}, async () => {
+      await generate({});
+
       const {route} = await getRouteToDestination({
         lnd,
         cltv_delta: decodedRequest.cltv_delta,

package/test/integration/test_propose_channel.js

@@ -61,6 +61,8 @@ test(`Propose a channel with a coop delay`, async () => {
   try {
     // Generate some funds for LND
     await asyncRetry({times}, async () => {
+      await generate({});
+
       await addPeer({lnd, public_key: target.id, socket: target.socket});
 
       await generate({});

package/test/integration/test_remove_peer.js

@@ -16,10 +16,12 @@ const times = 2000;
 test(`Remove a peer`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
-  const [{id, lnd}, target] = nodes;
+  const [{generate, id, lnd}, target] = nodes;
 
   try {
     await asyncRetry({interval, times}, async () => {
+      await generate({});
+
       await addPeer({lnd, public_key: target.id, socket: target.socket});
     });
 

package/test/integration/test_send_message_to_peer.js

@@ -17,7 +17,7 @@ const times = 2000;
 test(`Send peer message`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
-  const [{id, lnd}, target] = nodes;
+  const [{generate, id, lnd}, target] = nodes;
 
   try {
     await sendMessageToPeer({
@@ -38,6 +38,8 @@ test(`Send peer message`, async () => {
 
   try {
     await asyncRetry({interval, times}, async () => {
+      await generate({});
+
       await addPeer({
         lnd,
         public_key: target.id,

package/test/integration/test_subscribe_to_peer_messages.js

@@ -17,10 +17,12 @@ const times = 1000;
 test(`Subscribe to peer messages`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
-  const [{lnd}, target, remote] = nodes;
+  const [{generate, lnd}, target, remote] = nodes;
 
   try {
     await asyncRetry({interval, times}, async () => {
+      await generate({});
+
       await addPeer({
         lnd,
         public_key: target.id,
@@ -28,10 +30,14 @@ test(`Subscribe to peer messages`, async () => {
       });
     });
 
-    await addPeer({
-      lnd: target.lnd,
-      public_key: remote.id,
-      socket: remote.socket,
+    await asyncRetry({interval, times}, async () => {
+      await target.generate({});
+
+      await addPeer({
+        lnd: target.lnd,
+        public_key: remote.id,
+        socket: remote.socket,
+      });
     });
 
     try {

package/test/integration/test_subscribe_to_peers.js

@@ -27,6 +27,8 @@ test(`Subscribe to peers`, async () => {
     sub.on('error', () => {});
 
     await asyncRetry({interval, times}, async () => {
+      await generate({});
+
       await addPeer({lnd, public_key: target.id, socket: target.socket});
     });
 

package/test/integration/test_subscribe_to_rpc_requests.js

@@ -52,7 +52,7 @@ test(`Subscribe to RPC requests`, async () => {
 
     kills.push(kill);
 
-    const [{lnd, id: key}] = nodes;
+    const [{generate, lnd, id: key}] = nodes;
 
     const rpcRequestsSub = (await subscribeToRpcRequests({lnd})).subscription;
 
@@ -64,6 +64,17 @@ test(`Subscribe to RPC requests`, async () => {
     rpcRequestsSub.on('request', request => intercepted.push({request}));
     rpcRequestsSub.on('response', response => intercepted.push({response}));
 
+    // Make sure that target is synced to the chain otherwise invoice can halt
+    await asyncRetry({interval, times}, async () => {
+      const wallet = await getWalletInfo({lnd});
+
+      await generate({});
+
+      if (!wallet.is_synced_to_chain) {
+        throw new Error('WaitingForSyncToChain');
+      }
+    });
+
     const {id} = await createInvoice({lnd});
 
     const invoicesSub = subscribeToInvoice({id, lnd});

package/test/integration/test_trusted_funding.js

@@ -14,9 +14,11 @@ const {createInvoice} = require('./../../');
 const {fundPendingChannels} = require('./../../');
 const {fundPsbt} = require('./../../');
 const {getChannels} = require('./../../');
+const {getChannel} = require('./../../');
 const {getClosedChannels} = require('./../../');
 const {getEphemeralChannelIds} = require('./../../');
 const {getPendingChannels} = require('./../../');
+const {getWalletInfo} = require('./../../');
 const {openChannels} = require('./../../');
 const {pay} = require('./../../');
 const {signPsbt} = require('./../../');
@@ -30,9 +32,7 @@ const size = 2;
 const times = 4000;
 
 // Opening unconfirmed channels should in immediate channel opening
-test(`Open unconfirmed channels`, async t => {
-  t.after(() => exit());
-
+test(`Open unconfirmed channels`, async () => {
   // Unconfirmed channels are not supported on LND 0.15.0 and below
   {
     const {kill, nodes} = await spawnLightningCluster({});
@@ -67,6 +67,16 @@ test(`Open unconfirmed channels`, async t => {
     // Make some funds to use
     await generate({count: maturity});
 
+    await asyncRetry({interval, times}, async () => {
+      const wallet = await getWalletInfo({lnd});
+
+      await generate({});
+
+      if (!wallet.is_synced_to_chain) {
+        throw new Error('NotSyncedToChain');
+      }
+    });
+
     // Connect to the peer
     await addPeer({lnd, public_key: target.id, socket: target.socket});
 
@@ -78,9 +88,13 @@ test(`Open unconfirmed channels`, async t => {
       });
     });
 
+    // Wait for channel open requests to be able to accept the proposal
     const acceptSub = subscribeToOpenRequests({lnd: target.lnd});
+
+    // Listen for channel events
     const channelsSub = subscribeToChannels({lnd});
 
+    // Channel closing and opening events should be emitted
     const closings = [];
     const opened = [];
 
@@ -118,11 +132,10 @@ test(`Open unconfirmed channels`, async t => {
       funding: psbt,
     });
 
-    const invoice = await createInvoice({
-      lnd: target.lnd,
-      tokens: 100,
-    });
+    // Make an invoice to pay over the channel
+    const invoice = await createInvoice({lnd: target.lnd, tokens: 100});
 
+    // Wait for the trusted channel
     const channel = await asyncRetry({interval, times}, async () => {
       const {channels} = await getChannels({lnd, is_active: true});
 
@@ -148,11 +161,14 @@ test(`Open unconfirmed channels`, async t => {
     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});
+    await asyncRetry({interval, times}, async () => {
+      return await pay({lnd, request: invoice.request});
+    });
 
     // Generate the channel into a block
     await broadcastChainTransaction({lnd, transaction});
 
+    // Make sure that the channel id gets a confirmed id
     const confirmed = await asyncRetry({interval, times}, async () => {
       await generate({});
 
@@ -165,7 +181,7 @@ test(`Open unconfirmed channels`, async t => {
       return confirmed;
     });
 
-    equal(confirmed.id, '102x1x0', 'Channel id is real now');
+    match(confirmed.id, /1[\d][\d]x1x0/, 'Channel id is real now');
     equal(confirmed.is_trusted_funding, true, 'Channel funding was trusted');
     equal(confirmed.other_ids.length, 1, 'Got ephemeral id');
 
@@ -184,6 +200,7 @@ test(`Open unconfirmed channels`, async t => {
       }
     });
 
+    // Remove the channel
     await asyncRetry({interval, times}, async () => {
       await closeChannel({lnd, id: confirmed.id});
     });
@@ -214,6 +231,7 @@ test(`Open unconfirmed channels`, async t => {
       funding: signedPrivate.psbt,
     });
 
+    // Confirm the private channel
     const privateConfirmed = await asyncRetry({interval, times}, async () => {
       // Generate the channel into a block
       await broadcastChainTransaction({
@@ -252,11 +270,13 @@ test(`Open unconfirmed channels`, async t => {
 
     match(firstChannel.reference_id, /16000000x0/, 'Got first channel id');
     match(secondChannel.reference_id, /16000000x0/, 'Got second channel id');
+
+    await kill({});
   } catch (err) {
-    equal(err, null, 'No error is reported');
-  }
+    await kill({});
 
-  await kill({});
+    throw err;
+  }
 
   return;
 });

package/test/invoicesrpc-integration/test_get_sweep_transactions.js

@@ -37,6 +37,16 @@ test(`Get sweep transactions`, async t => {
 
   const [{generate, lnd}, target] = nodes;
 
+  await asyncRetry({interval, times}, async () => {
+    const wallet = await getWalletInfo({lnd});
+
+    await generate({});
+
+    if (!wallet.is_synced_to_chain) {
+      throw new Error('NotSyncedToChain');
+    }
+  });
+
   const channel = await setupChannel({
     generate,
     lnd,

package/test/routerrpc-integration/test_get_payment.js

@@ -3,6 +3,7 @@ const {equal} = require('node:assert').strict;
 const {rejects} = require('node:assert').strict;
 const test = require('node:test');
 
+const asyncRetry = require('async/retry');
 const {setupChannel} = require('ln-docker-daemons');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 
@@ -11,11 +12,14 @@ const {createInvoice} = require('./../../');
 const {getChannels} = require('./../../');
 const {getHeight} = require('./../../');
 const {getPayment} = require('./../../');
+const {getWalletInfo} = require('./../../');
 const {payViaPaymentRequest} = require('./../../');
 const {waitForRoute} = require('./../macros');
 
+const interval = 50;
 const size = 3;
 const start = new Date().toISOString();
+const times = 5000;
 const tokens = 100;
 
 // Paying an invoice should settle the invoice
@@ -24,6 +28,16 @@ test(`Get payment`, async () => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
+  await asyncRetry({interval, times}, async () => {
+    const wallet = await getWalletInfo({lnd: remote.lnd});
+
+    await remote.generate({});
+
+    if (!wallet.is_synced_to_chain) {
+      throw new Error('NotSyncedToChain');
+    }
+  });
+
   const invoice = await createInvoice({tokens, lnd: remote.lnd});
 
   const {id} = invoice;

package/test/routerrpc-integration/test_get_route_confidence.js

@@ -1,16 +1,20 @@
 const {equal} = require('node:assert').strict;
 const test = require('node:test');
 
+const asyncRetry = require('async/retry');
 const {setupChannel} = require('ln-docker-daemons');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 
 const {addPeer} = require('./../../');
 const {getRouteConfidence} = require('./../../');
+const {getWalletInfo} = require('./../../');
 const {probeForRoute} = require('./../../');
 const {waitForRoute} = require('./../macros');
 
 const channelCapacityTokens = 1e6;
+const interval = 50;
 const size = 3;
+const times = 5000;
 const tokens = 1e6 / 2;
 
 // Getting route confidence should return confidence in a route
@@ -19,6 +23,16 @@ test('Get route confidence', async () => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
+  await asyncRetry({interval, times}, async () => {
+    const wallet = await getWalletInfo({lnd});
+
+    await generate({});
+
+    if (!wallet.is_synced_to_chain) {
+      throw new Error('NotSyncedToChain');
+    }
+  });
+
   try {
     // Create a channel from the control to the target node
     await setupChannel({

package/test/routerrpc-integration/test_pay_via_payment_request.js

@@ -3,6 +3,7 @@ const {equal} = require('node:assert').strict;
 const {rejects} = require('node:assert').strict;
 const test = require('node:test');
 
+const asyncRetry = require('async/retry');
 const {setupChannel} = require('ln-docker-daemons');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 
@@ -14,8 +15,10 @@ const {getWalletInfo} = require('./../../');
 const {payViaPaymentRequest} = require('./../../');
 const {waitForRoute} = require('./../macros');
 
+const interval = 50;
 const size = 3;
 const start = new Date().toISOString();
+const times = 3000;
 const tlvType = '67890';
 const tlvValue = '0102';
 const tokens = 100;
@@ -29,6 +32,16 @@ test(`Pay via payment request`, async () => {
   try {
     await generate({count: 100});
 
+    await asyncRetry({interval, times}, async () => {
+      const wallet = await getWalletInfo({lnd: remote.lnd});
+
+      await remote.generate({});
+
+      if (!wallet.is_synced_to_chain) {
+        throw new Error('NotSyncedToChain');
+      }
+    });
+
     const channel = await setupChannel({generate, lnd, to: target});
 
     // Make sure that an error is returned when there is no route

package/test/routerrpc-integration/test_probe_for_route.js

@@ -13,6 +13,7 @@ const {delay} = require('./../macros');
 const {deleteForwardingReputations} = require('./../../');
 const {getChainBalance} = require('./../../');
 const {getFailedPayments} = require('./../../');
+const {getWalletInfo} = require('./../../');
 const {getWalletVersion} = require('./../../');
 const {payViaRoutes} = require('./../../');
 const {probeForRoute} = require('./../../');
@@ -24,6 +25,7 @@ const channelCapacityTokens = 1e6;
 const confirmationCount = 20;
 const count = 100;
 const defaultFee = 1e3;
+const interval = 50;
 const size = 3;
 const times = 1000;
 const tokens = 1e6 / 2;
@@ -38,6 +40,16 @@ test('Probe for route', async () => {
     // Send coins to remote so that it can accept a channel
     await remote.generate({count});
 
+    await asyncRetry({interval, times}, async () => {
+      const wallet = await getWalletInfo({lnd: remote.lnd});
+
+      await remote.generate({});
+
+      if (!wallet.is_synced_to_chain) {
+        throw new Error('NotSyncedToChain');
+      }
+    });
+
     await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
     await setupChannel({

package/test/routerrpc-integration/test_subscribe_to_forwards.js

@@ -25,6 +25,8 @@ const size = 3;
 const times = 1000;
 const tokens = 100;
 
+const asyncTimesSeries = require('async/timesSeries');
+
 // Subscribing to forwards should show forwarding events
 test('Subscribe to forwards', async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
@@ -40,6 +42,16 @@ test('Subscribe to forwards', async () => {
     return;
   }
 
+  await asyncRetry({interval, times}, async () => {
+    const wallet = await getWalletInfo({lnd});
+
+    await generate({});
+
+    if (!wallet.is_synced_to_chain) {
+      throw new Error('NotSyncedToChain');
+    }
+  });
+
   try {
     const {features} = await getWalletInfo({lnd});
     const testSub = subscribeToForwards({lnd});

package/test/routerrpc-integration/test_subscribe_to_past_payments.js

@@ -8,12 +8,15 @@ const {spawnLightningCluster} = require('ln-docker-daemons');
 const {createInvoice} = require('./../../');
 const {delay} = require('./../macros');
 const {getPayment} = require('./../../');
+const {getWalletInfo} = require('./../../');
 const {payViaPaymentRequest} = require('./../../');
 const {subscribeToForwards} = require('./../../');
 const {subscribeToPastPayments} = require('./../../');
 const {waitForRoute} = require('./../macros');
 
+const interval = 1000;
 const size = 2;
+const times = 1000;
 const tokens = 100;
 
 // Subscribing to past payments should notify on a payment
@@ -25,6 +28,22 @@ test(`Subscribe to past payment`, async () => {
 
     const forwards = [];
     const payments = [];
+    const sub = subscribeToPastPayments({lnd});
+    const sub2 = subscribeToForwards({lnd});
+
+    sub2.on('forward', forward => forwards.push(forward));
+    sub.on('payment', payment => payments.push(payment));
+
+    // Make sure that target is synced to the chain otherwise invoice can halt
+    await asyncRetry({interval, times}, async () => {
+      const wallet = await getWalletInfo({lnd: target.lnd});
+
+      await generate({});
+
+      if (!wallet.is_synced_to_chain) {
+        throw new Error('WaitingForSyncToChain');
+      }
+    });
 
     const invoice = await createInvoice({tokens, lnd: target.lnd});
 
@@ -32,12 +51,6 @@ test(`Subscribe to past payment`, async () => {
 
     await setupChannel({generate, lnd, to: target});
 
-    const sub = subscribeToPastPayments({lnd});
-    const sub2 = subscribeToForwards({lnd});
-
-    sub2.on('forward', forward => forwards.push(forward));
-    sub.on('payment', payment => payments.push(payment));
-
     await payViaPaymentRequest({lnd, request: invoice.request});
 
     const {payment} = await getPayment({id, lnd});

package/test/routerrpc-integration/test_subscribe_to_payments.js

@@ -7,14 +7,17 @@ const {spawnLightningCluster} = require('ln-docker-daemons');
 
 const {createInvoice} = require('./../../');
 const {getPayment} = require('./../../');
+const {getWalletInfo} = require('./../../');
 const {payViaPaymentRequest} = require('./../../');
 const {subscribeToForwards} = require('./../../');
 const {subscribeToPayments} = require('./../../');
 const {waitForRoute} = require('./../macros');
 
-const unsupported = 'unknown method TrackPayments for service routerrpc.Router';
+const interval = 1000;
 const size = 2;
+const times = 1000;
 const tokens = 100;
+const unsupported = 'unknown method TrackPayments for service routerrpc.Router';
 
 // Subscribing to payments should notify on a payment
 test(`Subscribe to payments`, async () => {
@@ -28,6 +31,17 @@ test(`Subscribe to payments`, async () => {
     const isPaying = [];
     const payments = [];
 
+    // Make sure that target is synced to the chain otherwise invoice can halt
+    await asyncRetry({interval, times}, async () => {
+      const wallet = await getWalletInfo({lnd: target.lnd});
+
+      await generate({});
+
+      if (!wallet.is_synced_to_chain) {
+        throw new Error('WaitingForSyncToChain');
+      }
+    });
+
     const invoice = await createInvoice({tokens, lnd: target.lnd});
 
     const {id} = invoice;

package/test/tower_clientrpc-integration/test_connect_watchtower.js

@@ -1,14 +1,18 @@
 const {equal} = require('node:assert').strict;
 const test = require('node:test');
 
+const asyncRetry = require('async/retry');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 
 const {connectWatchtower} = require('./../../');
 const {getConnectedWatchtowers} = require('./../../');
 const {getTowerServerInfo} = require('./../../');
+const {getWalletInfo} = require('./../../');
 
 const conf = ['--watchtower.active', '--wtclient.active'];
+const interval = 50;
 const size = 2;
+const times = 5000;
 
 // Connecting to a watchtower should add a watchtower
 test(`Connect watchtower`, async () => {
@@ -17,7 +21,17 @@ test(`Connect watchtower`, async () => {
     lnd_configuration: conf
   });
 
-  const [{lnd}, target] = nodes;
+  const [{generate, lnd}, target] = nodes;
+
+  await asyncRetry({interval, times}, async () => {
+    const wallet = await getWalletInfo({lnd});
+
+    await generate({});
+
+    if (!wallet.is_synced_to_chain) {
+      throw new Error('NotSyncedToChain');
+    }
+  });
 
   try {
     const {tower} = await getTowerServerInfo({lnd: target.lnd});