paid-services 3.3.0 → 3.6.0

package/test/integration/test_decrease_channel_capacity.js

@@ -27,7 +27,6 @@ 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);
@@ -47,11 +46,13 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
 
   try {
     // Open up a new channel
-    const channelOpen = await openChannel({
-      lnd,
-      local_tokens: capacity,
-      partner_public_key: target.id,
-      partner_socket: target.socket,
+    const channelOpen = await asyncRetry({interval, times}, async () => {
+      return await openChannel({
+        lnd,
+        local_tokens: capacity,
+        partner_public_key: target.id,
+        partner_socket: target.socket,
+      });
     });
 
     // Wait for the channel to be active
@@ -116,6 +117,10 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
               return cbk({query: target.id});
             }
 
+            if (args.name === 'type') {
+              return cbk({type: 'Private'});
+            }
+
             throw new Error('UnexpectedQueryNameForProposingSide');
           },
         });
@@ -159,7 +164,9 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
           interval: slow,
         },
         async () => {
-          const [channel] = (await getChannels({lnd, is_active: true})).channels.filter(n => n.capacity < capacity);
+          const {channels} = await getChannels({lnd, is_active: true});
+
+          const [channel] = channels.filter(n => n.capacity < capacity);
 
           await generate({});
 
@@ -167,6 +174,8 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
             throw new Error('ExpectedChannelActivation');
           }
 
+          equal(channel.is_private, true, 'Channel is changed to private');
+
           {
             const {policies} = await getChannel({lnd, id: channel.id});
 

package/test/integration/test_increase_channel_capacity.js

@@ -26,7 +26,6 @@ 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);
@@ -111,6 +110,10 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
               return cbk({query: target.id});
             }
 
+            if (args.name === 'type') {
+              return cbk({type: args.default});
+            }
+
             throw new Error('UnexpectedQueryNameForProposingSide');
           },
         });

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,61 @@
+const asyncAuto = require('async/auto');
+const asyncEach = require('async/each');
+const {cancelHodlInvoice} = require('ln-service');
+const {getInvoice} = 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>]
+    id: <Trade Id Hex String>
+    lnd: <Authenticated LND API Object>
+    secret: <Invoice to Settle Preimage Hex String>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = ({cancel, id, lnd, secret}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isArray(cancel)) {
+          return cbk([400, 'ExpectedArrayOfIdsToCancelToAcceptTrade']);
+        }
+
+        if (!id) {
+          return cbk([400, 'ExpectedAnchorTradeIdToAcceptTrade']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToAcceptTrade']);
+        }
+
+        if (!secret) {
+          return cbk([400, 'ExpectedSettlementPreimageToAcceptTrade']);
+        }
+
+        return cbk();
+      },
+
+      // Fetch the anchor invoice to make sure it's still open
+      getAnchor: ['validate', ({}, cbk) => getInvoice({id, lnd}, cbk)],
+
+      // Cancel alternative invoices so that only one resolves as settled
+      cancel: ['getAnchor', ({}, cbk) => {
+        return asyncEach([].concat(cancel).concat(id), (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));
+  });
+};

package/trades/create_trade.js

@@ -1,17 +1,24 @@
 const asyncAuto = require('async/auto');
 const {createInvoice} = require('ln-service');
-const {getIdentity} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {getNetwork} = require('ln-sync');
+const {getWalletInfo} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
-const encodeTrade = require('./encode_trade');
-const encryptTradeSecret = require('./encrypt_trade_secret');
+const encodeAnchoredTrade = require('./encode_anchored_trade');
+const finalizeTradeSecret = require('./finalize_trade_secret');
+const serviceOpenTrade = require('./service_open_trade');
 
 const asNumber = n => parseFloat(n, 10);
+const daysAsMs = days => Number(days) * 1000 * 60 * 60 * 24;
+const defaultExpirationDays = 14;
 const {floor} = Math;
+const futureDate = ms => new Date(Date.now() + ms).toISOString();
 const isNumber = n => !isNaN(n);
 const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
 const maxDescriptionLength = 100;
 const maxSecretLength = 100;
+const uriAsSocket = n => n.substring(67);
 const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
 
 /** Create a new trade
@@ -19,6 +26,7 @@ const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
   {
     ask: <Ask Function>
     lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
   }
 
   @returns via cbk or Promise
@@ -26,7 +34,7 @@ const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
     trade: <Hex Encoded Trade String>
   }
 */
-module.exports = ({ask, lnd}, cbk) => {
+module.exports = ({ask, lnd, logger}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -39,28 +47,32 @@ module.exports = ({ask, lnd}, cbk) => {
           return cbk([400, 'ExpectedAuthenticatedLndToCreateTrade']);
         }
 
+        if (!logger) {
+          return cbk([400, 'ExpectedWinstonLoggerToCreateTrade']);
+        }
+
         return cbk();
       },
 
       // Get the node identity key
-      getNodeId: ['validate', ({}, cbk) => getIdentity({lnd}, cbk)],
+      getIdentity: ['validate', ({}, cbk) => getWalletInfo({lnd}, cbk)],
 
       // Ask for the public key of the node to trade with
-      askForNodeId: ['getNodeId', ({getNodeId}, cbk) => {
+      askForNodeId: ['getIdentity', ({getIdentity}, cbk) => {
         return ask({
           name: 'id',
-          message: 'Public key of node you are trading with?',
+          message: 'Public key of node you are trading with? (Optional)',
           type: 'input',
           validate: input => {
             if (!input) {
-              return false;
+              return true;
             }
 
             if (!isPublicKey(input)) {
               return 'Expected public key of node to trade with';
             }
 
-            if (input === getNodeId.public_key) {
+            if (input === getIdentity.public_key) {
               return 'Expected public key of other node';
             }
 
@@ -70,6 +82,26 @@ module.exports = ({ask, lnd}, cbk) => {
         cbk);
       }],
 
+      // Get the public channels to use for an open trade
+      getChannels: ['askForNodeId', ({askForNodeId}, cbk) => {
+        // Exit early when there is a specific node
+        if (!!askForNodeId.id) {
+          return cbk();
+        }
+
+        return getChannels({lnd, is_public: true}, cbk);
+      }],
+
+      // Get the network name to use for an open trade
+      getNetwork: ['askForNodeId', ({askForNodeId}, cbk) => {
+        // Exit early when there is a specific node
+        if (!!askForNodeId.id) {
+          return cbk();
+        }
+
+        return getNetwork({lnd}, cbk);
+      }],
+
       // Ask for how to describe the payload
       askForDescription: ['askForNodeId', ({}, cbk) => {
         return ask({
@@ -134,55 +166,135 @@ module.exports = ({ask, lnd}, cbk) => {
         cbk);
       }],
 
-      // Encrypt the secret data
-      encryptPayload: [
+      // Ask for the expiration of the trade
+      askForExpiration: ['askForPrice', ({}, cbk) => {
+        return ask({
+          default: defaultExpirationDays,
+          name: 'days',
+          message: 'Days to offer this for?',
+          validate: input => {
+            if (!isNumber(input) || !Number(input)) {
+              return false;
+            }
+
+            return true;
+          },
+        },
+        cbk);
+      }],
+
+      // Create an anchor invoice for the trade
+      createAnchor: [
+        'askForDescription',
+        'askForExpiration',
         'askForNodeId',
+        'askForPrice',
         'askForSecret',
-        ({askForNodeId, askForSecret}, cbk) =>
+        ({
+          askForDescription,
+          askForExpiration,
+          askForNodeId,
+          askForPrice,
+          askForSecret,
+        },
+        cbk) =>
       {
-        return encryptTradeSecret({
+        // Exit early if this is a closed trade
+        if (!!askForNodeId.id) {
+          return cbk();
+        }
+
+        const {encoded} = encodeAnchoredTrade({
+          description: askForDescription.description,
+          secret: askForSecret.secret,
+        });
+
+        return createInvoice({
           lnd,
-          secret: utf8AsHex(askForSecret.secret),
-          to: askForNodeId.id,
+          description: encoded,
+          expires_at: futureDate(daysAsMs(askForExpiration.days)),
+          tokens: asNumber(askForPrice.tokens),
         },
         cbk);
       }],
 
-      // Create the invoice to purchase the unlocking secret
-      createPurchaseInvoice: [
+      // Wait for a peer to connect and ask for the trade details
+      serviceTradeRequests: [
         'askForDescription',
+        'askForExpiration',
+        'askForNodeId',
         'askForPrice',
-        'encryptPayload',
-        ({askForDescription, askForPrice, encryptPayload}, cbk) =>
+        'askForSecret',
+        'createAnchor',
+        'getChannels',
+        'getIdentity',
+        'getNetwork',
+        ({
+          askForDescription,
+          askForExpiration,
+          askForNodeId,
+          askForPrice,
+          askForSecret,
+          createAnchor,
+          getChannels,
+          getIdentity,
+          getNetwork,
+        },
+        cbk) =>
       {
-        return createInvoice({
+        // Exit early if this is a closed trade
+        if (!!askForNodeId.id) {
+          return cbk();
+        }
+
+        return serviceOpenTrade({
           lnd,
+          logger,
+          channels: getChannels.channels,
           description: askForDescription.description,
-          secret: encryptPayload.payment_secret,
+          expires_at: futureDate(daysAsMs(askForExpiration.days)),
+          id: createAnchor.id,
+          network: getNetwork.network,
+          public_key: getIdentity.public_key,
+          secret: askForSecret.secret,
           tokens: asNumber(askForPrice.tokens),
+          uris: (getIdentity.uris || []),
         },
         cbk);
       }],
 
-      // Encode all the trade data into wire format
-      encodeTradeToWireFormat: [
-        'createPurchaseInvoice',
-        'encryptPayload',
-        ({createPurchaseInvoice, encryptPayload}, cbk) =>
+      // Finalize the trade with an encrypted secret and an invoice
+      finalize: [
+        'askForDescription',
+        'askForExpiration',
+        'askForNodeId',
+        'askForPrice',
+        'askForSecret',
+        ({
+          askForDescription,
+          askForExpiration,
+          askForNodeId,
+          askForPrice,
+          askForSecret,
+        },
+        cbk) =>
       {
-        try {
-          const {trade} = encodeTrade({
-            auth: encryptPayload.trade_auth_tag,
-            payload: encryptPayload.trade_cipher,
-            request: createPurchaseInvoice.request,
-          });
-
-          return cbk(null, {trade});
-        } catch (err) {
-          return cbk([500, err.message]);
+        // Exit early when there is no node to finalize the trade to
+        if (!askForNodeId.id) {
+          return cbk();
         }
+
+        return finalizeTradeSecret({
+          lnd,
+          description: askForDescription.description,
+          expires_at: futureDate(daysAsMs(askForExpiration.days)),
+          secret: askForSecret.secret,
+          to: askForNodeId.id,
+          tokens: asNumber(askForPrice.tokens),
+        },
+        cbk);
       }],
     },
-    returnResult({reject, resolve, of: 'encodeTradeToWireFormat'}, cbk));
+    returnResult({reject, resolve, of: 'finalize'}, cbk));
   });
 };

package/trades/decode_anchored_trade.js

@@ -0,0 +1,56 @@
+const {decodeTlvStream} = require('bolt01');
+
+const anchorPrefix = 'anchor-trade-secret:';
+const base64AsHex = base64 => Buffer.from(base64, 'base64').toString('hex');
+const findDescription = records => records.find(n => n.type === '1');
+const findSecret = records => records.find(n => n.type === '0');
+const hexAsUtf = n => !n ? '' : Buffer.from(n.value, 'hex').toString('utf8');
+
+/** Decode an anchored trade data blob
+
+  Data blobs look like anchored-trade-secret:<base64-encoded-data>
+
+  Inside the base64 is encoded TLV data:
+  0: <Trade Secret>
+  [1]: <Trade Description>
+
+  {
+    encoded: <Encoded Trade Data String>
+  }
+
+  @returns
+  {
+    [trade]: {
+      description: <Description of Trade String>
+      secret: <Trade Secret String>
+    }
+  }
+*/
+module.exports = ({encoded}) => {
+  if (!encoded.startsWith(anchorPrefix)) {
+    return {};
+  }
+
+  const data = encoded.slice(anchorPrefix.length);
+
+  try {
+    decodeTlvStream({encoded: base64AsHex(data)});
+  } catch (err) {
+    return {};
+  }
+
+  const {records} = decodeTlvStream({encoded: base64AsHex(data)});
+
+  const secret = findSecret(records);
+
+  if (!secret.value) {
+    return {};
+  }
+
+  return {
+    trade: {
+      description: hexAsUtf(findDescription(records)),
+      secret: hexAsUtf(secret),
+    },
+  };
+};

package/trades/decode_basic_trade.js

@@ -0,0 +1,45 @@
+const findDescriptionRecord = records => records.find(n => n.type === '2');
+const findIdRecord = records => records.find(n => n.type === '1');
+const hexAsUtf8 = hex => Buffer.from(hex, 'hex').toString('utf8');
+const {isArray} = Array;
+
+/** Decode a basic trade
+
+  1: <Trade Id>
+  2: <Trade Description>
+
+  {
+    records: [{
+      type: <Basic Trade Record Type Number String>
+      value: <Value Hex Encoded String>
+    }]
+  }
+
+  @returns
+  {
+    description: <Trade Description String>
+    id: <Trade Id Hex String>
+  }
+*/
+module.exports = ({records}) => {
+  if (!isArray(records)) {
+    throw new Error('ExpectedArrayOfRecordsToDecodeBasicTrade');
+  }
+
+  const descriptionRecord = findDescriptionRecord(records);
+
+  if (!descriptionRecord) {
+    throw new Error('ExpectedDescriptionRecordToDecodeBasicTrade');
+  }
+
+  const idRecord = findIdRecord(records);
+
+  if (!idRecord) {
+    throw new Error('ExpectedIdRecordToDecodeBasicTradeDetails');
+  }
+
+  return {
+    description: hexAsUtf8(descriptionRecord.value),
+    id: idRecord.value,
+  };
+};