paid-services 6.1.4 → 6.1.5

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## Version 6.1.4
+## Version 6.1.5
 
 - `manageSwap`: Add support for Loop Out to external address
 

package/package.json

@@ -13,12 +13,12 @@
     "asyncjs-util": "1.2.12",
     "bech32": "2.0.0",
     "bolt01": "2.0.0",
-    "bolt07": "1.9.3",
+    "bolt07": "1.9.4",
     "ecpair": "2.1.0",
     "goldengate": "14.0.7",
     "invoices": "3.0.0",
-    "ln-service": "57.14.2",
-    "ln-sync": "6.0.4",
+    "ln-service": "57.17.0",
+    "ln-sync": "6.1.0",
     "psbt": "3.0.0",
     "p2tr": "2.0.0",
     "tiny-secp256k1": "2.2.3"
@@ -26,8 +26,8 @@
   "description": "Lightning Paid Services library",
   "devDependencies": {
     "@alexbosworth/tap": "15.0.12",
-    "ln-docker-daemons": "6.0.19",
-    "mock-lnd": "1.4.4",
+    "ln-docker-daemons": "6.0.21",
+    "mock-lnd": "2.0.0",
     "secp256k1": "5.0.0"
   },
   "engines": {
@@ -48,5 +48,5 @@
     "integration-tests": "tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 2700 test/integration/*.js",
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 60 test/actions/*.js test/balanced/*.js test/capacity/*.js test/client/*.js test/config/*.js test/p2p/*.js test/records/*.js test/respond/*.js test/server/*.js test/swaps/*.js test/services/*.js test/trades/*.js"
   },
-  "version": "6.1.4"
+  "version": "6.1.5"
 }

package/test/client/test_make_service_request.js

@@ -4,7 +4,6 @@ const {makeInvoiceSubscription} = require('mock-lnd');
 const {makeLnd} = require('mock-lnd');
 const {makePaySubscription} = require('mock-lnd');
 const {makePayViaRoutesResponse} = require('mock-lnd');
-const {makePaymentRequest} = require('mock-lnd');
 const {test} = require('@alexbosworth/tap');
 
 const messagesForResponse = require('./../../respond/messages_for_response');
@@ -14,7 +13,6 @@ const responseForSchema = require('./../../services/response_for_schema');
 const encode = records => encodeTlvStream({records: [records]}).encoded;
 const id1 = Buffer.alloc(32).toString('hex');
 const id2 = Buffer.alloc(32, 1).toString('hex');
-const {request} = makePaymentRequest({});
 
 const makeArgs = overrides => {
   let requests = 0;

package/test/respond/test_send_service_response.js

@@ -2,87 +2,99 @@ const {makeLnd} = require('mock-lnd');
 const {makePayViaRoutesResponse} = require('mock-lnd');
 const {makePaymentRequest} = require('mock-lnd');
 const {test} = require('@alexbosworth/tap');
+const tinysecp = require('tiny-secp256k1');
 
 const method = require('./../../respond/send_service_response');
 
-const makeArgs = overrides => {
-  let requests = 0;
+(async () => {
+  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
 
-  const lnd = makeLnd({
-    payViaRoutes: ({}, cbk) => {
-      requests++;
+  const makeArgs = overrides => {
+    let requests = 0;
 
-      if (requests === 2) {
-        return cbk(null, makePayViaRoutesResponse({}));
-      }
+    const lnd = makeLnd({
+      payViaRoutes: ({}, cbk) => {
+        requests++;
 
-      return cbk(null, makePayViaRoutesResponse({is_unknown_failure: true}));
-    },
-  });
+        if (requests === 2) {
+          return cbk(null, makePayViaRoutesResponse({}));
+        }
 
-  const args = {
-    lnd,
-    mtokens: '10000',
-    request: 'lnbc1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdpl2pkx2ctnv5sxxmmwwd5kgetjypeh2ursdae8g6twvus8g6rfwvs8qun0dfjkxaq8rkx3yf5tcsyz3d73gafnh3cax9rn449d9p5uxz9ezhhypd0elx87sjle52x86fux2ypatgddc6k63n7erqz25le42c4u4ecky03ylcqca784w',
-    text: 'text',
-  };
+        return cbk(null, makePayViaRoutesResponse({is_unknown_failure: true}));
+      },
+    });
 
-  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+    const args = {
+      lnd,
+      mtokens: '10000',
+      request: 'lnbc1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdpl2pkx2ctnv5sxxmmwwd5kgetjypeh2ursdae8g6twvus8g6rfwvs8qun0dfjkxaq8rkx3yf5tcsyz3d73gafnh3cax9rn449d9p5uxz9ezhhypd0elx87sjle52x86fux2ypatgddc6k63n7erqz25le42c4u4ecky03ylcqca784w',
+      text: 'text',
+    };
 
-  return args;
-};
+    Object.keys(overrides).forEach(k => args[k] = overrides[k]);
 
-const tests = [
-  {
-    args: makeArgs({error: 'error'}),
-    description: 'A request is expected to include valid response records',
-    error: [400, 'ExpectedValidServiceResponseToSend'],
-  },
-  {
-    args: makeArgs({mtokens: undefined}),
-    description: 'The mtokens received are expected',
-    error: [400, 'ExpectedMillitokensReceivedToSendResponse'],
-  },
-  {
-    args: makeArgs({request: undefined}),
-    description: 'A response request is expected',
-    error: [400, 'ExpectedResponsePaymentRequestToSendResponse'],
-  },
-  {
-    args: makeArgs({request: 'request'}),
-    description: 'A valid response request is expected',
-    error: [400, 'ExpectedValidPaymentRequestToPayResponse'],
-  },
-  {
-    args: makeArgs({}),
-    description: 'An unexpired invoice is required',
-    error: [400, 'ExpectedUnexpiredInvoiceToSendServiceResponse'],
-  },
-  {
-    args: makeArgs({mtokens: '1', request: makePaymentRequest({}).request}),
-    description: 'Payment cannot be greater than the mtokens received',
-    error: [400, 'ExpectedPaymentTokensNotGreaterThanReceived'],
-  },
-  {
-    args: makeArgs({request: makePaymentRequest({mtokens: '0'}).request}),
-    description: 'A zero mtokens response is paid',
-  },
-  {
-    args: makeArgs({request: makePaymentRequest({mtokens: '1'}).request}),
-    description: 'A service response is delivered',
-  },
-];
+    return args;
+  };
 
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async ({end, strictSame, rejects}) => {
-    if (!!error) {
-      await rejects(method(args), error, 'Got error');
-    } else {
-      const res = await method(args);
+  const tests = [
+    {
+      args: makeArgs({error: 'error'}),
+      description: 'A request is expected to include valid response records',
+      error: [400, 'ExpectedValidServiceResponseToSend'],
+    },
+    {
+      args: makeArgs({mtokens: undefined}),
+      description: 'The mtokens received are expected',
+      error: [400, 'ExpectedMillitokensReceivedToSendResponse'],
+    },
+    {
+      args: makeArgs({request: undefined}),
+      description: 'A response request is expected',
+      error: [400, 'ExpectedResponsePaymentRequestToSendResponse'],
+    },
+    {
+      args: makeArgs({request: 'request'}),
+      description: 'A valid response request is expected',
+      error: [400, 'ExpectedValidPaymentRequestToPayResponse'],
+    },
+    {
+      args: makeArgs({}),
+      description: 'An unexpired invoice is required',
+      error: [400, 'ExpectedUnexpiredInvoiceToSendServiceResponse'],
+    },
+    {
+      args: makeArgs({
+        mtokens: '1',
+        request: makePaymentRequest({ecp}).request,
+      }),
+      description: 'Payment cannot be greater than the mtokens received',
+      error: [400, 'ExpectedPaymentTokensNotGreaterThanReceived'],
+    },
+    {
+      args: makeArgs({
+        request: makePaymentRequest({ecp, mtokens: '0'}).request,
+      }),
+      description: 'A zero mtokens response is paid',
+    },
+    {
+      args: makeArgs({
+        request: makePaymentRequest({ecp, mtokens: '1'}).request,
+      }),
+      description: 'A service response is delivered',
+    },
+  ];
+
+  tests.forEach(({args, description, error, expected}) => {
+    return test(description, async ({end, strictSame, rejects}) => {
+      if (!!error) {
+        await rejects(method(args), error, 'Got error');
+      } else {
+        const res = await method(args);
 
-      strictSame(res, expected, 'Got expected result');
-    }
+        strictSame(res, expected, 'Got expected result');
+      }
 
-    return end();
+      return end();
+    });
   });
-});
+})();

package/test/server/test_paid_service_event.js

@@ -4,6 +4,7 @@ const {makeLnd} = require('mock-lnd');
 const {makePayViaRoutesResponse} = require('mock-lnd');
 const {makePaymentRequest} = require('mock-lnd');
 const {test} = require('@alexbosworth/tap');
+const tinysecp = require('tiny-secp256k1');
 
 const messagesForRequest = require('./../../client/messages_for_request');
 const method = require('./../../server/paid_service_event');
@@ -11,187 +12,192 @@ const method = require('./../../server/paid_service_event');
 const encode = records => encodeTlvStream({records: [records]}).encoded;
 const id1 = Buffer.alloc(32).toString('hex');
 const id2 = Buffer.alloc(32, 1).toString('hex');
-const {request} = makePaymentRequest({});
 
-const {messages} = messagesForRequest({reply: request, service: '2'});
+(async () => {
+  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
 
-const makeArgs = overrides => {
-  let requests = 0;
+  const {request} = makePaymentRequest({ecp});
 
-  const lnd = makeLnd({
-    getInvoice: ({}, cbk) => {
-      return cbk(null, makeInvoice({
-        is_confirmed: true,
-        is_push: true,
-        payments: [{messages, is_confirmed: true}],
-      }));
-    },
-    payViaRoutes: ({}, cbk) => {
-      requests++;
+  const {messages} = messagesForRequest({reply: request, service: '2'});
 
-      if (requests === 2) {
-        return cbk(null, makePayViaRoutesResponse({}));
-      }
+  const makeArgs = overrides => {
+    let requests = 0;
 
-      return cbk(null, makePayViaRoutesResponse({is_unknown_failure: true}));
-    },
-  });
+    const lnd = makeLnd({
+      getInvoice: ({}, cbk) => {
+        return cbk(null, makeInvoice({
+          is_confirmed: true,
+          is_push: true,
+          payments: [{messages, is_confirmed: true}],
+        }));
+      },
+      payViaRoutes: ({}, cbk) => {
+        requests++;
+
+        if (requests === 2) {
+          return cbk(null, makePayViaRoutesResponse({}));
+        }
+
+        return cbk(null, makePayViaRoutesResponse({is_unknown_failure: true}));
+      },
+    });
+
+    const args = {
+      lnd,
+      env: {},
+      fetch: () => new Promise(resolve => resolve()),
+      id: id1,
+      network: 'btc',
+      payer: lnd,
+    };
+
+    Object.keys(overrides).forEach(k => args[k] = overrides[k]);
 
-  const args = {
-    lnd,
-    env: {},
-    fetch: () => new Promise(resolve => resolve()),
-    id: id1,
-    network: 'btc',
-    payer: lnd,
+    return args;
   };
 
-  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
-
-  return args;
-};
-
-const tests = [
-  {
-    args: makeArgs({env: undefined}),
-    description: 'Processing a service request requires env vars',
-    error: [400, 'ExpectedEnvironmentVariablesForPaidServiceEvent'],
-  },
-  {
-    args: makeArgs({fetch: undefined}),
-    description: 'Processing a service request requires a fetch function',
-    error: [400, 'ExpectedFetchFunctionForPaidServiceEvent'],
-  },
-  {
-    args: makeArgs({id: undefined}),
-    description: 'Processing a service request requires an invoice id',
-    error: [400, 'ExpectedInvoiceIdForPaidServiceEvent'],
-  },
-  {
-    args: makeArgs({lnd: undefined}),
-    description: 'Processing a service request requires lnd to lookup invoice',
-    error: [400, 'ExpectedAuthenticatedLndForPaidServiceEvent'],
-  },
-  {
-    args: makeArgs({network: undefined}),
-    description: 'Processing a service request requires network name',
-    error: [400, 'ExpectedNetworkNameStringToGetServiceRequest'],
-  },
-  {
-    args: makeArgs({payer: undefined}),
-    description: 'Processing a service request requires a payer to respond',
-    error: [400, 'ExpectedPayerLndForPaidServiceEvent'],
-  },
-  {
-    args: makeArgs({}),
-    description: 'A paid service event happens',
-    expected: {
-      error: undefined,
-      node: '03e7156ae33b0a208d0744199163177e909e80176e55d97a2f221ede0f934dd9ad',
-      service: 'ping',
+  const tests = [
+    {
+      args: makeArgs({env: undefined}),
+      description: 'Processing a service request requires env vars',
+      error: [400, 'ExpectedEnvironmentVariablesForPaidServiceEvent'],
     },
-  },
-  {
-    args: makeArgs({
-      lnd: makeLnd({
-        getInvoice: ({}, cbk) => {
-          return cbk(null, makeInvoice({
-            is_confirmed: true,
-            is_push: true,
-            payments: [],
-          }));
-        },
-      }),
-    }),
-    description: 'A random push happens',
-    expected: {},
-  },
-  {
-    args: makeArgs({
-      env: {
-        PAID_SERVICES_INBOX_EMAIL_FROM: 'from',
-        PAID_SERVICES_INBOX_EMAIL_TO: 'to',
-        PAID_SERVICES_INBOX_POSTMARK_API_KEY: 'key',
-        PAID_SERVICES_INBOX_PRICE: '1',
+    {
+      args: makeArgs({fetch: undefined}),
+      description: 'Processing a service request requires a fetch function',
+      error: [400, 'ExpectedFetchFunctionForPaidServiceEvent'],
+    },
+    {
+      args: makeArgs({id: undefined}),
+      description: 'Processing a service request requires an invoice id',
+      error: [400, 'ExpectedInvoiceIdForPaidServiceEvent'],
+    },
+    {
+      args: makeArgs({lnd: undefined}),
+      description: 'Processing a service request requires lnd to lookup invoice',
+      error: [400, 'ExpectedAuthenticatedLndForPaidServiceEvent'],
+    },
+    {
+      args: makeArgs({network: undefined}),
+      description: 'Processing a service request requires network name',
+      error: [400, 'ExpectedNetworkNameStringToGetServiceRequest'],
+    },
+    {
+      args: makeArgs({payer: undefined}),
+      description: 'Processing a service request requires a payer to respond',
+      error: [400, 'ExpectedPayerLndForPaidServiceEvent'],
+    },
+    {
+      args: makeArgs({}),
+      description: 'A paid service event happens',
+      expected: {
+        error: undefined,
+        node: '03e7156ae33b0a208d0744199163177e909e80176e55d97a2f221ede0f934dd9ad',
+        service: 'ping',
       },
-      lnd: makeLnd({
-        getInvoice: ({id}, cbk) => {
-          switch (id) {
-          // Return a paywall invoice
-          case id1:
+    },
+    {
+      args: makeArgs({
+        lnd: makeLnd({
+          getInvoice: ({}, cbk) => {
             return cbk(null, makeInvoice({
-              description_hash: id2,
               is_confirmed: true,
+              is_push: true,
+              payments: [],
             }));
+          },
+        }),
+      }),
+      description: 'A random push happens',
+      expected: {},
+    },
+    {
+      args: makeArgs({
+        env: {
+          PAID_SERVICES_INBOX_EMAIL_FROM: 'from',
+          PAID_SERVICES_INBOX_EMAIL_TO: 'to',
+          PAID_SERVICES_INBOX_POSTMARK_API_KEY: 'key',
+          PAID_SERVICES_INBOX_PRICE: '1',
+        },
+        lnd: makeLnd({
+          getInvoice: ({id}, cbk) => {
+            switch (id) {
+            // Return a paywall invoice
+            case id1:
+              return cbk(null, makeInvoice({
+                description_hash: id2,
+                is_confirmed: true,
+              }));
 
-          // Return a keysend invoice
-          case id2:
+            // Return a keysend invoice
+            case id2:
+              return cbk(null, makeInvoice({
+                is_confirmed: true,
+                is_push: true,
+                payments: [{
+                  is_confirmed: true,
+                  messages: messagesForRequest({
+                    arguments: encode({
+                      type: '0',
+                      value: Buffer.from('message').toString('hex'),
+                    }),
+                    reply: request,
+                    service: '4',
+                  }).messages,
+                }],
+              }));
+
+            default:
+              return cbk([500, 'UnexpectedIdentifierForGetInvoice', {id}]);
+            }
+          },
+        }),
+      }),
+      description: 'A paywall request is processed',
+      expected: {
+        error: undefined,
+        node: '03e7156ae33b0a208d0744199163177e909e80176e55d97a2f221ede0f934dd9ad',
+        service: 'inbox',
+      },
+    },
+    {
+      args: makeArgs({
+        lnd: makeLnd({
+          getInvoice: ({}, cbk) => {
             return cbk(null, makeInvoice({
               is_confirmed: true,
               is_push: true,
               payments: [{
-                is_confirmed: true,
                 messages: messagesForRequest({
-                  arguments: encode({
-                    type: '0',
-                    value: Buffer.from('message').toString('hex'),
-                  }),
                   reply: request,
-                  service: '4',
+                  service: '3',
                 }).messages,
+                is_confirmed: true,
               }],
             }));
-
-          default:
-            return cbk([500, 'UnexpectedIdentifierForGetInvoice', {id}]);
-          }
-        },
+          },
+        }),
       }),
-    }),
-    description: 'A paywall request is processed',
-    expected: {
-      error: undefined,
-      node: '03e7156ae33b0a208d0744199163177e909e80176e55d97a2f221ede0f934dd9ad',
-      service: 'inbox',
-    },
-  },
-  {
-    args: makeArgs({
-      lnd: makeLnd({
-        getInvoice: ({}, cbk) => {
-          return cbk(null, makeInvoice({
-            is_confirmed: true,
-            is_push: true,
-            payments: [{
-              messages: messagesForRequest({
-                reply: request,
-                service: '3',
-              }).messages,
-              is_confirmed: true,
-            }],
-          }));
-        },
-      }),
-    }),
-    description: 'A request is processed',
-    expected: {
-      error: [404, 'ServiceCurrentlyUnsupported'],
-      node: '03e7156ae33b0a208d0744199163177e909e80176e55d97a2f221ede0f934dd9ad',
-      service: 'profile',
+      description: 'A request is processed',
+      expected: {
+        error: [404, 'ServiceCurrentlyUnsupported'],
+        node: '03e7156ae33b0a208d0744199163177e909e80176e55d97a2f221ede0f934dd9ad',
+        service: 'profile',
+      },
     },
-  },
-];
+  ];
 
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async ({end, equal, rejects, strictSame}) => {
-    if (!!error) {
-      await rejects(method(args), error, 'Got expected error');
-    } else {
-      const res = await method(args);
+  tests.forEach(({args, description, error, expected}) => {
+    return test(description, async ({end, equal, rejects, strictSame}) => {
+      if (!!error) {
+        await rejects(method(args), error, 'Got expected error');
+      } else {
+        const res = await method(args);
 
-      strictSame(res, expected, 'Got expected result');
-    }
+        strictSame(res, expected, 'Got expected result');
+      }
 
-    return end();
+      return end();
+    });
   });
-});
+})();

package/test/server/test_process_paywall.js

@@ -3,6 +3,7 @@ const {makeInvoice} = require('mock-lnd');
 const {makeLnd} = require('mock-lnd');
 const {makePaymentRequest} = require('mock-lnd');
 const {test} = require('@alexbosworth/tap');
+const tinysecp = require('tiny-secp256k1');
 
 const messagesForRequest = require('./../../client/messages_for_request');
 const method = require('./../../server/process_paywall');
@@ -10,104 +11,109 @@ const method = require('./../../server/process_paywall');
 const encode = records => encodeTlvStream({records: [records]}).encoded;
 const id1 = Buffer.alloc(32).toString('hex');
 const id2 = Buffer.alloc(32, 1).toString('hex');
-const {request} = makePaymentRequest({});
 
-const {messages} = messagesForRequest({reply: request, service: '2'});
+(async () => {
+  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
 
-const makeArgs = overrides => {
-  const args = {
-    env: {
-      PAID_SERVICES_INBOX_EMAIL_FROM: 'from',
-      PAID_SERVICES_INBOX_EMAIL_TO: 'to',
-      PAID_SERVICES_INBOX_POSTMARK_API_KEY: 'key',
-      PAID_SERVICES_INBOX_PRICE: '1',
-    },
-    fetch: () => new Promise(resolve => resolve()),
-    id: id1,
-    lnd: makeLnd({
-      getInvoice: ({id}, cbk) => {
-        switch (id) {
-        // Return a paywall invoice
-        case id1:
-          return cbk(null, makeInvoice({
-            description_hash: id2,
-            is_confirmed: true,
-          }));
+  const {request} = makePaymentRequest({ecp});
 
-        // Return a keysend invoice
-        case id2:
-          return cbk(null, makeInvoice({
-            is_confirmed: true,
-            is_push: true,
-            payments: [{
-              is_confirmed: true,
-              messages: messagesForRequest({
-                arguments: encode({
-                  type: '0',
-                  value: Buffer.from('message').toString('hex'),
-                }),
-                reply: request,
-                service: '4',
-              }).messages,
-            }],
-          }));
+  const {messages} = messagesForRequest({reply: request, service: '2'});
 
-        default:
-          return cbk([500, 'UnexpectedIdentifierForGetInvoice', {id}]);
-        }
+  const makeArgs = overrides => {
+    const args = {
+      env: {
+        PAID_SERVICES_INBOX_EMAIL_FROM: 'from',
+        PAID_SERVICES_INBOX_EMAIL_TO: 'to',
+        PAID_SERVICES_INBOX_POSTMARK_API_KEY: 'key',
+        PAID_SERVICES_INBOX_PRICE: '1',
       },
-    }),
-    network: 'btc',
-    payer: makeLnd({}),
-  };
+      fetch: () => new Promise(resolve => resolve()),
+      id: id1,
+      lnd: makeLnd({
+        getInvoice: ({id}, cbk) => {
+          switch (id) {
+          // Return a paywall invoice
+          case id1:
+            return cbk(null, makeInvoice({
+              description_hash: id2,
+              is_confirmed: true,
+            }));
+
+          // Return a keysend invoice
+          case id2:
+            return cbk(null, makeInvoice({
+              is_confirmed: true,
+              is_push: true,
+              payments: [{
+                is_confirmed: true,
+                messages: messagesForRequest({
+                  arguments: encode({
+                    type: '0',
+                    value: Buffer.from('message').toString('hex'),
+                  }),
+                  reply: request,
+                  service: '4',
+                }).messages,
+              }],
+            }));
+
+          default:
+            return cbk([500, 'UnexpectedIdentifierForGetInvoice', {id}]);
+          }
+        },
+      }),
+      network: 'btc',
+      payer: makeLnd({}),
+    };
 
-  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+    Object.keys(overrides).forEach(k => args[k] = overrides[k]);
 
-  return args;
-};
+    return args;
+  };
 
-const tests = [
-  {
-    args: makeArgs({env: undefined}),
-    description: 'Processing a paywall requires env vars',
-    error: [400, 'ExpectedEnvironmentVariablesToProcessPaywall'],
-  },
-  {
-    args: makeArgs({fetch: undefined}),
-    description: 'Processing a paywall requires a fetch function',
-    error: [400, 'ExpectedFetchFunctionToProcessPaywallPayment'],
-  },
-  {
-    args: makeArgs({id: undefined}),
-    description: 'Processing a paywall requires an invoice id',
-    error: [400, 'ExpectedInvoiceIdToProcessPaywallRequest'],
-  },
-  {
-    args: makeArgs({lnd: undefined}),
-    description: 'Processing a paywall requires lnd',
-    error: [400, 'ExpectedLndToProcessPaywallRequest'],
-  },
-  {
-    args: makeArgs({network: undefined}),
-    description: 'Processing a paywall requires a network name',
-    error: [400, 'ExpectedNetworkNameToProcessPaywallRequest'],
-  },
-  {
-    args: makeArgs({}),
-    description: 'A paywall is processed',
-  },
-];
+  const tests = [
+    {
+      args: makeArgs({env: undefined}),
+      description: 'Processing a paywall requires env vars',
+      error: [400, 'ExpectedEnvironmentVariablesToProcessPaywall'],
+    },
+    {
+      args: makeArgs({fetch: undefined}),
+      description: 'Processing a paywall requires a fetch function',
+      error: [400, 'ExpectedFetchFunctionToProcessPaywallPayment'],
+    },
+    {
+      args: makeArgs({id: undefined}),
+      description: 'Processing a paywall requires an invoice id',
+      error: [400, 'ExpectedInvoiceIdToProcessPaywallRequest'],
+    },
+    {
+      args: makeArgs({lnd: undefined}),
+      description: 'Processing a paywall requires lnd',
+      error: [400, 'ExpectedLndToProcessPaywallRequest'],
+    },
+    {
+      args: makeArgs({network: undefined}),
+      description: 'Processing a paywall requires a network name',
+      error: [400, 'ExpectedNetworkNameToProcessPaywallRequest'],
+    },
+    {
+      args: makeArgs({}),
+      description: 'A paywall is processed',
+    },
+  ];
 
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async ({end, equal, rejects, strictSame}) => {
-    if (!!error) {
-      await rejects(method(args), error, 'Got expected error');
-    } else {
-      const res = await method(args);
+  tests.forEach(({args, description, error, expected}) => {
+    return test(description, async ({end, equal, rejects, strictSame}) => {
+      if (!!error) {
+        await rejects(method(args), error, 'Got expected error');
+      } else {
+        const res = await method(args);
 
-      strictSame(res, expected, 'Got expected result');
-    }
+        strictSame(res, expected, 'Got expected result');
+      }
 
-    return end();
+      return end();
+    });
   });
-});
+})();

package/test/server/test_process_request.js

@@ -4,6 +4,7 @@ const {makeLnd} = require('mock-lnd');
 const {makePayViaRoutesResponse} = require('mock-lnd');
 const {makePaymentRequest} = require('mock-lnd');
 const {test} = require('@alexbosworth/tap');
+const tinysecp = require('tiny-secp256k1');
 
 const messagesForRequest = require('./../../client/messages_for_request');
 const method = require('./../../server/process_request');
@@ -11,142 +12,149 @@ const method = require('./../../server/process_request');
 const encode = records => encodeTlvStream({records: [records]}).encoded;
 const id1 = Buffer.alloc(32).toString('hex');
 const id2 = Buffer.alloc(32, 1).toString('hex');
-const {request} = makePaymentRequest({});
 
-const {messages} = messagesForRequest({reply: request, service: '2'});
+(async () => {
+  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
 
-const makeArgs = overrides => {
-  let requests = 0;
+  const {request} = makePaymentRequest({ecp});
 
-  const lnd = makeLnd({
-    payViaRoutes: ({}, cbk) => {
-      requests++;
+  const {messages} = messagesForRequest({reply: request, service: '2'});
 
-      if (requests === 2) {
-        return cbk(null, makePayViaRoutesResponse({}));
-      }
+  const makeArgs = overrides => {
+    let requests = 0;
 
-      return cbk(null, makePayViaRoutesResponse({is_unknown_failure: true}));
-    },
-  });
+    const lnd = makeLnd({
+      payViaRoutes: ({}, cbk) => {
+        requests++;
 
-  const args = {
-    env: {},
-    fetch: () => {},
-    id: id1,
-    lnd: makeLnd({
-      getInvoice: ({}, cbk) => {
-        return cbk(null, makeInvoice({
-          is_confirmed: true,
-          is_push: true,
-          payments: [{messages, is_confirmed: true}],
-        }));
+        if (requests === 2) {
+          return cbk(null, makePayViaRoutesResponse({}));
+        }
+
+        return cbk(null, makePayViaRoutesResponse({is_unknown_failure: true}));
       },
-    }),
-    network: 'btc',
-    payer: lnd,
-  };
+    });
 
-  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
-
-  return args;
-};
-
-const tests = [
-  {
-    args: makeArgs({env: undefined}),
-    description: 'Processing a service request requires env vars',
-    error: [400, 'ExpectedEnvironmentVarsToProcessPaidRequest'],
-  },
-  {
-    args: makeArgs({fetch: undefined}),
-    description: 'Processing a service request requires a fetch function',
-    error: [400, 'ExpectedFetchFunctionToProcessPaidRequest'],
-  },
-  {
-    args: makeArgs({id: undefined}),
-    description: 'Processing a service request requires an invoice id',
-    error: [400, 'ExpectedInvoiceIdToProcessPaidRequest'],
-  },
-  {
-    args: makeArgs({lnd: undefined}),
-    description: 'Processing a service request requires lnd to lookup invoice',
-    error: [400, 'ExpectedAuthenticatedLndToProcessPaidRequest'],
-  },
-  {
-    args: makeArgs({network: undefined}),
-    description: 'Processing a service request requires network name',
-    error: [400, 'ExpectedNetworkNameToProcessPaidRequest'],
-  },
-  {
-    args: makeArgs({payer: undefined}),
-    description: 'Processing a service request requires a payer to respond',
-    error: [400, 'ExpectedPayerLndToProcessPaidRequest'],
-  },
-  {
-    args: makeArgs({network: 'network'}),
-    description: 'A request is processed',
-    error: [500, 'UnexpectedErrMappingInvoiceToPaidRequest'],
-  },
-  {
-    args: makeArgs({}),
-    description: 'A request is processed',
-    expected: {},
-  },
-  {
-    args: makeArgs({
+    const args = {
+      env: {},
+      fetch: () => {},
+      id: id1,
       lnd: makeLnd({
         getInvoice: ({}, cbk) => {
           return cbk(null, makeInvoice({
             is_confirmed: true,
             is_push: true,
-            payments: [{
-              messages: messagesForRequest({
-                reply: request,
-                service: Number.MAX_SAFE_INTEGER.toString(),
-              }).messages,
-              is_confirmed: true,
-            }],
+            payments: [{messages, is_confirmed: true}],
           }));
         },
       }),
-    }),
-    description: 'A request is processed',
-    expected: {error: [404, 'UnknownServiceType']},
-  },
-  {
-    args: makeArgs({
-      lnd: makeLnd({
-        getInvoice: ({}, cbk) => {
-          return cbk(null, makeInvoice({
-            is_confirmed: true,
-            is_push: true,
-            payments: [{
-              messages: messagesForRequest({
-                reply: request,
-                service: '3',
-              }).messages,
+      network: 'btc',
+      payer: lnd,
+    };
+
+    Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+    return args;
+  };
+
+  const tests = [
+    {
+      args: makeArgs({env: undefined}),
+      description: 'Processing a service request requires env vars',
+      error: [400, 'ExpectedEnvironmentVarsToProcessPaidRequest'],
+    },
+    {
+      args: makeArgs({fetch: undefined}),
+      description: 'Processing a service request requires a fetch function',
+      error: [400, 'ExpectedFetchFunctionToProcessPaidRequest'],
+    },
+    {
+      args: makeArgs({id: undefined}),
+      description: 'Processing a service request requires an invoice id',
+      error: [400, 'ExpectedInvoiceIdToProcessPaidRequest'],
+    },
+    {
+      args: makeArgs({lnd: undefined}),
+      description: 'Processing a service request requires lnd to lookup invoice',
+      error: [400, 'ExpectedAuthenticatedLndToProcessPaidRequest'],
+    },
+    {
+      args: makeArgs({network: undefined}),
+      description: 'Processing a service request requires network name',
+      error: [400, 'ExpectedNetworkNameToProcessPaidRequest'],
+    },
+    {
+      args: makeArgs({payer: undefined}),
+      description: 'Processing a service request requires a payer to respond',
+      error: [400, 'ExpectedPayerLndToProcessPaidRequest'],
+    },
+    {
+      args: makeArgs({network: 'network'}),
+      description: 'A request is processed',
+      error: [500, 'UnexpectedErrMappingInvoiceToPaidRequest'],
+    },
+    {
+      args: makeArgs({}),
+      description: 'A request is processed',
+      expected: {},
+    },
+    {
+      args: makeArgs({
+        lnd: makeLnd({
+          getInvoice: ({}, cbk) => {
+            return cbk(null, makeInvoice({
               is_confirmed: true,
-            }],
-          }));
-        },
+              is_push: true,
+              payments: [{
+                messages: messagesForRequest({
+                  reply: request,
+                  service: Number.MAX_SAFE_INTEGER.toString(),
+                }).messages,
+                is_confirmed: true,
+              }],
+            }));
+          },
+        }),
       }),
-    }),
-    description: 'A request is processed',
-    expected: {error: [404, 'ServiceCurrentlyUnsupported']},
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async ({end, equal, rejects, strictSame}) => {
-    if (!!error) {
-      await rejects(method(args), error, 'Got expected error');
-    } else {
-      const res = await method(args);
-
-      strictSame(res, expected, 'Got expected result');
-    }
-
-    return end();
+      description: 'A request is processed',
+      expected: {error: [404, 'UnknownServiceType']},
+    },
+    {
+      args: makeArgs({
+        lnd: makeLnd({
+          getInvoice: ({}, cbk) => {
+            return cbk(null, makeInvoice({
+              is_confirmed: true,
+              is_push: true,
+              payments: [{
+                messages: messagesForRequest({
+                  reply: request,
+                  service: '3',
+                }).messages,
+                is_confirmed: true,
+              }],
+            }));
+          },
+        }),
+      }),
+      description: 'A request is processed',
+      expected: {error: [404, 'ServiceCurrentlyUnsupported']},
+    },
+  ];
+
+  tests.forEach(({args, description, error, expected}) => {
+    return test(description, async ({end, equal, rejects, strictSame}) => {
+      args.ecp = (await import('ecpair')).ECPairFactory(tinysecp);
+
+      if (!!error) {
+        await rejects(method(args), error, 'Got expected error');
+      } else {
+        const res = await method(args);
+
+        strictSame(res, expected, 'Got expected result');
+      }
+
+      return end();
+    });
   });
-});
+})();