ln-service 52.14.4 → 53.0.0

package/test/integration/test_get_payments.js

@@ -1,35 +1,35 @@
 const asyncTimesSeries = require('async/timesSeries');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {createCluster} = require('./../macros');
 const {createInvoice} = require('./../../');
-const {delay} = require('./../macros');
 const {getPayments} = require('./../../');
 const {pay} = require('./../../');
 const {setupChannel} = require('./../macros');
 
 const start = new Date().toISOString();
+const size = 2;
 const tokens = 100;
 
 // Getting payments should return the list of payments
 test('Get payments', async ({end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [{generate, lnd}, target] = nodes;
 
-  await setupChannel({lnd, generate: cluster.generate, to: cluster.target});
+  await setupChannel({generate, lnd, to: target});
 
-  const invoice = await createInvoice({tokens, lnd: cluster.target.lnd});
+  const invoice = await createInvoice({tokens, lnd: target.lnd});
 
   const paid = await pay({lnd, request: invoice.request});
 
   const [payment] = (await getPayments({lnd})).payments;
 
-  equal(payment.destination, cluster.target_node_public_key, 'Destination');
+  equal(payment.destination, target.id, 'Destination');
   equal(payment.confirmed_at > start, true, 'Got confirmed date');
   equal(payment.created_at.length, 24, 'Created at time');
   equal(payment.fee, 0, 'Fee paid');
-  equal(payment.hops.length, 0, 'Hops');
+  equal(payment.hops.length, [].length, 'Hops');
   equal(payment.id, invoice.id, 'Id');
   equal(payment.is_confirmed, true, 'Confirmed');
   equal(payment.is_outgoing, true, 'Outgoing');
@@ -42,7 +42,7 @@ test('Get payments', async ({end, equal}) => {
   }
 
   await asyncTimesSeries(4, async () => {
-    const {request} = await createInvoice({tokens, lnd: cluster.target.lnd});
+    const {request} = await createInvoice({tokens, lnd: target.lnd});
 
     const paid = await pay({lnd, request});
   });
@@ -61,7 +61,7 @@ test('Get payments', async ({end, equal}) => {
 
   equal(!!page3.next, false, 'There is no page 4');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_peers.js

@@ -1,26 +1,23 @@
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {addPeer} = require('./../../');
-const {createCluster} = require('./../macros');
 const {getPeers} = require('./../../');
 
-const interval = retryCount => 50 * Math.pow(2, retryCount);
-const times = 10;
+const interval = 10
+const size = 2;
+const times = 1000;
 
 // Getting peers should return the list of peers
 test('Get peers', async ({end, equal}) => {
-  const cluster = await createCluster({});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
-
-  await addPeer({
-    lnd,
-    public_key: cluster.remote.public_key,
-    socket: cluster.remote.socket,
-  });
+  const [{lnd}, target] = nodes;
 
   await asyncRetry({interval, times}, async () => {
+    await addPeer({lnd, public_key: target.id, socket: target.socket});
+
     const [peer] = (await getPeers({lnd})).peers;
 
     if (!peer || !peer.is_sync_peer) {
@@ -32,7 +29,7 @@ test('Get peers', async ({end, equal}) => {
     equal(peer.is_inbound, false, 'Is inbound peer');
     equal(peer.is_sync_peer, true, 'Is sync peer');
     equal(peer.ping_time, 0, 'Ping time');
-    equal(!!peer.public_key, true, 'Public key');
+    equal(peer.public_key, target.id, 'Public key');
     equal(!!peer.socket, true, 'Socket');
     equal(peer.tokens_received, 0, 'Tokens received');
     equal(peer.tokens_sent, 0, 'Tokens sent');
@@ -40,7 +37,7 @@ test('Get peers', async ({end, equal}) => {
     return;
   });
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_pending_coop.js

@@ -1,37 +1,32 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {closeChannel} = require('./../../');
-const {createCluster} = require('./../macros');
 const {getWalletInfo} = require('./../../');
 const {setupChannel} = require('./../macros');
 const {waitForPendingChannel} = require('./../macros');
 
+const anchorsFeatureBit = 23;
 const defaultFee = 1e3;
-const giftTokens = 1e4;
+const give = 1e4;
+const size = 2;
 
 // Getting pending channels should show pending channels
 test(`Get pending channels`, async ({end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [{generate, lnd}, target] = nodes;
 
   const {features} = await getWalletInfo({lnd});
 
-  const isAnchors = !!features.find(n => n.bit === 23);
+  const isAnchors = !!features.find(n => n.bit === anchorsFeatureBit);
 
   // Target starts a channel with control
-  const coopChan = await setupChannel({
-    lnd,
-    generate: cluster.generate,
-    give: giftTokens,
-    to: cluster.target,
-  });
+  const coopChan = await setupChannel({generate, give, lnd, to: target});
 
   // Target closes the channel
   const niceClose = await closeChannel({
-    lnd: cluster.target.lnd,
-    public_key: cluster.target.public_key,
-    socket: cluster.target.socket,
+    lnd: target.lnd,
     tokens_per_vbyte: defaultFee,
     transaction_id: coopChan.transaction_id,
     transaction_vout: coopChan.transaction_vout,
@@ -39,7 +34,7 @@ test(`Get pending channels`, async ({end, equal}) => {
 
   // Control views their pending channels
   const {channel} = await waitForPendingChannel({
-    lnd: cluster.control.lnd,
+    lnd,
     id: coopChan.transaction_id,
   });
 
@@ -61,7 +56,7 @@ test(`Get pending channels`, async ({end, equal}) => {
   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, cluster.target.public_key, 'target pubk');
+  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');
@@ -74,10 +69,10 @@ test(`Get pending channels`, async ({end, equal}) => {
   equal(channel.transaction_weight, null, 'No funding tx weight data');
 
   if (!!channel.remote_balance) {
-    equal(channel.remote_balance, giftTokens, 'Opposing channel balance');
+    equal(channel.remote_balance, give, 'Opposing channel balance');
   }
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_pending_force.js

@@ -1,9 +1,10 @@
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
+const {addPeer} = require('./../../');
 const {closeChannel} = require('./../../');
-const {createCluster} = require('./../macros');
-const {delay} = require('./../macros');
+const {getChainBalance} = require('./../../');
 const {getChannels} = require('./../../');
 const {getHeight} = require('./../../');
 const {getPeers} = require('./../../');
@@ -14,35 +15,42 @@ const {waitChannel} = require('./../macros');
 const {waitPendingChannel} = require('./../macros');
 const {waitForUtxo} = require('./../macros');
 
+const anchorFeatureBit = 23;
 const channelCapacityTokens = 1e6;
 const confirmationCount = 20;
+const count = 100;
 const defaultFee = 1e3;
 const defaultVout = 0;
 const giftTokens = 1e4;
-const interval = retryCount => 10 * Math.pow(2, retryCount);
+const interval = 10;
+const size = 2;
 const spendableRatio = 0.99;
-const times = 20;
+const times = 2000;
 
 // Getting pending channels should show pending channels
 test(`Get pending channels`, async ({end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [{generate, lnd}, target] = nodes;
 
   const {features} = await getWalletInfo({lnd});
 
-  const isAnchors = !!features.find(n => n.bit === 23);
-  const startHeight = (await getHeight({lnd})).current_block_height
+  const isAnchors = !!features.find(n => n.bit === anchorFeatureBit);
+  const startHeight = (await getHeight({lnd})).current_block_height;
+
+  await generate({count});
 
   const channelOpen = await asyncRetry({interval, times}, async () => {
+    await addPeer({lnd, public_key: target.id, socket: target.socket});
+
     return await openChannel({
       lnd,
       chain_fee_tokens_per_vbyte: defaultFee,
       give_tokens: giftTokens,
       local_tokens: channelCapacityTokens,
       partner_csv_delay: 10,
-      partner_public_key: cluster.target.public_key,
-      socket: cluster.target.socket,
+      partner_public_key: target.id,
+      socket: target.socket,
     });
   });
 
@@ -65,7 +73,7 @@ test(`Get pending channels`, async ({end, equal}) => {
   equal(pendingOpen.is_closing, false, 'Not closing yet');
   equal(pendingOpen.is_opening, true, 'Channel is opening');
   equal(pendingOpen.local_reserve, 10000, 'Local reserve amount');
-  equal(pendingOpen.partner_public_key, cluster.target_node_public_key, 'Key');
+  equal(pendingOpen.partner_public_key, target.id, 'Key');
   equal(pendingOpen.pending_balance, undefined, 'No pending chain balance');
   equal(pendingOpen.pending_payments, undefined, 'No pending payments');
   equal(pendingOpen.received, 0, 'Nothing received');
@@ -75,9 +83,9 @@ test(`Get pending channels`, async ({end, equal}) => {
   equal(pendingOpen.sent, 0, 'Nothing sent');
   equal(pendingOpen.timelock_expiration, undefined, 'Not timelocked');
   equal(pendingOpen.transaction_id, channelOpen.transaction_id, 'Open tx id');
-  equal(pendingOpen.transaction_vout, channelOpen.transaction_vout, 'Tx vout');
+  equal(pendingOpen.transaction_vout, channelOpen.transaction_vout, 'Tx out');
 
-  await cluster.generate({count: confirmationCount});
+  await generate({count: confirmationCount});
 
   await getChannels({lnd, id: channelOpen.transaction_id});
 
@@ -108,7 +116,7 @@ test(`Get pending channels`, async ({end, equal}) => {
   equal(waitClose.is_closing, true, 'Channel is closing');
   equal(waitClose.is_opening, false, 'Not opening channel');
   equal(waitClose.local_reserve, 10000, 'Local reserve of closing channel');
-  equal(waitClose.partner_public_key, cluster.target_node_public_key, 'Pkey');
+  equal(waitClose.partner_public_key, target.id, 'Pkey');
   equal(waitClose.pending_payments, undefined, 'No pending payments data');
   equal(waitClose.received, 0, 'Nothing received');
   equal(waitClose.recovered_tokens, undefined, 'Funds not recovered yet');
@@ -116,7 +124,7 @@ test(`Get pending channels`, async ({end, equal}) => {
   equal(waitClose.sent, 0, 'No sent tokens');
   equal(waitClose.timelock_expiration, undefined, 'No timelock data');
   equal(waitClose.transaction_fee, null, 'No tx fee data');
-  equal(waitClose.transaction_id, channelOpen.transaction_id, 'Funding tx id');
+  equal(waitClose.transaction_id, channelOpen.transaction_id, 'Funding txid');
   equal(waitClose.transaction_vout, channelOpen.transaction_vout, 'Tx vout');
   equal(waitClose.transaction_weight, null, 'No funding tx weight data');
 
@@ -127,12 +135,12 @@ test(`Get pending channels`, async ({end, equal}) => {
   equal(waitClose.sent, 0, 'Channel never sent funds');
   equal(waitClose.timelock_expiration, undefined, 'Not timelocked yet');
   equal(waitClose.transaction_id, channelOpen.transaction_id, 'Chan txid');
-  equal(waitClose.transaction_vout, channelOpen.transaction_vout, 'Chan vout');
+  equal(waitClose.transaction_vout, channelOpen.transaction_vout, 'Chan out');
 
   // Wait for generation to be over
   await asyncRetry({interval, times}, async () => {
     // Generate to confirm the tx
-    await cluster.generate({});
+    await generate({});
 
     const [forceClose] = (await getPendingChannels({lnd})).pending_channels;
 
@@ -163,17 +171,17 @@ test(`Get pending channels`, async ({end, equal}) => {
   equal(forceClose.is_closing, true, 'Channel is force closing');
   equal(forceClose.is_timelocked, true, 'Force close funds are timelocked')
   equal(forceClose.is_opening, false, 'Channel is not opening');
-  equal(forceClose.partner_public_key, cluster.target_node_public_key, 'pk');
+  equal(forceClose.partner_public_key, target.id, 'pk');
   equal(forceClose.received, 0, 'No receive amount');
   equal(forceClose.recovered_tokens, undefined, 'No recovered amount');
   equal(forceClose.remote_balance, 0, 'No remote balance');
   equal(forceClose.sent, 0, 'No sent amount');
   equal(!!forceClose.timelock_blocks, true, 'Timelock blocks set');
-  equal(forceClose.timelock_expiration, startHeight + 165, 'Funds timelocked');
+  equal(forceClose.timelock_expiration, startHeight + 265, 'Funds timelock');
   equal(forceClose.transaction_id, channelOpen.transaction_id, 'Chan-Txid');
-  equal(forceClose.transaction_vout, channelOpen.transaction_vout, 'ChanVout');
+  equal(forceClose.transaction_vout, channelOpen.transaction_vout, 'ChanOut');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_route_to_destination.js

@@ -1,10 +1,13 @@
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {addPeer} = require('./../../');
+const {cancelHodlInvoice} = require('./../../');
 const {createCluster} = require('./../macros');
 const {createInvoice} = require('./../../');
 const {decodePaymentRequest} = require('./../../');
+const {delay} = require('./../macros');
 const {getInvoice} = require('./../../');
 const {getRouteToDestination} = require('./../../');
 const {parsePaymentRequest} = require('./../../');
@@ -12,48 +15,52 @@ const {payViaRoutes} = require('./../../');
 const {setupChannel} = require('./../macros');
 
 const all = promise => Promise.all(promise);
-const interval = retryCount => 50 * Math.pow(2, retryCount);
+const interval = 10;
 const {isArray} = Array;
 const message = {type: '85805', value: '01'};
-const times = 15;
-const tokens = 100;
+const size = 3;
+const times = 3000;
+const tokens = 1000;
 
 // Getting a route to a destination should return a route to the destination
 test(`Get a route to a destination`, async ({end, equal, strictSame}) => {
-  const cluster = await createCluster({});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  {
-    const {lnd} = cluster.target;
+  const [control, target, remote] = nodes;
 
-    const {request} = await createInvoice({lnd});
-
-    // Exit test early if features are not supported
-    if (!(await decodePaymentRequest({lnd, request})).features.length) {
-      await cluster.kill({});
-
-      return end();
-    }
-  }
+  await control.generate({count: 500});
 
   await setupChannel({
-    generate: cluster.generate,
-    lnd: cluster.control.lnd,
-    to: cluster.target,
+    generate: control.generate,
+    lnd: control.lnd,
+    to: target,
   });
 
   await setupChannel({
-    generate: cluster.generate,
-    generator: cluster.target,
+    generate: target.generate,
     give: 1e5,
     hidden: true,
-    lnd: cluster.target.lnd,
-    to: cluster.remote,
+    lnd: target.lnd,
+    to: remote,
   });
 
-  const invoice = await createInvoice({
-    tokens,
-    is_including_private_channels: true,
-    lnd: cluster.remote.lnd,
+  const invoice = await asyncRetry({interval, times}, async () => {
+    const invoice = await createInvoice({
+      tokens,
+      is_including_private_channels: true,
+      lnd: remote.lnd,
+    });
+
+    const {routes} = parsePaymentRequest({request: invoice.request});
+
+    // Wait for private routes to get picked up
+    if (!routes) {
+      await cancelHodlInvoice({id: invoice.id, lnd: remote.lnd});
+
+      throw new Error('ExpectedRouteForInvoice');
+    }
+
+    return invoice;
   });
 
   const parsed = parsePaymentRequest({request: invoice.request});
@@ -62,7 +69,7 @@ test(`Get a route to a destination`, async ({end, equal, strictSame}) => {
     const {route} = await getRouteToDestination({
       destination: parsed.destination,
       features: parsed.features,
-      lnd: cluster.control.lnd,
+      lnd: control.lnd,
       payment: parsed.payment,
       routes: parsed.routes,
       mtokens: parsed.mtokens,
@@ -71,37 +78,37 @@ test(`Get a route to a destination`, async ({end, equal, strictSame}) => {
 
     const paid = await payViaRoutes({
       id: parsed.id,
-      lnd: cluster.control.lnd,
+      lnd: control.lnd,
       routes: [route],
     });
 
     equal(invoice.secret, paid.secret, 'Paid multi-hop private route');
   });
 
-  const inv = await createInvoice({tokens, lnd: cluster.target.lnd});
+  const inv = await createInvoice({tokens, lnd: target.lnd});
 
   const invDetails = await decodePaymentRequest({
-    lnd: cluster.control.lnd,
+    lnd: control.lnd,
     request: inv.request,
   });
 
   const controlToTarget = await getRouteToDestination({
-    destination: cluster.target.public_key,
+    destination: target.id,
     features: invDetails.features,
-    lnd: cluster.control.lnd,
+    lnd: control.lnd,
     messages: [message],
     payment: invDetails.payment,
-    tokens: invDetails.tokens / [cluster.control, cluster.remote].length,
+    tokens: invDetails.tokens / [control, remote].length,
     total_mtokens: invDetails.mtokens,
   });
 
   const remoteToTarget = await getRouteToDestination({
-    destination: cluster.target.public_key,
+    destination: target.id,
     features: invDetails.features,
-    lnd: cluster.remote.lnd,
+    lnd: remote.lnd,
     messages: [message],
     payment: invDetails.payment,
-    tokens: invDetails.tokens / [cluster.control, cluster.remote].length,
+    tokens: invDetails.tokens / [control, remote].length,
     total_mtokens: invDetails.mtokens,
   });
 
@@ -109,12 +116,12 @@ test(`Get a route to a destination`, async ({end, equal, strictSame}) => {
     const [controlPay, remotePay] = await all([
       payViaRoutes({
         id: invDetails.id,
-        lnd: cluster.control.lnd,
+        lnd: control.lnd,
         routes: [controlToTarget.route],
       }),
       payViaRoutes({
         id: invDetails.id,
-        lnd: cluster.remote.lnd,
+        lnd: remote.lnd,
         routes: [remoteToTarget.route],
       }),
     ]);
@@ -124,7 +131,7 @@ test(`Get a route to a destination`, async ({end, equal, strictSame}) => {
 
     const {payments} = await getInvoice({
       id: invDetails.id,
-      lnd: cluster.target.lnd,
+      lnd: target.lnd,
     });
 
     const [payment1, payment2] = payments;
@@ -138,7 +145,7 @@ test(`Get a route to a destination`, async ({end, equal, strictSame}) => {
     equal(err, null, 'Unexpected error paying invoice');
   }
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_utxos.js

@@ -1,72 +1,47 @@
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {chainSendTransaction} = require('./../macros');
 const {createChainAddress} = require('./../../');
-const {generateBlocks} = require('./../macros');
+const {getChainBalance} = require('./../../');
 const {getUtxos} = require('./../../');
-const {mineTransaction} = require('./../macros');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
-const {waitForUtxo} = require('./../macros');
 
-const count = 100;
-const defaultFee = 1e3;
-const defaultVout = 0;
-const format = 'np2wpkh';
+const format = 'p2wpkh';
+const times = 300;
 const tokens = 1e8;
 
 // Getting utxos should list out the utxos
 test(`Get utxos`, async ({end, equal, fail, strictSame}) => {
-  const node = await asyncRetry({}, async () => await spawnLnd({}));
+  const {kill, nodes} = await spawnLightningCluster({});
 
-  const cert = node.chain_rpc_cert_file;
-  const host = node.listen_ip;
-  const {kill} = node;
-  const pass = node.chain_rpc_pass;
-  const port = node.chain_rpc_port;
-  const {lnd} = node;
-  const user = node.chain_rpc_user;
-
-  const {address} = await createChainAddress({format, lnd});
+  const [{generate, lnd}] = nodes;
 
   // Generate some funds for LND
-  const {blocks} = await node.generate({count});
-
-  const [block] = blocks;
+  await asyncRetry({times}, async () => {
+    await generate({});
 
-  const [coinbaseTransaction] = block.transaction_ids;
+    const wallet = await getChainBalance({lnd});
 
-  const {transaction} = chainSendTransaction({
-    tokens,
-    destination: address,
-    fee: defaultFee,
-    private_key: node.mining_key,
-    spend_transaction_id: coinbaseTransaction,
-    spend_vout: defaultVout,
+    if (!wallet.chain_balance) {
+      throw new Error('ExpectedChainBalanceForNode');
+    }
   });
 
-  await mineTransaction({cert, host, pass, port, transaction, user});
-
-  await waitForUtxo({confirmations: 6, lnd, transaction});
-
   const {utxos} = await getUtxos({lnd});
 
-  equal(utxos.length, [transaction].length, 'Unspent output returned');
+  equal(!!utxos.length, true, 'Unspent output returned');
 
   const [utxo] = utxos;
 
-  equal(utxo.address, address, 'UTXO address returned');
+  equal(!!utxo.address, true, 'UTXO address returned');
   equal(utxo.address_format, format, 'UTXO address format returned');
-  equal(utxo.confirmation_count, 6, 'Confirmation count returned');
+  equal(utxo.confirmation_count, 100, 'Confirmation count returned');
   equal(!!utxo.output_script, true, 'Output script returned');
-  equal(utxo.tokens, tokens - defaultFee, 'UTXO amount returned');
+  equal(!!utxo.tokens, true, 'UTXO amount returned');
   equal(!!utxo.transaction_id, true, 'UTXO transaction id returned');
   equal(utxo.transaction_vout !== undefined, true, 'UTXO vout returned');
 
-  kill();
-
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_wallet_info.js

@@ -1,8 +1,7 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {getWalletInfo} = require('./../../');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
 
 const initHeight = 1;
 const pubKeyHexLength = Buffer.alloc(33).toString('hex').length;
@@ -11,31 +10,25 @@ const walletInfoType = 'wallet';
 
 // Getting the wallet info should return info about the wallet
 test(`Get wallet info`, async ({end, equal, strictSame}) => {
-  const spawned = await spawnLnd({});
+  const {kill, nodes} = await spawnLightningCluster({});
 
-  const {lnd} = spawned;
-  const pubKey = spawned.public_key;
+  const [{lnd}] = nodes;
 
   const result = await getWalletInfo({lnd});
 
-  const expectedUri = `${pubKey}@127.0.0.1:${spawned.listen_port}`;
-
   equal(result.active_channels_count, 0, 'Expected channels count');
   equal(!!result.alias, true, 'Expected alias');
   strictSame(result.chains, [regtestChainId], 'Got chains');
   equal(!!result.current_block_hash, true, 'Expected best block hash');
   equal(result.current_block_height, initHeight, 'Expected best block height');
-  equal(result.is_synced_to_chain, true, 'Expected synced to chain status');
   equal(!!result.latest_block_at, true, 'Last block time');
   equal(result.peers_count, 0, 'Expected wallet peers count');
   equal(result.pending_channels_count, 0, 'Expected pending channels count');
   equal(result.public_key.length, pubKeyHexLength, 'Expected public key');
-  strictSame(result.uris, [expectedUri], 'Expected node URI');
+  strictSame(result.uris.length, 1, 'Expected node URI');
   equal(!!result.version, true, 'Expected version');
 
-  spawned.kill({});
-
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });