paid-services 3.2.0 → 3.3.0

package/test/capacity/test_witness_script_from_close_txs.js

@@ -0,0 +1,53 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../capacity/witness_script_from_close_txs');
+
+const makeArgs = overrides => {
+  const args = {
+    closing_tx_id: '8c037c526683ac573903a8028e764b6aee1556d584c06f9a4287643774388ae9',
+    transactions: [{
+      block_id: undefined,
+      confirmation_count: undefined,
+      confirmation_height: undefined,
+      created_at: '2021-12-25T03:33:28.000Z',
+      description: '0:closechannel:shortchanid-112150186098688',
+      fee: undefined,
+      id: '8c037c526683ac573903a8028e764b6aee1556d584c06f9a4287643774388ae9',
+      is_confirmed: false,
+      is_outgoing: false,
+      output_addresses: [],
+      tokens: 0,
+      transaction: '02000000000101b2841e16bd8db0e960ca5d861336cb21e2adb999c2b7ffd8ba68a92950215752000000000093bfcb80024a0100000000000022002063db12b145998af3bc5122d454ca37d5a4690b69626584ac3d2fdb225eea1490b2340f00000000002200200bdb542d1a67fbb991413a01530f5d430f43a082e27efe11657fbf76a1734a0c0400483045022100c0ce0fab8d4c6e3f3a46035c80a3567a801de32cb0c69fff8c18e3e6a03a66c0022018881a1b79957fd1d201ee5696ad535a4a70d8f8addd1bcec6c65e21bb7c4c8f01473044022015ab404487a28dce1975b132377a112181a0a8d6564d0b01be07506808c571a302204cf66d2de2a5c499fd2f23d00c4dc8642d133b321c99dcade227ac8291671ffc0147522102404943cc648419553e1fa33e7b620c07cb1b7225a9437dfa849bb0b842e12f1121038af0a2a3cd6ca9bc1bd38e4a6fa005a7c92b3ddd9b0d4c2c816efa10cdcdadf652ae9d84ef20',
+    }],
+    transaction_id: '5257215029a968bad8ffb7c299b9ade221cb3613865dca60e9b08dbd161e84b2',
+    transaction_vout: 0,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({}),
+    description: 'Get the witness script from a list of close transactions',
+    expected: {
+      script: '522102404943cc648419553e1fa33e7b620c07cb1b7225a9437dfa849bb0b842e12f1121038af0a2a3cd6ca9bc1bd38e4a6fa005a7c92b3ddd9b0d4c2c816efa10cdcdadf652ae',
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => method(args), new Error(error), 'Got error');
+    } else {
+      const res = method(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/integration/test_accept_capacity_change.js

@@ -0,0 +1,152 @@
+const {address} = require('bitcoinjs-lib');
+const asyncAuto = require('async/auto');
+const asyncMap = require('async/map');
+const asyncRetry = require('async/retry');
+const {broadcastChainTransaction} = require('ln-service');
+const {closeChannel} = require('ln-service');
+const {createChainAddress} = require('ln-service');
+const {getChainTransactions} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {getNetwork} = require('ln-sync');
+const {networks} = require('bitcoinjs-lib');
+const {openChannel} = require('ln-service');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+const {Transaction} = require('bitcoinjs-lib');
+
+const accept = require('./../../capacity/accept_capacity_change');
+const finalize = require('./../../capacity/finalize_capacity_replacement');
+const method = require('./../../capacity/sign_capacity_replacement');
+const propose = require('./../../capacity/propose_capacity_change');
+const {servicePeerRequests} = require('./../../');
+
+const acceptCapacityChange = accept;
+const bufferAsHex = buffer => buffer.toString('hex');
+const capacity = 1e6;
+const finalizeCapacityReplacement = finalize;
+const {fromHex} = Transaction;
+const id = Buffer.alloc(32).toString('hex');
+const interval = 10;
+const logger = {error: () => {}, info: () => {}};
+const maturity = 100;
+const proposeCapacityChange = propose;
+const signCapacityReplacement = method;
+const size = 2;
+const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
+const times = 2000;
+const {toOutputScript} = address;
+const weightAsVBytes = n => Math.ceil(n / 4);
+
+// A capacity replacement proposal should be counter signed and accepted
+test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [control, target] = nodes;
+
+  const {generate, lnd} = control;
+
+  const network = networks[(await getNetwork({lnd})).bitcoinjs];
+
+  // Make some funds
+  await generate({count: maturity});
+
+  try {
+    // Open up a new channel
+    const channelOpen = await openChannel({
+      lnd,
+      local_tokens: capacity,
+      partner_public_key: target.id,
+      partner_socket: target.socket,
+    });
+
+    // Wait for the channel to be active
+    const channel = await asyncRetry({interval, times}, async () => {
+      const [channel] = (await getChannels({lnd, is_active: true})).channels;
+
+      if (!!channel) {
+        return channel;
+      }
+
+      await generate({});
+
+      throw new Error('ExpectedChannelActivation');
+    });
+
+    // Find the open tx
+    const tx = (await getChainTransactions({lnd})).transactions.find(tx => {
+      return tx.id === channel.transaction_id;
+    });
+
+    // Get the open tx output
+    const output = fromHex(tx.transaction).outs[channel.transaction_vout];
+
+    const baseFee = channel.commit_transaction_fee;
+    const deltaFee = weightAsVBytes(channel.commit_transaction_weight);
+
+    const openTxHash = fromHex(tx.transaction).getHash();
+
+    // Setup service to ack the accept
+    const service = servicePeerRequests({lnd});
+    const type = '8050002';
+
+    // Listen for the acceptance of the capacity change
+    service.request({type}, (req, res) => {
+      service.stop({});
+
+      return res.success({records: [{type: '1', value: tx.transaction}]});
+    });
+
+    await asyncAuto({
+      // Propose the channel
+      propose: async () => {
+        await proposeCapacityChange({
+          id,
+          lnd,
+          logger,
+          bitcoinjs_network: (await getNetwork({lnd})).bitcoinjs,
+          channel: channel.id,
+          decrease: [],
+          open_transaction: tx.transaction,
+          partner_public_key: target.id,
+          transaction_id: channel.transaction_id,
+          transaction_vout: channel.transaction_vout,
+        });
+      },
+
+      // Wait for a
+      accept: async () => {
+        await acceptCapacityChange({
+          id,
+          logger,
+          channel: channel.id,
+          from: control.id,
+          lnd: target.lnd,
+        });
+      },
+    });
+
+    // Wait for the new channel to be active
+    const recreated = await asyncRetry({interval, times}, async () => {
+      const [channel] = (await getChannels({lnd, is_active: true})).channels;
+
+      if (!!channel) {
+        return channel;
+      }
+
+      await generate({});
+
+      throw new Error('ExpectedChannelActivation');
+    });
+
+    strictSame(recreated.is_active, true, 'Recreated channel is active');
+
+    // Recreate the channel but in reverse roles
+
+  } catch (err) {
+    strictSame(err, null, 'Expected no failure');
+  } finally {
+    await kill({});
+  }
+
+  return end();
+});

package/test/integration/test_change_channel_capacity.js

@@ -0,0 +1,196 @@
+const {address} = require('bitcoinjs-lib');
+const asyncAuto = require('async/auto');
+const asyncMap = require('async/map');
+const asyncRetry = require('async/retry');
+const {broadcastChainTransaction} = require('ln-service');
+const {closeChannel} = require('ln-service');
+const {createChainAddress} = require('ln-service');
+const {getChainTransactions} = require('ln-service');
+const {getChannel} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {getNetwork} = require('ln-sync');
+const {networks} = require('bitcoinjs-lib');
+const {openChannel} = require('ln-service');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+const {Transaction} = require('bitcoinjs-lib');
+
+const {changeChannelCapacity} = require('./../../capacity');
+const {getCapacityChangeRequests} = require('./../../capacity');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const capacity = 1e6;
+const {fromHex} = Transaction;
+const id = Buffer.alloc(32).toString('hex');
+const interval = 10;
+const log = () => {};
+const maturity = 100;
+const size = 2;
+const slow = 5000;
+const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
+const times = 2000;
+const {toOutputScript} = address;
+const weightAsVBytes = n => Math.ceil(n / 4);
+
+// A capacity replacement proposal should be counter signed and accepted
+test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [control, target] = nodes;
+
+  const {generate, lnd} = control;
+
+  const network = networks[(await getNetwork({lnd})).bitcoinjs];
+
+  // Make some funds
+  await generate({count: maturity});
+
+  try {
+    // Open up a new channel
+    const channelOpen = await openChannel({
+      lnd,
+      local_tokens: capacity,
+      partner_public_key: target.id,
+      partner_socket: target.socket,
+    });
+
+    // Wait for the channel to be active
+    const channel = await asyncRetry({interval, times}, async () => {
+      const [channel] = (await getChannels({lnd, is_active: true})).channels;
+
+      if (!channel) {
+        await generate({});
+
+        throw new Error('ExpectedChannelActivation');
+      }
+
+      const {policies} = await getChannel({lnd, id: channel.id});
+
+      const noPolicy = policies.find(n => !n.cltv_delta);
+
+      if (!!channel && !noPolicy) {
+        return channel;
+      }
+
+      await generate({});
+
+      throw new Error('ExpectedChannelActivation');
+    });
+
+    await asyncAuto({
+      // Propose the channel
+      propose: async () => {
+        await changeChannelCapacity({
+          lnd,
+          ask: (args, cbk) => {
+            if (args.name === 'amount') {
+              return cbk({amount: '0'});
+            }
+
+            if (args.name === 'direction') {
+              return cbk({direction: 'decrease'});
+            }
+
+            if (args.name === 'ok') {
+              return cbk({ok: true});
+            }
+
+            if (args.name === 'proceed') {
+              return cbk({proceed: true});
+            }
+
+            if (args.name === 'query') {
+              return cbk({query: target.id});
+            }
+
+            throw new Error('UnknownQueryNameForInitiator');
+          },
+          logger: {error: log, info: log},
+        });
+      },
+
+      // Wait to see the inbound proposal
+      waitForProposal: async () => {
+        await asyncRetry({interval, times}, async () => {
+          const {requests} = await getCapacityChangeRequests({
+            lnd: target.lnd,
+          });
+
+          if (!requests.length) {
+            throw new Error('FailedToFindChangeRequest');
+          }
+        });
+      },
+
+      // Accept the channel
+      accept: ['waitForProposal', async ({}) => {
+        await changeChannelCapacity({
+          ask: (args, cbk) => {
+            if (args.name === 'accept') {
+              return cbk({accept: true});
+            }
+
+            if (args.name === 'ok') {
+              return cbk({ok: true});
+            }
+
+            throw new Error('UnexpectedQueryForAcceptingPeer');
+          },
+          lnd: target.lnd,
+          logger: {error: log, info: log},
+        });
+      }],
+
+      // Generate to confirm the change
+      generate: ['waitForProposal', async ({}) => {
+        // Wait for the new channel to be active
+        const recreated = await asyncRetry({
+          times,
+          interval: slow,
+        },
+        async () => {
+          const {channels} = await getChannels({lnd, is_active: true});
+
+          const [channel] = channels.filter(n => n.capacity < capacity);
+
+          await generate({});
+
+          if (!channel) {
+            throw new Error('ExpectedChannelActivation');
+          }
+
+          {
+            const {policies} = await getChannel({lnd, id: channel.id});
+
+            const noPolicy = policies.find(n => !n.cltv_delta);
+
+            if (!!noPolicy) {
+              throw new Error('ExpectedChannelPolicy');
+            }
+          }
+
+          {
+            const {policies} = await getChannel({
+              id: channel.id,
+              lnd: target.lnd,
+            });
+
+            const noPolicy = policies.find(n => !n.cltv_delta);
+
+            if (!!noPolicy) {
+              throw new Error('ExpectedChannelPolicy');
+            }
+          }
+
+          return;
+        });
+      }],
+    });
+  } catch (err) {
+    strictSame(err, null, 'Expected no failure');
+  } finally {
+    await kill({});
+  }
+
+  return end();
+});

package/test/integration/test_decrease_channel_capacity.js

@@ -0,0 +1,206 @@
+const {address} = require('bitcoinjs-lib');
+const asyncAuto = require('async/auto');
+const asyncMap = require('async/map');
+const asyncRetry = require('async/retry');
+const {broadcastChainTransaction} = require('ln-service');
+const {closeChannel} = require('ln-service');
+const {createChainAddress} = require('ln-service');
+const {getChainTransactions} = require('ln-service');
+const {getChannel} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {getNetwork} = require('ln-sync');
+const {networks} = require('bitcoinjs-lib');
+const {openChannel} = require('ln-service');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+const {Transaction} = require('bitcoinjs-lib');
+
+const {changeChannelCapacity} = require('./../../capacity');
+const {getCapacityChangeRequests} = require('./../../capacity');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const capacity = 1e6;
+const {fromHex} = Transaction;
+const id = Buffer.alloc(32).toString('hex');
+const interval = 10;
+const logger = {error: () => {}, info: () => {}};
+const maturity = 100;
+const size = 2;
+const slow = 3000;
+const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
+const times = 2000;
+const {toOutputScript} = address;
+const weightAsVBytes = n => Math.ceil(n / 4);
+
+// A capacity replacement proposal should be counter signed and accepted
+test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [control, target] = nodes;
+
+  const {generate, lnd} = control;
+
+  const network = networks[(await getNetwork({lnd})).bitcoinjs];
+
+  // Make some funds
+  await generate({count: maturity});
+
+  try {
+    // Open up a new channel
+    const channelOpen = await openChannel({
+      lnd,
+      local_tokens: capacity,
+      partner_public_key: target.id,
+      partner_socket: target.socket,
+    });
+
+    // Wait for the channel to be active
+    const channel = await asyncRetry({interval, times}, async () => {
+      const [channel] = (await getChannels({lnd, is_active: true})).channels;
+
+      if (!channel) {
+        await generate({});
+
+        throw new Error('ExpectedChannelActivation');
+      }
+
+      const {policies} = await getChannel({lnd, id: channel.id});
+
+      const noPolicy = policies.find(n => !n.cltv_delta);
+
+      if (!!channel && !noPolicy) {
+        return channel;
+      }
+
+      await generate({});
+
+      throw new Error('ExpectedChannelActivation');
+    });
+
+    await asyncAuto({
+      // Propose the channel
+      propose: async () => {
+        await changeChannelCapacity({
+          lnd,
+          logger,
+          ask: (args, cbk) => {
+            if (args.name === 'amount') {
+              return cbk({amount: '200000'});
+            }
+
+            if (args.name === 'direction') {
+              return cbk({direction: 'decrease'});
+            }
+
+            if (args.name === 'internal') {
+              return cbk({internal: true});
+            }
+
+            if (args.name === 'ok') {
+              return cbk({ok: true});
+            }
+
+            if (args.name === 'proceed') {
+              return cbk({proceed: true});
+            }
+
+            if (args.name === 'rate') {
+              return cbk({rate: args.default});
+            }
+
+            if (args.name === 'spend') {
+              return cbk({spend: false});
+            }
+
+            if (args.name === 'query') {
+              return cbk({query: target.id});
+            }
+
+            throw new Error('UnexpectedQueryNameForProposingSide');
+          },
+        });
+      },
+
+      // Wait to see the inbound proposal
+      waitForProposal: async () => {
+        await asyncRetry({interval, times}, async () => {
+          const {requests} = await getCapacityChangeRequests({lnd: target.lnd});
+
+          if (!requests.length) {
+            throw new Error('FailedToFindChangeRequest');
+          }
+        });
+      },
+
+      // Accept the channel
+      accept: ['waitForProposal', async ({}) => {
+        await changeChannelCapacity({
+          logger,
+          ask: (args, cbk) => {
+            if (args.name === 'accept') {
+              return cbk({accept: true});
+            }
+
+            if (args.name === 'ok') {
+              return cbk({ok: true});
+            }
+
+            throw new Error('UnexpectedQueryNameForAcceptingSide');
+          },
+          lnd: target.lnd,
+        });
+      }],
+
+      // Generate to confirm the change
+      generate: ['waitForProposal', async ({}) => {
+        // Wait for the new channel to be active
+        const recreated = await asyncRetry({
+          times,
+          interval: slow,
+        },
+        async () => {
+          const [channel] = (await getChannels({lnd, is_active: true})).channels.filter(n => n.capacity < capacity);
+
+          await generate({});
+
+          if (!channel) {
+            throw new Error('ExpectedChannelActivation');
+          }
+
+          {
+            const {policies} = await getChannel({lnd, id: channel.id});
+
+            const noPolicy = policies.find(n => !n.cltv_delta);
+
+            if (!!noPolicy) {
+              throw new Error('ExpectedChannelPolicy');
+            }
+          };
+
+          {
+            const {policies} = await getChannel({
+              id: channel.id,
+              lnd: target.lnd,
+            });
+
+            const noPolicy = policies.find(n => !n.cltv_delta);
+
+            if (!!noPolicy) {
+              throw new Error('ExpectedChannelPolicy');
+            }
+          };
+
+          return;
+        });
+
+        return;
+      }],
+    });
+  } catch (err) {
+    strictSame(err, null, 'Expected no failure');
+  } finally {
+    await kill({});
+  }
+
+  return end();
+});