paid-services 3.5.1 → 3.6.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Versions
 
+## Version 3.6.0
+
+- `manageTrades`: Add support for persistent open trades
+- `manageTrades`: Add expiration dates to open trades
+- `manageTrades`: Support longer-lived open trade scenarios
+- `manageTrades`: Show final encoded trade when requesting open trade
+- `manageTrades`: Check for RPC signer support before trading
+
 ## Version 3.5.1
 
 - `changeChannelCapacity`: Allow changing private/public status of channel

package/capacity/get_capacity_replacement.js

@@ -266,7 +266,6 @@ module.exports = (args, cbk) => {
             give_tokens: pendingChannel.remote_balance,
             is_private: args.is_private,
             partner_public_key: pendingChannel.partner_public_key,
-            is_private: args.is_private,
           }],
           is_avoiding_broadcast: true,
           lnd: args.lnd,

package/capacity/initiate_capacity_change.js

@@ -47,7 +47,6 @@ const rebroadcastTimeMs = 1000 * 5;
 const recordsAsObject = a => a.reduce((sum, n) => sum[n.type] = n.value, {});
 const requestCapacityChangeIntervalMs = 2000;
 const requestCapacityChangeTimeoutMs = 1000 * 60 * 60 * 6;
-const sumOf = arr => arr.reduce((sum, n) => sum + n, Number());
 const testMessage = '00';
 const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 const uniq = arr => Array.from(new Set(arr));

package/package.json

@@ -7,20 +7,20 @@
     "url": "https://github.com/alexbosworth/paid-services/issues"
   },
   "dependencies": {
-    "async": "3.2.2",
-    "asyncjs-util": "1.2.7",
+    "async": "3.2.3",
+    "asyncjs-util": "1.2.8",
     "bolt01": "1.2.3",
     "bolt07": "1.8.0",
-    "invoices": "2.0.2",
-    "ln-service": "53.2.0",
+    "invoices": "2.0.3",
+    "ln-service": "53.4.0",
     "ln-sync": "3.6.1"
   },
   "description": "Lightning Paid Services library",
   "devDependencies": {
     "@alexbosworth/tap": "15.0.10",
-    "ln-docker-daemons": "2.1.0",
+    "ln-docker-daemons": "2.2.0",
     "mock-lnd": "1.4.1",
-    "secp256k1": "4.0.2"
+    "secp256k1": "4.0.3"
   },
   "engines": {
     "node": ">=12.20"
@@ -40,5 +40,5 @@
     "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/trades/*.js"
   },
-  "version": "3.5.1"
+  "version": "3.6.0"
 }

package/services/response_for_relay.js

@@ -18,7 +18,6 @@ const defaultProbeTimeoutMs = 1000 * 60 * 5;
 const expiresAt = () => new Date(Date.now() + 1000 * 60 * 30).toISOString();
 const interval = 1000 * 60 * 10;
 const rateDivisor = BigInt(1e6);
-const sumOf = arr => arr.reduce((sum, n) => BigInt(n) + n, BigInt(0));
 const text = 'Relay payment request created';
 const times = 12;
 

package/test/integration/test_accept_capacity_change.js

@@ -32,7 +32,6 @@ 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);

package/test/integration/test_change_channel_capacity.js

@@ -27,7 +27,6 @@ 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);

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);

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);

package/trades/accept_trade.js

@@ -1,6 +1,7 @@
 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');
 
@@ -10,13 +11,14 @@ const {isArray} = Array;
 
   {
     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, lnd, secret}, cbk) => {
+module.exports = ({cancel, id, lnd, secret}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -25,6 +27,10 @@ module.exports = ({cancel, lnd, secret}, cbk) => {
           return cbk([400, 'ExpectedArrayOfIdsToCancelToAcceptTrade']);
         }
 
+        if (!id) {
+          return cbk([400, 'ExpectedAnchorTradeIdToAcceptTrade']);
+        }
+
         if (!lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToAcceptTrade']);
         }
@@ -36,9 +42,12 @@ module.exports = ({cancel, lnd, secret}, cbk) => {
         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: ['validate', ({}, cbk) => {
-        return asyncEach(cancel, (id, cbk) => {
+      cancel: ['getAnchor', ({}, cbk) => {
+        return asyncEach([].concat(cancel).concat(id), (id, cbk) => {
           return cancelHodlInvoice({id, lnd}, cbk);
         },
         cbk);

package/trades/create_trade.js

@@ -1,21 +1,23 @@
 const asyncAuto = require('async/auto');
+const {createInvoice} = require('ln-service');
 const {getChannels} = require('ln-service');
 const {getNetwork} = require('ln-sync');
-const {getNodeAlias} = require('ln-sync');
 const {getWalletInfo} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
-const encodeOpenTrade = require('./encode_open_trade');
+const encodeAnchoredTrade = require('./encode_anchored_trade');
 const finalizeTradeSecret = require('./finalize_trade_secret');
-const serviceTradeRequests = require('./service_trade_requests');
+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 nodeName = (alias, id) => `${alias} ${id}`;
 const uriAsSocket = n => n.substring(67);
 const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
 
@@ -164,20 +166,76 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         cbk);
       }],
 
+      // 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',
+        ({
+          askForDescription,
+          askForExpiration,
+          askForNodeId,
+          askForPrice,
+          askForSecret,
+        },
+        cbk) =>
+      {
+        // 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,
+          description: encoded,
+          expires_at: futureDate(daysAsMs(askForExpiration.days)),
+          tokens: asNumber(askForPrice.tokens),
+        },
+        cbk);
+      }],
+
       // Wait for a peer to connect and ask for the trade details
       serviceTradeRequests: [
         'askForDescription',
+        'askForExpiration',
         'askForNodeId',
         'askForPrice',
         'askForSecret',
+        'createAnchor',
         'getChannels',
         'getIdentity',
         'getNetwork',
         ({
           askForDescription,
+          askForExpiration,
           askForNodeId,
           askForPrice,
           askForSecret,
+          createAnchor,
           getChannels,
           getIdentity,
           getNetwork,
@@ -189,64 +247,37 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
-        // Encode the open trade details to give out
-        const openTrade = encodeOpenTrade({
-          network: getNetwork.network,
-          nodes: [{
-            channels: getChannels.channels,
-            id: getIdentity.public_key,
-            sockets: (getIdentity.uris || []).map(uriAsSocket),
-          }],
-        });
-
-        const settled = [];
-
-        const sub = serviceTradeRequests({
+        return serviceOpenTrade({
           lnd,
+          logger,
+          channels: getChannels.channels,
           description: askForDescription.description,
+          expires_at: futureDate(daysAsMs(askForExpiration.days)),
+          id: createAnchor.id,
+          network: getNetwork.network,
+          public_key: getIdentity.public_key,
           secret: askForSecret.secret,
           tokens: asNumber(askForPrice.tokens),
-        });
-
-        sub.on('details', async ({to}) => {
-          const {alias, id} = await getNodeAlias({lnd, id: to});
-
-          return logger.info({return_trade_info_to: nodeName(alias, id)});
-        });
-
-        sub.once('end', async () => {
-          const [to] = settled;
-
-          if (!!to) {
-            const {alias, id} = await getNodeAlias({lnd, id: to});
-
-            return logger.info({finished_trade_with: nodeName(alias, id)});
-          }
-
-          return cbk();
-        });
-
-        sub.on('failure', failure => logger.error({failure}));
-
-        sub.on('settled', ({to}) => settled.push(to));
-
-        sub.on('trade', async ({to}) => {
-          const {alias, id} = await getNodeAlias({lnd, id: to});
-
-          return logger.info({make_trade_invoice_for: nodeName(alias, id)});
-        });
-
-        // Show the trade details blob
-        return logger.info({waiting_for_trade_request_to: openTrade.trade});
+          uris: (getIdentity.uris || []),
+        },
+        cbk);
       }],
 
       // Finalize the trade with an encrypted secret and an invoice
       finalize: [
         'askForDescription',
+        'askForExpiration',
         'askForNodeId',
         'askForPrice',
         'askForSecret',
-        ({askForDescription, askForNodeId, askForPrice, askForSecret}, cbk) =>
+        ({
+          askForDescription,
+          askForExpiration,
+          askForNodeId,
+          askForPrice,
+          askForSecret,
+        },
+        cbk) =>
       {
         // Exit early when there is no node to finalize the trade to
         if (!askForNodeId.id) {
@@ -256,6 +287,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         return finalizeTradeSecret({
           lnd,
           description: askForDescription.description,
+          expires_at: futureDate(daysAsMs(askForExpiration.days)),
           secret: askForSecret.secret,
           to: askForNodeId.id,
           tokens: asNumber(askForPrice.tokens),

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/encode_anchored_trade.js

@@ -0,0 +1,35 @@
+const {encodeTlvStream} = require('bolt01');
+
+const anchorPrefix = 'anchor-trade-secret:';
+const descriptionRecord = value => !!value ? ({value, type: '1'}) : undefined;
+const secretRecord = value => ({value, type: '0'});
+const utf8AsHex = utf8 => Buffer.from(utf8, 'utf8').toString('hex');
+const withPrefix = (pre, v) => pre + Buffer.from(v, 'hex').toString('base64');
+
+/** Encode a trade into an anchor blob
+
+  This will look like anchored-trade-secret:<base64-encoded-data>
+
+  The data encodes a TLV:
+  0: <Trade Secret>
+  [1]: <Trade Description>
+
+  {
+    [description]: <Open Trade Description String>
+    secret: <Open Trade Secret String>
+  }
+
+  @returns
+  {
+    encoded: <Encoded Anchor Trade Data Blob String>
+  }
+*/
+module.exports = ({description, secret}) => {
+  const records = [secretRecord(secret), descriptionRecord(description)]
+    .filter(n => !!n)
+    .map(({type, value}) => ({type, value: utf8AsHex(value)}));
+
+  const {encoded} = encodeTlvStream({records});
+
+  return {encoded: withPrefix(anchorPrefix, encoded)};
+};

package/trades/finalize_trade_secret.js

@@ -17,6 +17,7 @@ const utf8AsHex = utf8 => Buffer.from(utf8, 'utf8').toString('hex');
 
   {
     description: <Trade Description String>
+    expires_at: <Trade Expires At ISO 8601 Date String>
     is_hold: <Create Hold Invoice Bool>
     lnd: <Authenticated LND API Object>
     secret: <Clear Secret String>
@@ -40,6 +41,10 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedDescriptionToFinalizeTradeSecret']);
         }
 
+        if (!args.expires_at) {
+          return cbk([400, 'ExpectedExpiresAtDateToFinalizeTradeSecret']);
+        }
+
         if (!args.lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToFinalizeTradeSecret']);
         }
@@ -75,6 +80,7 @@ module.exports = (args, cbk) => {
         if (!!args.is_hold) {
           return createHodlInvoice({
             description: args.description,
+            expires_at: args.expires_at,
             id: bufferAsHex(sha256(hexAsBuffer(encrypt.payment_secret))),
             lnd: args.lnd,
             secret: encrypt.payment_secret,
@@ -85,6 +91,7 @@ module.exports = (args, cbk) => {
 
         return createInvoice({
           description: args.description,
+          expires_at: args.expires_at,
           lnd: args.lnd,
           secret: encrypt.payment_secret,
           tokens: args.tokens,

package/trades/find_trade.js

@@ -24,6 +24,8 @@ const makeRequestId = () => randomBytes(32).toString('hex');
 const requestTradeType = '805005';
 const requestTradesTimeoutMs = 1000 * 30;
 const tradesRequestIdType = '1';
+const uniq = arr => Array.from(new Set(arr));
+const uniqBy = (a,b) => a.filter((e,i) => a.findIndex(n => n[b] == e[b]) == i);
 const waitForTradesMs = 1000 * 5;
 
 /** Find a trade to purchase
@@ -49,6 +51,7 @@ const waitForTradesMs = 1000 * 5;
     auth: <Encrypted Payload Auth Hex String>
     payload: <Preimage Encrypted Payload Hex String>
     request: <BOLT 11 Payment Request String>
+    trade: <Encoded Trade String>
   }
 */
 module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
@@ -89,7 +92,23 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
 
           // Exit early when the node id and sockets is specified directly
           if (!!connect.node) {
-            return cbk(null, connect.node);
+            return getNode({
+              lnd,
+              is_omitting_channels: true,
+              public_key: connect.node.id,
+            },
+            (err, res) => {
+              if (!!err) {
+                return cbk(null, connect.node);
+              }
+
+              const sockets = connect.node.sockets.map(n => n.socket);
+
+              return cbk(null, {
+                id: connect.node.id,
+                sockets: uniq([].concat(sockets).concat(connect.node.sockets)),
+              });
+            });
           }
 
           // Exit early when there is no landmark channel
@@ -156,6 +175,8 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
 
         // Try and connect to a referenced node
         return asyncDetect(getNodes.filter(n => !!n), (node, cbk) => {
+          logger.info({connecting_to: node.id});
+
           // Attempt referenced sockets to establish p2p connection
           return asyncDetectSeries(node.sockets, (socket, cbk) => {
             return addPeer({lnd, socket, public_key: node.id}, err => {
@@ -238,6 +259,8 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
           return res.success({});
         });
 
+        logger.info({requesting_trade_details: true});
+
         // Once connected, ask for the trade details
         return makePeerRequest({
           lnd,
@@ -270,7 +293,9 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
           return cbk([404, 'NoTradesFound']);
         }
 
-        const [trade, other] = requestTrades.trades;
+        const uniqueTrades = uniqBy(requestTrades.trades, 'description');
+
+        const [trade, other] = uniqueTrades;
 
         // Exit early when there is only a single trade
         if (!other) {
@@ -279,7 +304,7 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
 
         // Present the possible choices
         return ask({
-          choices: requestTrades.trades.map(trade => ({
+          choices: uniqueTrades.map(trade => ({
             name: trade.description,
             value: trade.id,
           })),

package/trades/manage_trade.js

@@ -16,6 +16,7 @@ const findTrade = require('./find_trade');
 const hexAsUtf8 = hex => Buffer.from(hex, 'hex').toString();
 const {isArray} = Array;
 const isHexPreimage = n => !!n && /^[0-9A-F]{64}$/i.test(n);
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 
 /** Manage an individual trade
 
@@ -141,7 +142,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         logger.info({
           id: requestDetails.id,
           offering: requestDetails.description,
-          price: requestDetails.tokens,
+          price: tokensAsBigUnit(requestDetails.tokens),
           is_canceled: invoice.is_canceled || undefined,
           is_purchased: invoice.is_confirmed || undefined,
         });
@@ -169,7 +170,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         logger.info({
           id: requestDetails.id,
           offering: requestDetails.description,
-          price: requestDetails.tokens,
+          price: tokensAsBigUnit(requestDetails.tokens),
         });
 
         return ask({
@@ -195,7 +196,15 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
-        return cancelHodlInvoice({lnd, id: requestDetails.id}, cbk);
+        return cancelHodlInvoice({lnd, id: requestDetails.id}, err => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          logger.info({trade_canceled: true});
+
+          return cbk();
+        });
       }],
 
       // Select a purchase option for the trade
@@ -216,10 +225,12 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
+        logger.info({trade: findTrade.trade});
+
         logger.info({
           request: findTrade.request,
           purchase: requestDetails.description,
-          price: requestDetails.tokens,
+          price: tokensAsBigUnit(requestDetails.tokens),
           to: requestDetails.destination,
         });