ln-service 54.1.2 → 54.2.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Versions
 
+## 54.2.0
+
+- `openChannel`, `openChannels`: Add `base_fee_mtokens`, `fee_rate` to set
+    initial routing fee rate.
+
 ## 54.1.2
 
 - `subscribeToRpcRequests`: Fix support for LND 0.15.1

package/README.md

@@ -3571,9 +3571,14 @@ If give_tokens is set, it is a gift and it does not alter the capacity
 
 Requires `offchain:write`, `onchain:write`, `peers:write` permissions
 
+`base_fee_mtokens` is not supported on LND 0.15.2 and below
+`fee_rate` is not supported on LND 0.15.2 and below
+
     {
+      [base_fee_mtokens]: <Routing Base Fee Millitokens Charged String>
       [chain_fee_tokens_per_vbyte]: <Chain Fee Tokens Per VByte Number>
       [cooperative_close_address]: <Restrict Cooperative Close To Address String>
+      [fee_rate]: <Routing Fee Rate In Millitokens Per Million Number>
       [give_tokens]: <Tokens to Gift To Partner Number> // Defaults to zero
       [is_private]: <Channel is Private Bool> // Defaults to false
       lnd: <Authenticated LND API Object>
@@ -3619,10 +3624,15 @@ after the funding step.
 `--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.
 
+`base_fee_mtokens` is not supported on LND 0.15.2 and below
+`fee_rate` is not supported on LND 0.15.2 and below
+
     {
       channels: [{
+        [base_fee_mtokens]: <Routing Base Fee Millitokens Charged String>
         capacity: <Channel Capacity Tokens Number>
         [cooperative_close_address]: <Restrict Coop Close To Address String>
+        [fee_rate]: <Routing Fee Rate In Millitokens Per Million Number>
         [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>

package/package.json

@@ -11,7 +11,7 @@
     "cors": "2.8.5",
     "express": "4.18.1",
     "invoices": "2.2.0",
-    "lightning": "6.1.2",
+    "lightning": "6.2.0",
     "macaroon": "3.0.4",
     "morgan": "1.10.0",
     "ws": "8.9.0"
@@ -28,7 +28,7 @@
     "bn.js": "5.2.1",
     "bs58check": "2.1.2",
     "ecpair": "2.1.0",
-    "ln-docker-daemons": "3.0.1",
+    "ln-docker-daemons": "3.1.0",
     "p2tr": "1.3.2",
     "portfinder": "1.0.32",
     "psbt": "2.7.1",
@@ -71,5 +71,5 @@
     "integration-test-0.12.0": "DOCKER_LND_VERSION=v0.12.0-beta npm run test",
     "test": "echo $DOCKER_LND_VERSION && tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 200 test/autopilotrpc-integration/*.js test/chainrpc-integration/*.js test/integration/*.js test/invoicesrpc-integration/*.js test/peersrpc-integration/*.js test/routerrpc-integration/*.js test/signerrpc-integration/*.js test/tower_clientrpc-integration/*.js test/tower_serverrpc-integration/*.js test/walletrpc-integration/*.js"
   },
-  "version": "54.1.2"
+  "version": "54.2.0"
 }

package/test/chainrpc-integration/test_subscribe_to_blocks.js

@@ -14,7 +14,7 @@ const {subscribeToBlocks} = require('./../../');
 const {waitForTermination} = require('./../macros');
 
 const confirmationCount = 6;
-const interval = 1;
+const interval = 10;
 const race = promises => Promise.race(promises);
 const times = 4000;
 

package/test/integration/test_grant_access.js

@@ -1,19 +1,15 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {authenticatedLndGrpc} = require('./../../');
 const {createChainAddress} = require('./../../');
 const {getWalletVersion} = require('./../../');
 const {grantAccess} = require('./../../');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
 
 const format = 'np2wpkh';
 
 // Granting access should result in access granted
 test(`Get access credentials`, async ({end, equal, rejects, strictSame}) => {
-  const spawned = await spawnLnd({});
-
-  const {lnd, kill} = spawned;
+  const [{lnd, kill, rpc}] = (await spawnLightningCluster({})).nodes;
 
   await grantAccess({lnd, is_ok_to_create_chain_addresses: true});
 
@@ -27,17 +23,11 @@ test(`Get access credentials`, async ({end, equal, rejects, strictSame}) => {
 
   strictSame(makeChainAddresses.permissions, permissions, 'Got permissions');
 
-  const canPay = authenticatedLndGrpc({
-    cert: spawned.lnd_cert,
+  const canPay = rpc({
     macaroon: (await grantAccess({lnd, is_ok_to_pay: true})).macaroon,
-    socket: `localhost:${spawned.rpc_port}`,
   });
 
-  const makeAddress = authenticatedLndGrpc({
-    cert: spawned.lnd_cert,
-    macaroon: makeChainAddresses.macaroon,
-    socket: `localhost:${spawned.rpc_port}`,
-  });
+  const makeAddress = rpc({macaroon: makeChainAddresses.macaroon});
 
   await rejects(
     grantAccess({lnd: makeAddress.lnd, is_ok_to_create_chain_addresses: true}),
@@ -64,10 +54,8 @@ test(`Get access credentials`, async ({end, equal, rejects, strictSame}) => {
       methods: ['createChainAddress'],
     });
 
-    const authenticatedToCreateAddress = authenticatedLndGrpc({
-      cert: spawned.lnd_cert,
+    const authenticatedToCreateAddress = rpc({
       macaroon: createChainAddressCredential.macaroon,
-      socket: `localhost:${spawned.rpc_port}`,
     });
 
     const created = await createChainAddress({
@@ -78,9 +66,7 @@ test(`Get access credentials`, async ({end, equal, rejects, strictSame}) => {
     equal(!!created, true, 'Can make address with URI credential');
   }
 
-  kill();
-
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });

package/test/integration/test_open_channel.js

@@ -5,12 +5,17 @@ const {test} = require('@alexbosworth/tap');
 const {addPeer} = require('./../../');
 const {createChainAddress} = require('./../../');
 const {getChainBalance} = require('./../../');
+const {getChannel} = require('./../../');
+const {getChannels} = require('./../../');
 const {openChannel} = require('./../../');
 
+const baseFee = '1337';
 const channelCapacityTokens = 1e6;
 const count = 100;
+const defaultBaseFee = '1000';
 const defaultFee = 1e3;
 const defaultVout = 0;
+const feeRate = 420;
 const giftTokens = 1000;
 const interval = 250;
 const size = 2;
@@ -21,7 +26,7 @@ const txIdHexLength = 32 * 2;
 test(`Open channel`, async ({end, equal}) => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
-  const [{generate, lnd}, target] = nodes;
+  const [{generate, id, lnd}, target] = nodes;
 
   const {address} = await createChainAddress({lnd});
 
@@ -32,8 +37,10 @@ test(`Open channel`, async ({end, equal}) => {
 
     return await openChannel({
       lnd,
+      base_fee_mtokens: baseFee,
       chain_fee_tokens_per_vbyte: defaultFee,
       cooperative_close_address: address,
+      fee_rate: feeRate,
       give_tokens: giftTokens,
       local_tokens: channelCapacityTokens,
       partner_public_key: target.id,
@@ -44,6 +51,30 @@ test(`Open channel`, async ({end, equal}) => {
   equal(channelOpen.transaction_id.length, txIdHexLength, 'Channel tx id');
   equal(channelOpen.transaction_vout, defaultVout, 'Channel tx output index');
 
+  await asyncRetry({interval, times}, async () => {
+    await generate({});
+
+    const {channels} = await getChannels({lnd});
+
+    const [channel] = channels;
+
+    if (!channel) {
+      throw new Error('ExpectedChannelOpened');
+    }
+
+    const {policies} = await getChannel({lnd, id: channel.id});
+
+    const policy = policies.find(n => n.public_key === id);
+
+    // LND 0.15.2 and below do not support setting fees on open
+    if (policy.base_fee_mtokens === defaultBaseFee) {
+      return;
+    }
+
+    equal(policy.base_fee_mtokens, baseFee, 'Base fee is set');
+    equal(policy.fee_rate, feeRate, 'Fee rate is set');
+  });
+
   await kill({});
 
   return end();

package/test/integration/test_open_channels.js

@@ -13,15 +13,19 @@ const {delay} = require('./../macros');
 const {fundPendingChannels} = require('./../../');
 const {getChainBalance} = require('./../../');
 const {getChainTransactions} = require('./../../');
+const {getChannel} = require('./../../');
 const {getChannels} = require('./../../');
 const {getHeight} = require('./../../');
 const {getPeers} = require('./../../');
 const {openChannels} = require('./../../');
 const {sendToChainAddresses} = require('./../../');
 
+const baseFeeMtokens = '1234';
 const capacity = 1e6;
 const count = 10;
+const defaultBaseFee = '1000';
 const interval = 10;
+const feeRate = 56;
 const maturity = 100;
 const race = promises => Promise.race(promises);
 const size = 3;
@@ -61,7 +65,9 @@ test(`Open channels`, async ({end, equal}) => {
 
     const channels = [target, remote].map(({id}) => ({
       capacity,
+      base_fee_mtokens: baseFeeMtokens,
       cooperative_close_address: address,
+      fee_rate: feeRate,
       partner_public_key: id,
     }));
 
@@ -129,6 +135,18 @@ test(`Open channels`, async ({end, equal}) => {
 
       equal(channel.cooperative_close_address, address, 'Channel close addr');
 
+      const {policies} = await getChannel({lnd, id: channel.id});
+
+      const policy = policies.find(n => !!n.cltv_delta);
+
+      // LND 0.15.2 and below do not support setting fees on open
+      if (policy.base_fee_mtokens === defaultBaseFee) {
+        return;
+      }
+
+      equal(policy.base_fee_mtokens, baseFeeMtokens, 'Base fee is set');
+      equal(policy.fee_rate, feeRate, 'Fee rate is set');
+
       return;
     });
   } catch (err) {

package/test/integration/test_recover_funds_from_channel.js

@@ -0,0 +1,196 @@
+const asyncRetry = require('async/retry');
+const {getPortPromise: getPort} = require('portfinder');
+const {setupChannel} = require('ln-docker-daemons');
+const {spawnLightningDocker} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+
+const {addPeer} = require('./../../');
+const {authenticatedLndGrpc} = require('./../../');
+const {createChainAddress} = require('./../../');
+const {getBackup} = require('./../../');
+const {getIdentity} = require('./../../');
+const {getPendingChannels} = require('./../../');
+const {getUtxos} = require('./../../');
+const {recoverFundsFromChannel} = require('./../../');
+
+const confirmationCount = 20;
+const generateAddress = '2N8hwP1WmJrFF5QWABn38y63uYLhnJYJYTF';
+const giftTokens = 1e5;
+const interval = 10;
+const makeAddress = ({lnd}) => createChainAddress({lnd});
+const maturity = 100;
+const seed = 'about rabbit ozone hope jaguar quit scare twenty punch crisp consider clutch ring frost universe okay execute shrug drink notice abandon wine denial retreat';
+const times = 3000;
+
+// Using a channel backup should recover funds
+test(`Recover funds from channel`, async ({end, equal}) => {
+  const control = await spawnLightningDocker({
+    seed,
+    chain_p2p_port: await getPort({port: 8000, stopPort: 9000}),
+    chain_rpc_port: await getPort({port: 9001, stopPort: 10000}),
+    chain_zmq_block_port: await getPort({port: 10001, stopPort: 11000}),
+    chain_zmq_tx_port: await getPort({port: 11001, stopPort: 12000}),
+    generate_address: generateAddress,
+    lightning_p2p_port: await getPort({port: 12001, stopPort: 13000}),
+    lightning_rpc_port: await getPort({port: 13001, stopPort: 14000}),
+  });
+
+  const target = await spawnLightningDocker({
+    chain_p2p_port: await getPort({port: 8000, stopPort: 9000}),
+    chain_rpc_port: await getPort({port: 9001, stopPort: 10000}),
+    chain_zmq_block_port: await getPort({port: 10001, stopPort: 11000}),
+    chain_zmq_tx_port: await getPort({port: 11001, stopPort: 12000}),
+    generate_address: generateAddress,
+    lightning_p2p_port: await getPort({port: 12001, stopPort: 13000}),
+    lightning_rpc_port: await getPort({port: 13001, stopPort: 14000}),
+  });
+
+  await control.add_chain_peer({socket: target.chain_socket});
+  await target.add_chain_peer({socket: control.chain_socket});
+
+  const controlLnd = authenticatedLndGrpc({
+    cert: control.cert,
+    macaroon: control.macaroon,
+    socket: control.socket,
+  });
+
+  const id = (await getIdentity({lnd: controlLnd.lnd})).public_key;
+
+  const targetLnd = authenticatedLndGrpc({
+    cert: target.cert,
+    macaroon: target.macaroon,
+    socket: target.socket,
+  });
+
+  const targetId = (await getIdentity({lnd: targetLnd.lnd})).public_key;
+
+  const channelOpen = await setupChannel({
+    generate: ({address, count}) => {
+      return new Promise(async (resolve, reject) => {
+        const {lnd} = targetLnd;
+
+        await target.generate({
+          count,
+          address: (await makeAddress({lnd})).address,
+        });
+
+        if (!count || count < maturity) {
+          return resolve();
+        }
+
+        await asyncRetry({interval, times}, async () => {
+          const [utxo] = (await getUtxos({lnd})).utxos;
+
+          if (!utxo) {
+            throw new Error('ExpectedUtxoInUtxos');
+          }
+        });
+
+        return resolve();
+      });
+    },
+    give_tokens: giftTokens,
+    lnd: targetLnd.lnd,
+    to: {id, socket: control.ln_socket},
+  });
+
+  const {backup} = await getBackup({
+    lnd: controlLnd.lnd,
+    transaction_id: channelOpen.transaction_id,
+    transaction_vout: channelOpen.transaction_vout,
+  });
+
+  await control.kill({});
+
+  const clone = await spawnLightningDocker({
+    seed,
+    chain_p2p_port: await getPort({port: 8000, stopPort: 9000}),
+    chain_rpc_port: await getPort({port: 9001, stopPort: 10000}),
+    chain_zmq_block_port: await getPort({port: 10001, stopPort: 11000}),
+    chain_zmq_tx_port: await getPort({port: 11001, stopPort: 12000}),
+    generate_address: generateAddress,
+    lightning_p2p_port: await getPort({port: 12001, stopPort: 13000}),
+    lightning_rpc_port: await getPort({port: 13001, stopPort: 14000}),
+  });
+
+  await clone.add_chain_peer({socket: target.chain_socket});
+
+  await target.add_chain_peer({socket: clone.chain_socket});
+
+  const cloneLnd = authenticatedLndGrpc({
+    cert: clone.cert,
+    macaroon: clone.macaroon,
+    socket: clone.socket,
+  });
+
+  await addPeer({
+    lnd: cloneLnd.lnd,
+    public_key: targetId,
+    socket: target.ln_socket,
+  });
+
+  await asyncRetry({interval, times}, async () => {
+    await recoverFundsFromChannel({backup, lnd: cloneLnd.lnd});
+  });
+
+  await clone.generate({
+    address: generateAddress,
+    count: confirmationCount,
+  });
+
+  await target.generate({
+    address: generateAddress,
+    count: confirmationCount,
+  });
+
+  // Target should force close the channel
+  {
+    const {lnd} = targetLnd;
+
+    await asyncRetry({interval, times}, async () => {
+      await addPeer({
+        lnd: cloneLnd.lnd,
+        public_key: targetId,
+        socket: target.ln_socket,
+      });
+
+      const [chan] = (await getPendingChannels({lnd})).pending_channels;
+
+      if (!chan) {
+        throw new Error('ExpectedChannelClosing');
+      }
+    });
+  }
+
+  // Make sure that the clone is getting the recovered funds
+  {
+    const {lnd} = cloneLnd;
+
+    await asyncRetry({interval, times}, async () => {
+      const [chan] = (await getPendingChannels({lnd})).pending_channels;
+
+      await target.generate({address: generateAddress});
+
+      if (!chan.local_balance) {
+        throw new Error('ExpectedChannelClosingBalance');
+      }
+    });
+
+    const [chan] = (await getPendingChannels({lnd})).pending_channels;
+
+    equal(!!chan.close_transaction_id, true, 'Close transaction id found');
+    equal(chan.is_active, false, 'Chan no longer active');
+    equal(chan.is_closing, true, 'Channel is closing');
+    equal(chan.is_opening, false, 'Channel closing');
+    equal(chan.local_balance, giftTokens, 'Funds are being restored');
+    equal(chan.partner_public_key, targetId, 'Peer key');
+    equal(chan.transaction_id, channelOpen.transaction_id, 'Chan tx id');
+    equal(chan.transaction_vout, channelOpen.transaction_vout, 'Chan tx vout');
+  }
+
+  await clone.kill({});
+
+  await target.kill({});
+
+  return end();
+});

package/test/integration/test_recover_funds_from_channels.js

@@ -0,0 +1,198 @@
+const asyncRetry = require('async/retry');
+const {getPortPromise: getPort} = require('portfinder');
+const {setupChannel} = require('ln-docker-daemons');
+const {spawnLightningDocker} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+
+const {addPeer} = require('./../../');
+const {authenticatedLndGrpc} = require('./../../');
+const {createChainAddress} = require('./../../');
+const {getBackups} = require('./../../');
+const {getIdentity} = require('./../../');
+const {getPendingChannels} = require('./../../');
+const {getUtxos} = require('./../../');
+const {recoverFundsFromChannels} = require('./../../');
+
+const confirmationCount = 20;
+const generateAddress = '2N8hwP1WmJrFF5QWABn38y63uYLhnJYJYTF';
+const giftTokens = 1e5;
+const interval = 10;
+const makeAddress = ({lnd}) => createChainAddress({lnd});
+const maturity = 100;
+const seed = 'about rabbit ozone hope jaguar quit scare twenty punch crisp consider clutch ring frost universe okay execute shrug drink notice abandon wine denial retreat';
+const times = 3000;
+
+// Using a channels backup should recover funds
+test(`Recover funds from channels`, async ({end, equal}) => {
+  const control = await asyncRetry({interval, times}, async () => {
+    return await spawnLightningDocker({
+      seed,
+      chain_p2p_port: await getPort({port: 8000, stopPort: 9000}),
+      chain_rpc_port: await getPort({port: 9001, stopPort: 10000}),
+      chain_zmq_block_port: await getPort({port: 10001, stopPort: 11000}),
+      chain_zmq_tx_port: await getPort({port: 11001, stopPort: 12000}),
+      generate_address: generateAddress,
+      lightning_p2p_port: await getPort({port: 12001, stopPort: 13000}),
+      lightning_rpc_port: await getPort({port: 13001, stopPort: 14000}),
+    });
+  });
+
+  const target = await asyncRetry({interval, times}, async () => {
+    return await spawnLightningDocker({
+      chain_p2p_port: await getPort({port: 8000, stopPort: 9000}),
+      chain_rpc_port: await getPort({port: 9001, stopPort: 10000}),
+      chain_zmq_block_port: await getPort({port: 10001, stopPort: 11000}),
+      chain_zmq_tx_port: await getPort({port: 11001, stopPort: 12000}),
+      generate_address: generateAddress,
+      lightning_p2p_port: await getPort({port: 12001, stopPort: 13000}),
+      lightning_rpc_port: await getPort({port: 13001, stopPort: 14000}),
+    });
+  });
+
+  await control.add_chain_peer({socket: target.chain_socket});
+  await target.add_chain_peer({socket: control.chain_socket});
+
+  const controlLnd = authenticatedLndGrpc({
+    cert: control.cert,
+    macaroon: control.macaroon,
+    socket: control.socket,
+  });
+
+  const id = (await getIdentity({lnd: controlLnd.lnd})).public_key;
+
+  const targetLnd = authenticatedLndGrpc({
+    cert: target.cert,
+    macaroon: target.macaroon,
+    socket: target.socket,
+  });
+
+  const targetId = (await getIdentity({lnd: targetLnd.lnd})).public_key;
+
+  const channelOpen = await setupChannel({
+    generate: ({address, count}) => {
+      return new Promise(async (resolve, reject) => {
+        const {lnd} = targetLnd;
+
+        await target.generate({
+          count,
+          address: (await makeAddress({lnd})).address,
+        });
+
+        if (!count || count < maturity) {
+          return resolve();
+        }
+
+        await asyncRetry({interval, times}, async () => {
+          const [utxo] = (await getUtxos({lnd})).utxos;
+
+          if (!utxo) {
+            throw new Error('ExpectedUtxoInUtxos');
+          }
+        });
+
+        return resolve();
+      });
+    },
+    give_tokens: giftTokens,
+    lnd: targetLnd.lnd,
+    to: {id, socket: control.ln_socket},
+  });
+
+  const {backup} = await getBackups({lnd: controlLnd.lnd});
+
+  await control.kill({});
+
+  const clone = await asyncRetry({interval, times}, async () => {
+    return await spawnLightningDocker({
+      seed,
+      chain_p2p_port: await getPort({port: 8000, stopPort: 9000}),
+      chain_rpc_port: await getPort({port: 9001, stopPort: 10000}),
+      chain_zmq_block_port: await getPort({port: 10001, stopPort: 11000}),
+      chain_zmq_tx_port: await getPort({port: 11001, stopPort: 12000}),
+      generate_address: generateAddress,
+      lightning_p2p_port: await getPort({port: 12001, stopPort: 13000}),
+      lightning_rpc_port: await getPort({port: 13001, stopPort: 14000}),
+    });
+  });
+
+  await clone.add_chain_peer({socket: target.chain_socket});
+
+  await target.add_chain_peer({socket: clone.chain_socket});
+
+  const cloneLnd = authenticatedLndGrpc({
+    cert: clone.cert,
+    macaroon: clone.macaroon,
+    socket: clone.socket,
+  });
+
+  await addPeer({
+    lnd: cloneLnd.lnd,
+    public_key: targetId,
+    socket: target.ln_socket,
+  });
+
+  await asyncRetry({interval, times}, async () => {
+    await recoverFundsFromChannels({backup, lnd: cloneLnd.lnd});
+  });
+
+  await clone.generate({
+    address: generateAddress,
+    count: confirmationCount,
+  });
+
+  await target.generate({
+    address: generateAddress,
+    count: confirmationCount,
+  });
+
+  // Target should force close the channel
+  {
+    const {lnd} = targetLnd;
+
+    await asyncRetry({interval, times}, async () => {
+      await addPeer({
+        lnd: cloneLnd.lnd,
+        public_key: targetId,
+        socket: target.ln_socket,
+      });
+
+      const [chan] = (await getPendingChannels({lnd})).pending_channels;
+
+      if (!chan) {
+        throw new Error('ExpectedChannelClosing');
+      }
+    });
+  }
+
+  // Make sure that the clone is getting the recovered funds
+  {
+    const {lnd} = cloneLnd;
+
+    await asyncRetry({interval, times}, async () => {
+      const [chan] = (await getPendingChannels({lnd})).pending_channels;
+
+      await target.generate({address: generateAddress});
+
+      if (!chan.local_balance) {
+        throw new Error('ExpectedChannelClosingBalance');
+      }
+    });
+
+    const [chan] = (await getPendingChannels({lnd})).pending_channels;
+
+    equal(!!chan.close_transaction_id, true, 'Close transaction id found');
+    equal(chan.is_active, false, 'Chan no longer active');
+    equal(chan.is_closing, true, 'Channel is closing');
+    equal(chan.is_opening, false, 'Channel closing');
+    equal(chan.local_balance, giftTokens, 'Funds are being restored');
+    equal(chan.partner_public_key, targetId, 'Peer key');
+    equal(chan.transaction_id, channelOpen.transaction_id, 'Chan tx id');
+    equal(chan.transaction_vout, channelOpen.transaction_vout, 'Chan tx vout');
+  }
+
+  await clone.kill({});
+
+  await target.kill({});
+
+  return end();
+});

package/test/macros/change_password.js

@@ -39,7 +39,7 @@ const readMacaroonFileName = 'readonly.macaroon';
 const retryCreateSeedCount = 500;
 const startPortRange = 7593;
 const startWalletTimeoutMs = 4500;
-const times = 100;
+const times = 200;
 
 /** Run a change password test
 

package/test/walletrpc-integration/test_broadcast_chain_transaction.js

@@ -1,57 +1,60 @@
+const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
-const tinysecp = require('tiny-secp256k1');
 
 const {broadcastChainTransaction} = require('./../../');
-const {chainSendTransaction} = require('./../macros');
 const {createChainAddress} = require('./../../');
-const {delay} = require('./../macros');
-const {generateBlocks} = require('./../macros');
+const {fundPsbt} = require('./../../');
 const {getChainTransactions} = require('./../../');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
+const {signPsbt} = require('./../../');
 
 const count = 100;
-const defaultVout = 0;
-const fee = 1e3;
-const format = 'np2wpkh';
+const description = 'description';
+const interval = 10;
+const times = 2000;
 const tokens = 1e8;
 
 // Test sending a chain transaction to Bitcoin network peers
-test(`Send chain transaction`, async ({end, equal}) => {
-  const node = await spawnLnd({});
+test(`Broadcast chain transaction`, async ({end, equal}) => {
+  const [{generate, kill, lnd}] = (await spawnLightningCluster({})).nodes;
 
-  const {lnd} = node;
+  try {
+    await generate({count});
 
-  // Generate some funds
-  const {blocks} = await node.generate({count});
+    const {address} = await createChainAddress({lnd});
 
-  const [block] = blocks;
+    const {psbt} = await fundPsbt({lnd, outputs: [{address, tokens}]});
 
-  const [coinbaseTransactionId] = block.transaction_ids;
+    const {transaction} = await signPsbt({lnd, psbt});
 
-  const {transaction} = chainSendTransaction({
-    fee,
-    tokens,
-    destination: (await createChainAddress({format, lnd})).address,
-    ecp: (await import('ecpair')).ECPairFactory(tinysecp),
-    private_key: node.mining_key,
-    spend_transaction_id: coinbaseTransactionId,
-    spend_vout: defaultVout,
-  });
+    const {id} = await broadcastChainTransaction({
+      description,
+      lnd,
+      transaction,
+    });
 
-  const {id} = await broadcastChainTransaction({transaction, lnd: node.lnd});
+    await asyncRetry({interval, times}, async () => {
+      const {transactions} = await getChainTransactions({lnd});
 
-  await delay(5000);
+      await generate({});
 
-  const {transactions} = await getChainTransactions({lnd});
+      const tx = transactions.find(n => n.id === id);
 
-  const [tx] = transactions;
+      if (!tx) {
+        throw new Error('ExpectedTransactionBroadcast');
+      }
 
-  equal(id, tx.id, 'Transaction is found in broadcast');
+      if (!tx.is_confirmed) {
+        throw new Error('ExpectedTransactionConfirmed');
+      }
 
-  node.kill();
+      equal(tx.description, description, 'Description is set');
+    });
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  }
 
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });

package/test/walletrpc-integration/test_request_chain_fee_increase.js

@@ -1,54 +1,43 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
-const tinysecp = require('tiny-secp256k1');
 
 const {broadcastChainTransaction} = require('./../../');
-const {chainSendTransaction} = require('./../macros');
 const {createChainAddress} = require('./../../');
-const {generateBlocks} = require('./../macros');
+const {fundPsbt} = require('./../../');
+const {getUtxos} = require('./../../');
 const {requestChainFeeIncrease} = require('./../../');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
+const {signPsbt} = require('./../../');
 
 const count = 100;
-const defaultVout = 0;
-const fee = 1e3;
-const format = 'np2wpkh';
 const tokens = 1e8;
 
-// Test requesting an increase in chain fees
+// Test requesting a chain fee increase
 test(`Request chain fee increase`, async ({end, equal}) => {
-  const node = await spawnLnd({});
+  const [{generate, kill, lnd}] = (await spawnLightningCluster({})).nodes;
 
-  const {lnd} = node;
+  try {
+    await generate({count});
 
-  // Generate some funds
-  const {blocks} = await node.generate({count});
+    const {address} = await createChainAddress({lnd});
 
-  const [block] = blocks;
+    const {psbt} = await fundPsbt({lnd, outputs: [{address, tokens}]});
 
-  const [coinbaseTransactionId] = block.transaction_ids;
+    const {transaction} = await signPsbt({lnd, psbt});
 
-  const {transaction} = chainSendTransaction({
-    fee,
-    tokens,
-    destination: (await createChainAddress({format, lnd})).address,
-    ecp: (await import('ecpair')).ECPairFactory(tinysecp),
-    private_key: node.mining_key,
-    spend_transaction_id: coinbaseTransactionId,
-    spend_vout: defaultVout,
-  });
+    await broadcastChainTransaction({lnd, transaction});
 
-  const {id} = await broadcastChainTransaction({transaction, lnd: node.lnd});
+    const bump = (await getUtxos({lnd})).utxos.find(n => n.tokens === tokens);
 
-  await requestChainFeeIncrease({
-    lnd,
-    transaction_id: id,
-    transaction_vout: Number(),
-  });
+    await requestChainFeeIncrease({
+      lnd,
+      transaction_id: bump.transaction_id,
+      transaction_vout: bump.transaction_vout,
+    });
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  }
 
-  node.kill();
-
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });

package/test/extra-integration/test_recover_funds_from_channel.js

@@ -1,85 +0,0 @@
-const {test} = require('@alexbosworth/tap');
-
-const {createCluster} = require('./../macros');
-const {delay} = require('./../macros');
-const {getBackup} = require('./../../');
-const {getPendingChannels} = require('./../../');
-const {recoverFundsFromChannel} = require('./../../');
-const {setupChannel} = require('./../macros');
-const {spawnLnd} = require('./../macros');
-const {stopDaemon} = require('./../../');
-const {waitForPendingChannel} = require('./../macros');
-const {waitForTermination} = require('./../macros');
-
-const channelCapacityTokens = 1e6;
-const confirmationCount = 20;
-const defaultFee = 1e3;
-const giftTokens = 1e5;
-const seed = 'abandon tank dose ripple foil subway close flock laptop cabbage primary silent plastic unhappy west weird panda plastic brave prefer diesel glad jazz isolate';
-
-// Using a channel backup should recover funds
-test(`Recover funds from channel`, async ({end, equal}) => {
-  const clone = await spawnLnd({seed});
-
-  const cluster = await createCluster({
-    is_remote_skipped: true,
-    nodes: [clone],
-  });
-
-  const {lnd} = cluster.control;
-
-  const channelOpen = await setupChannel({
-    generate: cluster.generate,
-    generator: cluster.target,
-    give: giftTokens,
-    lnd: cluster.target.lnd,
-    to: cluster.control,
-  });
-
-  const {backup} = await getBackup({
-    lnd,
-    transaction_id: channelOpen.transaction_id,
-    transaction_vout: channelOpen.transaction_vout,
-  });
-
-  await stopDaemon({lnd});
-
-  cluster.control.kill();
-
-  await recoverFundsFromChannel({backup, lnd: clone.lnd});
-
-  await delay(3000);
-
-  await cluster.generate({count: confirmationCount, node: clone});
-
-  await delay(3000);
-
-  await cluster.generate({count: confirmationCount, node: cluster.target});
-
-  await delay(3000);
-
-  await waitForPendingChannel({
-    id: channelOpen.transaction_id,
-    is_closing: true,
-    lnd: clone.lnd,
-  });
-
-  const [chan] = (await getPendingChannels({lnd: clone.lnd})).pending_channels;
-
-  equal(!!chan.close_transaction_id, true, 'Close transaction id found');
-  equal(chan.is_active, false, 'Chan no longer active');
-  equal(chan.is_closing, true, 'Channel is closing');
-  equal(chan.is_opening, false, 'Channel closing');
-  equal(chan.local_balance, giftTokens, 'Funds are being restored');
-  equal(chan.partner_public_key, cluster.target_node_public_key, 'Peer key');
-  equal(chan.transaction_id, channelOpen.transaction_id, 'Chan tx id');
-  equal(chan.transaction_vout, channelOpen.transaction_vout, 'Chan tx vout');
-
-  clone.kill();
-
-  await waitForTermination({lnd: clone.lnd});
-
-  await cluster.kill({});
-
-  return end();
-});

package/test/extra-integration/test_recover_funds_from_channels.js

@@ -1,112 +0,0 @@
-const asyncRetry = require('async/retry');
-const {test} = require('@alexbosworth/tap');
-
-const {createCluster} = require('./../macros');
-const {delay} = require('./../macros');
-const {getBackups} = require('./../../');
-const {getPendingChannels} = require('./../../');
-const {recoverFundsFromChannels} = require('./../../');
-const {spawnLnd} = require('./../macros');
-const {setupChannel} = require('./../macros');
-const {stopDaemon} = require('./../../');
-const {waitForPendingChannel} = require('./../macros');
-const {waitForTermination} = require('./../macros');
-
-const channelCapacityTokens = 1e6;
-const confirmationCount = 20;
-const defaultFee = 1e3;
-const giftTokens = 1e5;
-const seed = 'abandon tank dose ripple foil subway close flock laptop cabbage primary silent plastic unhappy west weird panda plastic brave prefer diesel glad jazz isolate';
-
-// Using the channels backup should recover funds
-test(`Recover funds with backup`, async ({end, equal}) => {
-  const clone = await spawnLnd({seed});
-
-  const cluster = await createCluster({
-    is_remote_skipped: true,
-    nodes: [clone],
-  });
-
-  let channelOpen;
-  const {lnd} = cluster.control;
-
-  try {
-    channelOpen = await setupChannel({
-      generate: cluster.generate,
-      generator: cluster.target,
-      give: giftTokens,
-      lnd: cluster.target.lnd,
-      to: cluster.control,
-    });
-  } catch (err) {
-    equal(err, null, 'Expected no error setting up a channel');
-
-    clone.kill();
-
-    await waitForTermination({lnd: clone.lnd});
-
-    await cluster.kill({});
-
-    return end();
-  }
-
-  await delay(3000);
-
-  const {backup} = await getBackups({lnd});
-
-  await delay(3000);
-
-  await stopDaemon({lnd});
-
-  try {
-    const recover = await recoverFundsFromChannels({backup, lnd: clone.lnd});
-
-    equal(recover, undefined, 'Recover does not return anything');
-  } catch (err) {
-    equal(err, null, 'An error is not expected');
-  }
-
-  await cluster.generate({count: confirmationCount, node: clone});
-
-  await waitForPendingChannel({
-    id: channelOpen.transaction_id,
-    is_recovering: true,
-    lnd: clone.lnd,
-  });
-
-  await delay(3000);
-
-  await cluster.generate({count: confirmationCount, node: clone});
-
-  await delay(3000);
-
-  await cluster.generate({count: confirmationCount, node: cluster.target});
-
-  const [chan] = (await getPendingChannels({lnd: clone.lnd})).pending_channels;
-
-  equal(!!chan.close_transaction_id, true, 'Close transaction id found');
-  equal(chan.is_active, false, 'Chan no longer active');
-  equal(chan.is_closing, true, 'Channel is closing');
-  equal(chan.is_opening, false, 'Channel closing');
-  equal(chan.local_balance, giftTokens, 'Funds are being restored');
-  equal(chan.partner_public_key, cluster.target_node_public_key, 'Peer key');
-  equal(chan.transaction_id, channelOpen.transaction_id, 'Chan tx id');
-  equal(chan.transaction_vout, channelOpen.transaction_vout, 'Chan tx vout');
-
-  const interval = retryCount => 50 * Math.pow(2, retryCount);
-  const times = 10;
-
-  await delay(3000);
-
-  clone.kill();
-
-  clone.kill();
-
-  clone.kill();
-
-  await waitForTermination({lnd: clone.lnd});
-
-  await cluster.kill({});
-
-  return end();
-});