paid-services 3.2.0 → 3.3.0

package/test/integration/test_increase_channel_capacity.js

@@ -0,0 +1,197 @@
+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 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,
+          logger,
+          ask: (args, cbk) => {
+            if (args.name === 'amount') {
+              return cbk({amount: '200000'});
+            }
+
+            if (args.name === 'direction') {
+              return cbk({direction: 'increase'});
+            }
+
+            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 === '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({interval: 3000, times}, 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({
+              lnd: target.lnd,
+              id: channel.id,
+            });
+
+            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();
+});

package/test/integration/test_sign_capacity_replacement.js

@@ -0,0 +1,142 @@
+const {address} = require('bitcoinjs-lib');
+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 {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 finalize = require('./../../capacity/finalize_capacity_replacement');
+const method = require('./../../capacity/sign_capacity_replacement');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const capacity = 1e6;
+const finalizeCapacityReplacement = finalize;
+const {fromHex} = Transaction;
+const interval = 10;
+const maturity = 100;
+const network = networks.regtest;
+const sequence = 0;
+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);
+
+// Signing a capacity replacement transaction should result in a valid sig
+test(`Sign capacity replacement`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [{generate, lnd}, target] = nodes;
+
+  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];
+
+    // Close the channel
+    const channelClose = await closeChannel({
+      lnd,
+      id: channel.id,
+      is_force_close: true,
+    });
+
+    // Find the open tx
+    const endTx = (await getChainTransactions({lnd})).transactions.find(tx => {
+      return tx.id === channelClose.transaction_id;
+    });
+
+    // Get the witness spending the channel funds
+    const [{witness}] = fromHex(endTx.transaction).ins;
+
+    const replacement = new Transaction();
+
+    const openTxHash = fromHex(tx.transaction).getHash();
+
+    replacement.addInput(openTxHash, channel.transaction_vout, sequence);
+
+    const spendIdx = replacement.ins.findIndex(n => n.hash.equals(openTxHash));
+
+    const fee = sumOf([
+      channel.commit_transaction_fee,
+      weightAsVBytes(channel.commit_transaction_weight),
+    ]);
+
+    replacement.addOutput(
+      toOutputScript((await createChainAddress({lnd})).address, network),
+      channel.capacity - fee,
+    );
+
+    // Gather the replacement signatures
+    const [local, remote] = await asyncMap([lnd, target.lnd], async lnd => {
+      return await signCapacityReplacement({
+        lnd,
+        capacity: channel.capacity,
+        output: bufferAsHex(output.script),
+        script: bufferAsHex(witness.slice().pop()),
+        transaction: replacement.toHex(),
+        vin: replacement.ins.findIndex(n => n.hash.equals(openTxHash)),
+      });
+    });
+
+    // Add the signature to the replacement transaction
+    const {transaction} = finalizeCapacityReplacement({
+      local_public_key: local.key,
+      local_signature: local.signature,
+      funding_spend_vin: spendIdx,
+      remote_signature: remote.signature,
+      transaction: replacement.toHex(),
+      witness_script: bufferAsHex(witness.slice().pop()),
+    });
+
+    await broadcastChainTransaction({transaction, lnd});
+
+    await generate({count: maturity});
+
+    const done = (await getChainTransactions({lnd})).transactions.find(tx => {
+      return tx.id === fromHex(transaction).getId();
+    });
+
+    strictSame(done.is_confirmed, true, 'Signed replacement is confirmed');
+  } catch (err) {
+    strictSame(err, null, 'Expected no failure');
+  } finally {
+    await kill({});
+  }
+
+  return end();
+});

package/test/p2p/test_encode_peer_request.js

@@ -0,0 +1,53 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../p2p/encode_peer_request');
+
+const makeArgs = overrides => {
+  const args = {id: '00', type: '0'};
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({id: undefined}),
+    description: 'A request id is required',
+    error: 'ExpectedRequestIdHexStringToEncodePeerRequest',
+  },
+  {
+    args: makeArgs({records: '00'}),
+    description: 'Records array is required',
+    error: 'ExpectedRecordsArrayToEncodePeerRequest',
+  },
+  {
+    args: makeArgs({type: undefined}),
+    description: 'A type is required',
+    error: 'ExpectedRequestTypeToEncodePeerRequest',
+  },
+  {
+    args: makeArgs({}),
+    description: 'Peer request is encoded',
+    expected: {message: '626f73ff010100030100'},
+  },
+  {
+    args: makeArgs({records: [{type: '0', value: '00'}]}),
+    description: 'Peer request with records is encoded',
+    expected: {message: '626f73ff0101000301000503000100'},
+  },
+];
+
+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/p2p/test_encode_peer_response.js

@@ -0,0 +1,38 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../p2p/encode_peer_response');
+
+const makeArgs = overrides => {
+  const args = {id: '00'};
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({}),
+    description: 'Peer response is encoded',
+    expected: {message: '626f73ff01010002030001c8'},
+  },
+  {
+    args: makeArgs({records: [{type: '0', value: '00'}]}),
+    description: 'Peer response with records is encoded',
+    expected: {message: '626f73ff01010002030001c80503000100'},
+  },
+];
+
+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/p2p/test_encode_response_code.js

@@ -0,0 +1,48 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../p2p/encode_response_code');
+
+const makeArgs = overrides => {
+  const args = {};
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({failure: '00'}),
+    description: 'A failure array is expected',
+    error: 'ExpectedFailureArrayToEncodeResponseCode',
+  },
+  {
+    args: makeArgs({failure: []}),
+    description: 'A failure code is expected',
+    error: 'ExpectedErrorCodeToEncodeResponseCode',
+  },
+  {
+    args: makeArgs({}),
+    description: 'Encode response code',
+    expected: {encoded: '0001c8'},
+  },
+  {
+    args: makeArgs({failure: [400, 'Failure']}),
+    description: 'Encode failure code',
+    expected: {encoded: '0003fd019001074661696c757265'},
+  },
+];
+
+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/trades/network_from_network_record.js

@@ -1,4 +1,6 @@
 const defaultNetwork = 'bitcoin';
+const regtestNetwork = 'regtest';
+const regtestNetworkType = '02';
 const testnetNetwork = 'testnet';
 const testnetNetworkType = '01';
 
@@ -18,6 +20,10 @@ module.exports = ({value}) => {
     return defaultNetwork;
   }
 
+  if (value === regtestNetworkType) {
+    return regtestNetwork;
+  }
+
   if (value === testnetNetworkType) {
     return testnetNetwork;
   }

package/trades/network_record_from_request.js

@@ -1,4 +1,5 @@
 const defaultNetwork = 'lnbc';
+const regtestNetwork = 'lnbcrt';
 const testnetNetwork = 'lntb';
 const testnetNetworkType = '01';
 
@@ -22,6 +23,10 @@ module.exports = ({request}) => {
     return {};
   }
 
+  if (request.startsWith(regtestNetwork)) {
+    return {};
+  }
+
   if (request.startsWith(testnetNetwork)) {
     return {value: testnetNetworkType};
   }