paid-services 3.3.0 → 3.4.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Versions
 
+## Version 3.4.0
+
+- `changeChannelCapacity`: Fix broken preservation of channel announce status
+- `manageTrades`: Add support for open-ended trades
+
 ## Version 3.3.0
 
 - `changeChannelCapacity`: Add method to change a channel's capacity

package/capacity/accept_capacity_change.js

@@ -12,9 +12,9 @@ const {makePeerRequest} = require('./../p2p');
 const parseAcceptResponse = require('./parse_accept_response');
 const parseSignCapacityRequest = require('./parse_sign_capacity_request');
 const {servicePeerRequests} = require('./../p2p');
-const {serviceTypeAcceptCapacityChange} = require('./service_types');
-const {serviceTypeSignCapacityChange} = require('./service_types');
-const {serviceTypeWaitOnConfirmation} = require('./service_types');
+const {serviceTypeAcceptCapacityChange} = require('./../service_types');
+const {serviceTypeSignCapacityChange} = require('./../service_types');
+const {serviceTypeWaitOnConfirmation} = require('./../service_types');
 
 const acceptChangeTimeoutMs = 1000 * 45;
 const bufferAsHex = buffer => buffer.toString('hex');

package/capacity/get_capacity_change_requests.js

@@ -4,7 +4,7 @@ const {returnResult} = require('asyncjs-util');
 const {subscribeToPeerMessages} = require('ln-service');
 
 const capacityChangeRequests = require('./capacity_change_requests');
-const {serviceTypeChangeCapacity} = require('./service_types');
+const {serviceTypeChangeCapacity} = require('./../service_types');
 const parseCapacityChangeRequest = require('./parse_capacity_change_request');
 const {servicePeerRequests} = require('./../p2p');
 

package/capacity/get_capacity_replacement.js

@@ -264,10 +264,10 @@ module.exports = (args, cbk) => {
           channels: [{
             capacity: newCapacity,
             give_tokens: pendingChannel.remote_balance,
+            is_private: args.is_private,
             partner_public_key: pendingChannel.partner_public_key,
           }],
           is_avoiding_broadcast: true,
-          is_private: args.is_private,
           lnd: args.lnd,
         },
         cbk);

package/capacity/initiate_capacity_change.js

@@ -23,10 +23,10 @@ const {makePeerRequest} = require('./../p2p');
 const parseAcceptRequest = require('./parse_accept_request');
 const proposeCapacityChange = require('./propose_capacity_change');
 const {servicePeerRequests} = require('./../p2p');
-const {serviceTypeAcceptCapacityChange} = require('./service_types');
-const {serviceTypeChangeCapacity} = require('./service_types');
-const {serviceTypeSignCapacityChange} = require('./service_types');
-const {serviceTypeWaitOnConfirmation} = require('./service_types');
+const {serviceTypeAcceptCapacityChange} = require('./../service_types');
+const {serviceTypeChangeCapacity} = require('./../service_types');
+const {serviceTypeSignCapacityChange} = require('./../service_types');
+const {serviceTypeWaitOnConfirmation} = require('./../service_types');
 
 const bufferAsHex = buffer => buffer.toString('hex');
 const capacityChangeRequestIdType = '0';
@@ -438,6 +438,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           increase_transaction_id: getFunding.id,
           increase_transaction_vout: getFunding.vout,
           increase_witness_script: getFunding.script,
+          is_private: channel.is_private,
           open_transaction: sendBasicRequest,
           partner_public_key: askForChangeDetails.partner_public_key,
           transaction_id: channel.transaction_id,

package/capacity/propose_capacity_change.js

@@ -17,7 +17,7 @@ const finalizeCapacityReplacement = require('./finalize_capacity_replacement');
 const getCapacityReplacement = require('./get_capacity_replacement');
 const interimReplacementPsbt = require('./interim_replacement_psbt');
 const {makePeerRequest} = require('./../p2p');
-const {serviceTypeSignCapacityChange} = require('./service_types');
+const {serviceTypeSignCapacityChange} = require('./../service_types');
 
 const capacityChangeIdType = '0';
 const findSignatureRecord = records => records.find(n => n.type === '1');
@@ -40,6 +40,7 @@ const unsignedTransactionType = '1';
       tokens: <Spend Value Number>
     }]
     id: <Capacity Change Request Id Hex String>
+    is_private: <Channel is Private Bool>
     [increase]: <Increase Channel Size Tokens Number>
     [increase_key_index]: <Increase Funds Transit Key Number>
     [increase_output_script]: <Increase Funds Output Script Hex String>
@@ -119,6 +120,7 @@ module.exports = (args, cbk) => {
           bitcoinjs_network: args.bitcoinjs_network,
           decrease: args.decrease,
           id: args.channel,
+          is_private: args.is_private,
           increase: args.increase,
           lnd: args.lnd,
           open_transaction: args.open_transaction,

package/p2p/service_peer_requests.js

@@ -16,6 +16,7 @@ const returnSuccessResponse = require('./return_success_response');
 
   @returns
   {
+    end: <Add a Service Ended Function>
     error: <Add an Error Listener Function>
     request: <Add A Request Listener For Type Function>
     stop: <Stop Listening Function> ({}) => {};
@@ -55,9 +56,15 @@ const returnSuccessResponse = require('./return_success_response');
 */
 module.exports = ({lnd}) => {
   const listeners = {};
-  const service = {error: () => {}};
+  const service = {end: () => {}, error: () => {}};
   const sub = subscribeToPeerMessages({lnd});
 
+  sub.on('error', error => {
+    service.error(error);
+
+    return service.end();
+  });
+
   sub.on('message_received', received => {
     const from = received.public_key;
     const {message} = received;
@@ -93,7 +100,8 @@ module.exports = ({lnd}) => {
   });
 
   return {
-    error: cbk => service[error] = cbk,
+    end: cbk => service.end = cbk,
+    error: cbk => service.error = cbk,
     request: ({type}, cbk) => listeners[type] = cbk,
     stop: ({}) => sub.removeAllListeners(),
   };

package/package.json

@@ -10,6 +10,7 @@
     "async": "3.2.2",
     "asyncjs-util": "1.2.7",
     "bolt01": "1.2.3",
+    "bolt07": "1.8.0",
     "invoices": "2.0.2",
     "ln-service": "53.2.0",
     "ln-sync": "3.6.0"
@@ -37,7 +38,7 @@
   },
   "scripts": {
     "integration-tests": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 120 test/integration/*.js",
-    "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 60 test/actions/*.js test/capacity/*.js test/client/*.js test/config/*.js test/p2p/*.js test/records/*.js test/respond/*.js test/server/*.js test/server/*.js test/services/*.js"
+    "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 60 test/actions/*.js test/capacity/*.js test/client/*.js test/config/*.js test/p2p/*.js test/records/*.js test/respond/*.js test/server/*.js test/server/*.js test/services/*.js test/trades/*.js"
   },
-  "version": "3.3.0"
+  "version": "3.4.0"
 }

package/service_types.json

@@ -0,0 +1,16 @@
+{
+  "serviceTypeAcceptCapacityChange": "8050002",
+  "serviceTypeChangeCapacity": "8050001",
+  "serviceTypeReceiveTrades": "8050006",
+  "serviceTypeRequestTrades": "8050005",
+  "serviceTypeSignCapacityChange": "8050004",
+  "serviceTypeWaitOnConfirmation": "8050003",
+  "types": {
+    "8050001": "serviceTypeChangeCapacity",
+    "8050002": "serviceTypeAcceptCapacityChange",
+    "8050003": "serviceTypeWaitOnConfirmation",
+    "8050004": "serviceTypeSignCapacityChange",
+    "8050005": "serviceTypeRequestTrades",
+    "8050006": "serviceTypeReceiveTrades"
+  }
+}

package/test/integration/test_accept_capacity_change.js

@@ -111,9 +111,12 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
           transaction_id: channel.transaction_id,
           transaction_vout: channel.transaction_vout,
         });
+
+        proposeDone = true;
+
+        return;
       },
 
-      // Wait for a
       accept: async () => {
         await acceptCapacityChange({
           id,
@@ -123,25 +126,59 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
           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;
+      confirmTarget: ['accept', async ({}) => {
+        // Wait for the new channel to be active
+        const recreated = await asyncRetry({interval, times}, async () => {
+          const controlChannels = (await getChannels({lnd, is_active: true}));
 
-      if (!!channel) {
-        return channel;
-      }
+          const [channel] = controlChannels.channels;
 
-      await generate({});
+          const targetChans = await getChannels({
+            is_active: true,
+            lnd: target.lnd,
+          });
 
-      throw new Error('ExpectedChannelActivation');
-    });
+          const targetChan = targetChans.channels;
+
+          if (!!channel && !!targetChan && channel.capacity < capacity) {
+            return channel;
+          }
 
-    strictSame(recreated.is_active, true, 'Recreated channel is active');
+          await generate({});
 
-    // Recreate the channel but in reverse roles
+          throw new Error('ExpectedChannelActivation');
+        });
+
+        strictSame(recreated.is_active, true, 'Recreated channel is active');
+      }],
+
+      confirmControl: ['accept', 'propose', async ({}) => {
+        // Wait for the new channel to be active
+        const recreated = await asyncRetry({interval, times}, async () => {
+          const controlChannels = (await getChannels({lnd, is_active: true}));
+
+          const [channel] = controlChannels.channels;
+
+          const targetChans = await getChannels({
+            is_active: true,
+            lnd: target.lnd,
+          });
+
+          const targetChan = targetChans.channels;
 
+          if (!!channel && !!targetChan && channel.capacity < capacity) {
+            return channel;
+          }
+
+          await generate({});
+
+          throw new Error('ExpectedChannelActivation');
+        });
+
+        strictSame(recreated.is_active, true, 'Recreated channel is active');
+      }],
+    });
   } catch (err) {
     strictSame(err, null, 'Expected no failure');
   } finally {

package/test/integration/test_change_channel_capacity.js

@@ -49,6 +49,7 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
     // Open up a new channel
     const channelOpen = await openChannel({
       lnd,
+      is_private: true,
       local_tokens: capacity,
       partner_public_key: target.id,
       partner_socket: target.socket,
@@ -159,6 +160,8 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
             throw new Error('ExpectedChannelActivation');
           }
 
+          equal(channel.is_private, true, 'Channel is private');
+
           {
             const {policies} = await getChannel({lnd, id: channel.id});
 

package/test/trades/test_decode_basic_trade.js

@@ -0,0 +1,40 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../trades/decode_basic_trade');
+
+const tests = [
+  {
+    args: {},
+    description: 'Records are expected',
+    error: 'ExpectedArrayOfRecordsToDecodeBasicTrade',
+  },
+  {
+    args: {records: []},
+    description: 'A description record is expected',
+    error: 'ExpectedDescriptionRecordToDecodeBasicTrade',
+  },
+  {
+    args: {records: [{type: '2', value: '00'}]},
+    description: 'An id record is expected',
+    error: 'ExpectedIdRecordToDecodeBasicTradeDetails',
+  },
+  {
+    args: {records: [{type: '1', value: '00'}, {type: '2', value: '00'}]},
+    description: 'Basic trade is encoded',
+    expected: {description: '\u0000', id: '00'},
+  },
+];
+
+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/trades/test_decode_open_trade.js

@@ -0,0 +1,50 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../trades/decode_open_trade');
+
+const tests = [
+  {
+    args: {},
+    description: 'A network name is expected',
+    error: 'ExpectedNetworkNameToDecodeOpenTrade',
+  },
+  {
+    args: {network: 'btc'},
+    description: 'Records are expected',
+    error: 'ExpectedArrayOfRecordsToDecodeOpenTrade',
+  },
+  {
+    args: {network: 'btc', records: []},
+    description: 'Nodes are expected',
+    error: 'ExpectedNodesRecordToDecodeOpenTradeDetails',
+  },
+  {
+    args: {
+      network: 'btc',
+      records: [
+        {type: '0', value: '01'},
+        {type: '4', value: '000a01080000010000020003'},
+      ],
+    },
+    description: 'Open trade is decoded',
+    expected: {
+      id: undefined,
+      network: 'btc',
+      nodes: [{high_channel: '1x2x3'}],
+    },
+  },
+];
+
+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/trades/test_encode_open_trade.js

@@ -0,0 +1,35 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../trades/encode_open_trade');
+
+const tests = [
+  {
+    args: {
+      network: 'btc',
+      nodes: [{
+        channels: [{
+          id: '1x2x3',
+          partner_public_key: Buffer.alloc(33, 2).toString('hex'),
+        }],
+        id: Buffer.alloc(33, 3).toString('hex'),
+        sockets: [],
+      }],
+    },
+    description: 'Open trade is encoded',
+    expected: {trade: '626f73ff000101040c000a01080000010000020003'},
+  },
+];
+
+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/trades/test_encode_trade.js

@@ -0,0 +1,37 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../trades/encode_trade');
+
+const tests = [
+  {
+    args: {
+      connect: {
+        network: 'btc',
+        nodes: [{
+          channels: [{
+            id: '1x2x3',
+            partner_public_key: Buffer.alloc(33, 2).toString('hex'),
+          }],
+          id: Buffer.alloc(33, 3).toString('hex'),
+          sockets: [],
+        }],
+      },
+    },
+    description: 'Trade is encoded',
+    expected: {trade: '626f73ff000101040c000a01080000010000020003'},
+  },
+];
+
+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/accept_trade.js

@@ -0,0 +1,52 @@
+const asyncAuto = require('async/auto');
+const asyncEach = require('async/each');
+const {cancelHodlInvoice} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+const {settleHodlInvoice} = require('ln-service');
+
+const {isArray} = Array;
+
+/** Accept an open ended trade
+
+  {
+    cancel: [<Alternative Invoice Id Hex String>]
+    lnd: <Authenticated LND API Object>
+    secret: <Invoice to Settle Preimage Hex String>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = ({cancel, lnd, secret}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isArray(cancel)) {
+          return cbk([400, 'ExpectedArrayOfIdsToCancelToAcceptTrade']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToAcceptTrade']);
+        }
+
+        if (!secret) {
+          return cbk([400, 'ExpectedSettlementPreimageToAcceptTrade']);
+        }
+
+        return cbk();
+      },
+
+      // Cancel alternative invoices so that only one resolves as settled
+      cancel: ['validate', ({}, cbk) => {
+        return asyncEach(cancel, (id, cbk) => {
+          return cancelHodlInvoice({id, lnd}, cbk);
+        },
+        cbk);
+      }],
+
+      // Settle the held invoice with the preimage
+      settle: ['cancel', ({}, cbk) => settleHodlInvoice({lnd, secret}, cbk)],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};