paid-services 10.2.0 → 10.3.1

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Versions
 
+## Version 10.3.1
+
+- `getOfferInvoice`: Add support for offer paths that start at the payer
+- `serviceSupportOffer`: Add support for reply paths that start at the node
+
 ## Version 10.2.0
 
 - `serviceSupportOffer`: Add `start` event with the support offer

package/network/constants.json

@@ -12,5 +12,7 @@
   "codeInvalidArgument": 3,
   "codePermissionDenied": 7,
   "codeUnauthenticated": 16,
-  "codeUnimplemented": 12
+  "codeUnimplemented": 12,
+  "knownHopRecordTypes": ["1", "2", "4", "6", "8", "10", "12", "14"],
+  "typePathId": "6"
 }

package/network/get_path_after_self.js

@@ -0,0 +1,222 @@
+const asyncAuto = require('async/auto');
+const {decryptBlindedPath} = require('bolt04');
+const {diffieHellmanComputeSecret} = require('ln-service');
+const {getChannel} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const {knownHopRecordTypes} = require('./constants');
+const {typePathId} = require('./constants');
+
+const hasPathId = records => records.some(n => n.type === typePathId);
+const hopsAfterFirst = hops => hops.slice(1);
+const idsOf = channel => [channel.id].concat(channel.other_ids);
+const {isArray} = Array;
+const isEven = type => !(BigInt(type) % BigInt(2));
+const isKnown = record => knownHopRecordTypes.includes(record.type);
+const isPublicKey = n => typeof n === 'string' && /^[0-9A-F]{66}$/i.test(n);
+const isUnknownEven = record => !isKnown(record) && isEven(record.type);
+
+/** Get the blinded path after self, for a blinded path that starts at self
+
+  Self reads its own hop as an introduction node would. The path goes on from
+  the next node, which the hop names, or which is the peer at the other end
+  of the channel that the hop names.
+
+  As BOLT 4 asks of a node that forwards, the hop of self is not used when it
+  has an unknown even record, when it has a path id, or when it allows
+  features, since no onion message features are defined.
+
+  {
+    hops: [{
+      encrypted_data: <Encrypted Recipient Data Hex String>
+      relay_key: <Blinded Relaying Node Public Key Hex String>
+    }]
+    identity: <Node Identity Public Key Hex String>
+    key: <First Hop Path Key Public Key Hex String>
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    hops: [{
+      encrypted_data: <Encrypted Recipient Data Hex String>
+      relay_key: <Blinded Relaying Node Public Key Hex String>
+    }]
+    introduction_node: <Next Node Public Key Hex String>
+    key: <Next Hop Path Key Public Key Hex String>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isArray(args.hops) || !args.hops.length) {
+          return cbk([400, 'ExpectedBlindedPathHopsToGetPathAfterSelf']);
+        }
+
+        if (!isPublicKey(args.identity)) {
+          return cbk([400, 'ExpectedIdentityPublicKeyToGetPathAfterSelf']);
+        }
+
+        if (!args.key) {
+          return cbk([400, 'ExpectedPathKeyToGetPathAfterSelf']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndToGetPathAfterSelf']);
+        }
+
+        return cbk();
+      },
+
+      // Compute the shared secret of the path key and the node identity key
+      getSecret: ['validate', ({}, cbk) => {
+        return diffieHellmanComputeSecret({
+          lnd: args.lnd,
+          partner_public_key: args.key,
+        },
+        cbk);
+      }],
+
+      // Decrypt the data of the hop of self to read where the path goes next
+      decrypt: ['getSecret', ({getSecret}, cbk) => {
+        const [own] = args.hops;
+
+        try {
+          return cbk(null, decryptBlindedPath({
+            encrypted: own.encrypted_data,
+            key: args.key,
+            secret: getSecret.secret,
+          }));
+        } catch (err) {
+          return cbk([503, 'FailedToDecryptOwnBlindedPathHop', {err}]);
+        }
+      }],
+
+      // Check the hop of self can be followed, as a forwarding node would
+      check: ['decrypt', ({decrypt}, cbk) => {
+        // An unknown even record cannot be ignored, so the hop cannot be used
+        if (decrypt.records.some(isUnknownEven)) {
+          return cbk([
+            400,
+            'UnexpectedUnknownRequiredRecordInOwnBlindedPathHop',
+          ]);
+        }
+
+        // No features are defined for onion messages, so a feature bit in
+        // the allowed features is an unknown feature, and the hop is not used
+        if (!!decrypt.features.length) {
+          return cbk([400, 'UnsupportedFeatureInOwnBlindedPathHop']);
+        }
+
+        // A hop with no next node or channel is the final hop of the path
+        if (!decrypt.next_node_id && !decrypt.next_channel_id) {
+          return cbk([400, 'UnexpectedBlindedPathToSelf']);
+        }
+
+        // A hop that goes on to a next node is not one with a path id record,
+        // which is present even when the path id is empty
+        if (hasPathId(decrypt.records)) {
+          return cbk([400, 'UnexpectedPathIdInOwnBlindedPathHop']);
+        }
+
+        return cbk();
+      }],
+
+      // The hops after self, which the path goes on over
+      hops: ['check', ({}, cbk) => {
+        const hops = hopsAfterFirst(args.hops);
+
+        // The next node has a hop of its own to send to
+        if (!hops.length) {
+          return cbk([400, 'ExpectedHopsAfterSelfInBlindedPath']);
+        }
+
+        return cbk(null, hops);
+      }],
+
+      // Get the channels of self when the next node is named by a channel
+      getChannels: ['decrypt', 'hops', ({decrypt}, cbk) => {
+        // Exit early when the hop names the next node
+        if (!!decrypt.next_node_id) {
+          return cbk();
+        }
+
+        return getChannels({lnd: args.lnd}, cbk);
+      }],
+
+      // Find the next channel among the channels of self
+      channel: ['decrypt', 'getChannels', ({decrypt, getChannels}, cbk) => {
+        // Exit early when the hop names the next node
+        if (!getChannels) {
+          return cbk();
+        }
+
+        const id = decrypt.next_channel_id;
+
+        // A private channel can be named by one of its aliases
+        return cbk(null, getChannels.channels.find(n => idsOf(n).includes(id)));
+      }],
+
+      // Look for the next channel in the graph when self does not list it
+      getChannel: ['channel', 'decrypt', ({channel, decrypt}, cbk) => {
+        // Exit early when the next node is already known
+        if (!!decrypt.next_node_id || !!channel) {
+          return cbk();
+        }
+
+        return getChannel({
+          id: decrypt.next_channel_id,
+          lnd: args.lnd,
+        },
+        (err, res) => {
+          // Exit early when the channel is not in the graph
+          if (!!err) {
+            return cbk([503, 'FailedToFindNextPeerInBlindedPath']);
+          }
+
+          return cbk(null, res);
+        });
+      }],
+
+      // The next node is the one that the hop names, or is across the channel
+      next: [
+        'channel',
+        'decrypt',
+        'getChannel',
+        ({channel, decrypt, getChannel}, cbk) =>
+      {
+        // Exit early when the hop names the next node
+        if (!!decrypt.next_node_id) {
+          return cbk(null, decrypt.next_node_id);
+        }
+
+        // Exit early when the channel is a channel of self
+        if (!!channel) {
+          return cbk(null, channel.partner_public_key);
+        }
+
+        const keys = getChannel.policies.map(n => n.public_key);
+
+        // The channel in the graph has to be one that self forwards over
+        if (!keys.includes(args.identity)) {
+          return cbk([503, 'FailedToFindNextPeerInBlindedPath']);
+        }
+
+        return cbk(null, keys.find(n => n !== args.identity));
+      }],
+
+      // The path goes on from the next node, with the next hop path key
+      path: ['decrypt', 'hops', 'next', ({decrypt, hops, next}, cbk) => {
+        return cbk(null, {
+          hops,
+          introduction_node: next,
+          key: decrypt.next_path_key,
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'path'}, cbk));
+  });
+};

package/network/get_path_outbound.js

@@ -1,28 +1,48 @@
 const asyncAuto = require('async/auto');
+const asyncWhilst = require('async/whilst');
 const {getChannel} = require('ln-service');
+const {getIdentity} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
 const getMessageHops = require('./get_message_hops');
+const getPathAfterSelf = require('./get_path_after_self');
 const pathIntroduction = require('./path_introduction');
 
 const edgeChannel = edge => edge.split('x').slice(0, -1).join('x');
+const {isArray} = Array;
+const isPublicKey = n => typeof n === 'string' && /^[0-9A-F]{66}$/i.test(n);
 
-/** Get the outbound hops to reach the introduction node of a blinded path
+/** Get the outbound hops to reach the introduction node of a blinded path,
+  with the hops and the path key to send over
 
   When the introduction node is not a connected peer, the message is relayed
   along a payment route through nodes that relay onion messages
 
+  A path that starts at self is sent from the next node of the path: self
+  reads its own hops, as an introduction node would, and sends over the hops
+  after them. A path that does not start at self is sent over as it is.
+
   {
     [is_expecting_reply]: <Reply Comes Back Along the Same Nodes Bool>
     lnd: <Authenticated LND API Object>
     path: {
+      hops: [{
+        encrypted_data: <Encrypted Recipient Data Hex String>
+        relay_key: <Blinded Relaying Node Public Key Hex String>
+      }]
       [introduction_edge]: <Introduction Node Edge Format Channel Id String>
       [introduction_node]: <Introduction Node Public Key Hex String>
+      key: <First Hop Path Key Public Key Hex String>
     }
   }
 
   @returns via cbk or Promise
   {
+    hops: [{
+      encrypted_data: <Encrypted Recipient Data Hex String>
+      relay_key: <Blinded Relaying Node Public Key Hex String>
+    }]
+    key: <First Hop Path Key Public Key Hex String>
     outbound: [<Relaying Node Public Key Hex String>]
   }
 */
@@ -39,6 +59,21 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedBlindedPathToGetPathOutbound']);
         }
 
+        if (!isArray(args.path.hops) || !args.path.hops.length) {
+          return cbk([400, 'ExpectedBlindedPathHopsToGetPathOutbound']);
+        }
+
+        // A node introduction is compared to self as a public key
+        if (!!args.path.introduction_node) {
+          if (!isPublicKey(args.path.introduction_node)) {
+            return cbk([400, 'ExpectedIntroductionNodeKeyToGetPathOutbound']);
+          }
+        }
+
+        if (!args.path.key) {
+          return cbk([400, 'ExpectedBlindedPathKeyToGetPathOutbound']);
+        }
+
         return cbk();
       },
 
@@ -54,6 +89,11 @@ module.exports = (args, cbk) => {
         return getChannel({id, lnd: args.lnd}, cbk);
       }],
 
+      // Get the identity key of self, which the path can start at
+      getIdentity: ['validate', ({}, cbk) => {
+        return getIdentity({lnd: args.lnd}, cbk);
+      }],
+
       // Determine the introduction node of the path
       introduction: ['getChannel', ({getChannel}, cbk) => {
         try {
@@ -62,25 +102,69 @@ module.exports = (args, cbk) => {
             path: args.path,
           });
 
-          return cbk(null, introduction);
+          // Node keys are compared in lowercase, as LND gives them
+          return cbk(null, introduction.toLowerCase());
         } catch (err) {
           return cbk([400, err.message]);
         }
       }],
 
+      // Step past the hops of self while the path starts at self
+      stepped: [
+        'getIdentity',
+        'introduction',
+        ({getIdentity, introduction}, cbk) =>
+      {
+        const identity = getIdentity.public_key;
+
+        let path = {
+          hops: args.path.hops,
+          introduction_node: introduction,
+          key: args.path.key,
+        };
+
+        // Self reads its own hop as an introduction node would, and the path
+        // goes on from the next node, which can be self again
+        return asyncWhilst(
+          cbk => cbk(null, path.introduction_node === identity),
+          cbk => {
+            return getPathAfterSelf({
+              identity,
+              hops: path.hops,
+              key: path.key,
+              lnd: args.lnd,
+            },
+            (err, res) => {
+              if (!!err) {
+                return cbk(err);
+              }
+
+              path = res;
+
+              return cbk();
+            });
+          },
+          err => !!err ? cbk(err) : cbk(null, path)
+        );
+      }],
+
       // Get the hops to relay the message to the introduction node
-      getHops: ['introduction', ({introduction}, cbk) => {
+      getHops: ['stepped', ({stepped}, cbk) => {
         return getMessageHops({
-          destination: introduction,
+          destination: stepped.introduction_node,
           is_expecting_reply: args.is_expecting_reply,
           lnd: args.lnd,
         },
         cbk);
       }],
 
-      // The outbound hops end at the introduction node
-      outbound: ['getHops', ({getHops}, cbk) => {
-        return cbk(null, {outbound: getHops.hops});
+      // The outbound hops end at the introduction node of the path to send
+      outbound: ['getHops', 'stepped', ({getHops, stepped}, cbk) => {
+        return cbk(null, {
+          hops: stepped.hops,
+          key: stepped.key,
+          outbound: getHops.hops,
+        });
       }],
     },
     returnResult({reject, resolve, of: 'outbound'}, cbk));

package/network/request_network_reply.js

@@ -27,6 +27,9 @@ const isTimeout = n => isSafeInteger(n) && n > 0;
   than `max_reply_hops` keeps the hops nearest self, and the recipient routes
   to its start.
 
+  A path that starts at self is sent from the next node of the path, and the
+  reply path goes back from there.
+
   {
     lnd: <Authenticated LND API Object>
     [max_reply_hops]: <Maximum Reply Path Hops Count Number>
@@ -135,9 +138,9 @@ module.exports = (args, cbk) => {
       {
         const {outbound} = getOutbound;
 
-        // The outbound hops end at the introduction node of the path, which
-        // is the recipient itself when the path has a single hop
-        const isRecipient = args.path.hops.length === 1;
+        // The outbound hops end at the introduction node of the hops that are
+        // sent, which is the recipient itself when there is a single hop
+        const isRecipient = getOutbound.hops.length === 1;
 
         const relays = !isRecipient ? outbound : outbound.slice(0, -1);
 
@@ -258,8 +261,8 @@ module.exports = (args, cbk) => {
 
         // Send the message with a reply path back the way it goes
         const sending = sendMessage({
-          inbound: args.path.hops,
-          key: args.path.key,
+          inbound: getOutbound.hops,
+          key: getOutbound.key,
           lnd: args.lnd,
           message: args.message,
           outbound: getOutbound.outbound,

package/network/return_network_response.js

@@ -14,8 +14,8 @@ const largeOnionBytes = 32834;
 
   With `is_regular`, the response is only sent when it fits in an onion
   message of the regular size. Otherwise it has to fit in a large one. A
-  response that does not fit is a 413 error. Give the `outbound` hops to the
-  reply path when they are known.
+  response that does not fit is a 413 error. Give the `route` to the reply
+  path when it is known, as found by `getPathOutbound`.
 
   {
     [is_regular]: <Only Send In An Onion Message Of The Regular Size Bool>
@@ -33,7 +33,14 @@ const largeOnionBytes = 32834;
       [introduction_node]: <Introduction Node Public Key Hex String>
       key: <Path Key Hex String>
     }
-    [outbound]: [<Relaying Node Public Key Hex String>]
+    [route]: {
+      hops: [{
+        encrypted_data: <Encrypted Data Hex String>
+        relay_key: <Blinded Relay Key Hex String>
+      }]
+      key: <Path Key Hex String>
+      outbound: [<Relaying Node Public Key Hex String>]
+    }
   }
 
   @returns via cbk or Promise
@@ -58,23 +65,32 @@ module.exports = (args, cbk) => {
         return cbk();
       },
 
-      // Determine the outbound hops to reach the reply path
-      getOutbound: ['validate', ({}, cbk) => {
-        // Exit early when the outbound hops are already known
-        if (!!args.outbound) {
-          return cbk(null, {outbound: args.outbound});
+      // Determine the route to the reply path: the hops and key to send over
+      getRoute: ['validate', ({}, cbk) => {
+        // Exit early when the route is already known
+        if (!!args.route) {
+          return cbk(null, args.route);
         }
 
-        return getPathOutbound({lnd: args.lnd, path: args.reply}, cbk);
+        return getPathOutbound({
+          lnd: args.lnd,
+          path: {
+            hops: args.reply.inbound,
+            introduction_edge: args.reply.introduction_edge,
+            introduction_node: args.reply.introduction_node,
+            key: args.reply.key,
+          },
+        },
+        cbk);
       }],
 
       // Check that the response fits in an onion message that can be sent
-      checkSize: ['getOutbound', ({getOutbound}, cbk) => {
+      checkSize: ['getRoute', ({getRoute}, cbk) => {
         try {
           const {onion} = onionForPath({
-            inbound: args.reply.inbound,
-            key: args.reply.key,
-            outbound: getOutbound.outbound,
+            inbound: getRoute.hops,
+            key: getRoute.key,
+            outbound: getRoute.outbound,
             records: [args.message],
           });
 
@@ -99,13 +115,13 @@ module.exports = (args, cbk) => {
       }],
 
       // Send the response message through the reply path
-      send: ['checkSize', 'getOutbound', ({getOutbound}, cbk) => {
+      send: ['checkSize', 'getRoute', ({getRoute}, cbk) => {
         return sendMessage({
-          inbound: args.reply.inbound,
-          key: args.reply.key,
+          inbound: getRoute.hops,
+          key: getRoute.key,
           lnd: args.lnd,
           message: args.message,
-          outbound: getOutbound.outbound,
+          outbound: getRoute.outbound,
         },
         cbk);
       }],

package/network/service_network_messages.js

@@ -176,23 +176,32 @@ module.exports = ({delay, ids, lnd}) => {
 
     const {encrypted, key, reply} = received;
 
-    let outbound;
+    let route;
 
-    // The route to the reply path is found once for a message
-    const getOutbound = () => {
+    // The route to the reply path, the hops and key to send over and the
+    // outbound hops to reach them, is found once for a message
+    const getRoute = () => {
       // Exit early when the route was already found or is being found
-      if (!!outbound) {
-        return outbound;
+      if (!!route) {
+        return route;
       }
 
-      const lookup = getPathOutbound({lnd, path: reply});
+      const lookup = getPathOutbound({
+        lnd,
+        path: {
+          hops: reply.inbound,
+          introduction_edge: reply.introduction_edge,
+          introduction_node: reply.introduction_node,
+          key: reply.key,
+        },
+      });
 
-      outbound = lookup;
+      route = lookup;
 
       // A failed lookup is not kept, so that a later reply can try again
       lookup.catch(() => {
-        if (outbound === lookup) {
-          outbound = undefined;
+        if (route === lookup) {
+          route = undefined;
         }
       });
 
@@ -224,7 +233,7 @@ module.exports = ({delay, ids, lnd}) => {
 
       // The caller is told outside of the promise chain, so that a throw in
       // the caller is not taken as a failure to send
-      return getOutbound()
+      return getRoute()
         .then(res => {
           // Exit early when the service stopped while the route was found
           if (isStopped) {
@@ -236,7 +245,7 @@ module.exports = ({delay, ids, lnd}) => {
             lnd,
             reply,
             message: response,
-            outbound: res.outbound,
+            route: res,
           });
         })
         .then(() => setImmediate(() => done()), err => {
@@ -253,11 +262,11 @@ module.exports = ({delay, ids, lnd}) => {
 
       // The caller is told outside of the promise chain, so that it is only
       // called once, even when it throws
-      return getOutbound()
+      return getRoute()
         .then(res => regularReplyBytes({
           type,
-          inbound: reply.inbound,
-          key: reply.key,
+          inbound: res.hops,
+          key: res.key,
           outbound: res.outbound,
         }))
         .then(res => setImmediate(() => cbk(null, res)), err => {

package/offers/get_offer_invoice.js

@@ -29,11 +29,11 @@ const typeSchnorr = 'schnorr';
   The request is sent over each path of the offer in turn, waiting `timeout`
   for each, until a path gives back an invoice, or the recipient replies
   with an invoice error, which is returned. An offer without paths has the
-  request sent to its issuer id. The reply path of a request goes back along
-  its route, so that the recipient can reach it. The route to the start of a
-  path is found over the public graph and the channels of the payer, so a
-  payer that is only connected through a peer that is itself private is not
-  supported.
+  request sent to its issuer id. A path that starts at the payer is sent
+  from its next node. The reply path of a request goes back along its route,
+  so that the recipient can reach it. The route to the start of a path is
+  found over the public graph and the channels of the payer, so a payer that
+  is only connected through a peer that is itself private is not supported.
 
   The request is signed by the `payer_id`, a new key that LND derives in key
   family 808 at `payer_key_index`, only once the request is known to be one

package/package.json

@@ -19,18 +19,17 @@
     "bolt01": "4.0.1",
     "bolt04": "1.3.0",
     "bolt07": "2.0.0",
-    "ecpair": "2.1.0",
-    "goldengate": "16.0.8",
+    "goldengate": "16.0.9",
     "invoices": "6.3.0",
-    "ln-service": "60.1.4",
-    "ln-sync": "8.0.7",
+    "ln-service": "60.1.6",
+    "ln-sync": "8.0.8",
     "psbt": "7.0.0",
     "p2tr": "3.0.0",
     "tiny-secp256k1": "2.2.4"
   },
   "description": "Lightning Paid Services library",
   "devDependencies": {
-    "ln-docker-daemons": "8.1.1",
+    "ln-docker-daemons": "8.1.2",
     "mock-lnd": "4.0.0"
   },
   "engines": {
@@ -73,5 +72,5 @@
     "integration-tests": "node test/integration",
     "test": "node --experimental-test-coverage --test test/actions/*.js test/balanced/*.js test/client/*.js test/config/*.js test/network/*.js test/offers/*.js test/p2p/*.js test/records/*.js test/respond/*.js test/server/*.js test/service_records/*.js test/swaps/*.js test/services/*.js test/support/*.js test/trades/*.js"
   },
-  "version": "10.2.0"
+  "version": "10.3.1"
 }

package/swaps/complete_off_to_on_swap.js

@@ -32,6 +32,7 @@ const {parsePaymentRequest} = require('ln-service');
 const {pay} = require('ln-service');
 const {payViaPaymentDetails} = require('ln-service');
 const {pointAdd} = require('tiny-secp256k1');
+const {pointFromScalar} = require('tiny-secp256k1');
 const {privateAdd} = require('tiny-secp256k1');
 const {releaseSwapOutSecret} = require('goldengate');
 const {returnResult} = require('asyncjs-util');
@@ -43,7 +44,6 @@ const {subscribeToSpend} = require('goldengate');
 const {swapScriptBranches} = require('goldengate');
 const {taprootClaimTransaction} = require('goldengate');
 const {taprootCoopTransaction} = require('goldengate');
-const tinysecp = require('tiny-secp256k1');
 const {Transaction} = require('bitcoinjs-lib');
 const {v1OutputScript} = require('p2tr');
 
@@ -72,6 +72,7 @@ const fuzzTimelock = 1;
 const getLoopCoopSignedTransaction = asyncTimeout(getCoopSignedTx, 1000 * 30);
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const {isArray} = Array;
+const isCompressed = true;
 const maxClaimMultiple = (r, t) => Math.min(1000, ((1000 + t) / 150) / r);
 const maxCoopMultiple = (r, t) => Math.min(1000, ((1000 + t) / 100) / r);
 const messageRejected = 'PaymentRejectedByDestination';
@@ -82,6 +83,7 @@ const pollInterval = {btcregtest: 100};
 const ppmRate = (fee, total) => fee * 1e6 / total;
 const preimageByteLength = 32;
 const pubKeyAsInternalKey = key => Buffer.from(key).slice(1).toString('hex');
+const publicKeyFor = key => Buffer.from(pointFromScalar(key, isCompressed));
 const pushSecret = asyncTimeout(releaseSwapOutSecret, 1000 * 30);
 const sha256 = preimage => createHash('sha256').update(preimage).digest('hex');
 const sighash = Transaction.SIGHASH_DEFAULT;
@@ -116,9 +118,6 @@ const witnessVersionTaproot = 1;
 module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
-      // Import the ECPair library
-      ecp: async () => (await import('ecpair')).ECPairFactory(tinysecp),
-
       // Check arguments
       validate: cbk => {
         if (!args.emitter) {
@@ -340,12 +339,12 @@ module.exports = (args, cbk) => {
       }],
 
       // Get the claim public key
-      getClaimKey: ['ecp', 'requestDetails', ({ecp, requestDetails}, cbk) => {
+      getClaimKey: ['requestDetails', ({requestDetails}, cbk) => {
         // Exit early when a private key is defined
         if (!!requestDetails.solo_private_key) {
           const privateKey = hexAsBuffer(requestDetails.solo_private_key);
 
-          const {publicKey} = ecp.fromPrivateKey(privateKey);
+          const publicKey = publicKeyFor(privateKey);
 
           return cbk(null, {public_key: bufferAsHex(publicKey)});
         }
@@ -453,14 +452,12 @@ module.exports = (args, cbk) => {
 
       // Derive the swap script branches
       branches: [
-        'ecp',
         'getClaimKey',
         'requestDetails',
         'responseDetails',
-        ({ecp, getClaimKey, requestDetails, responseDetails}, cbk) =>
+        ({getClaimKey, requestDetails, responseDetails}, cbk) =>
       {
         const swapScript = swapScriptBranches({
-          ecp,
           claim_public_key: getClaimKey.public_key,
           hash: sha256(hexAsBuffer(requestDetails.secret)),
           refund_public_key: responseDetails.refund_public_key,
@@ -477,12 +474,11 @@ module.exports = (args, cbk) => {
 
       // Derive the output script
       joined: [
-        'ecp',
         'branches',
         'getClaimKey',
         'requestDetails',
         'responseDetails',
-        ({ecp, branches, getClaimKey, requestDetails, responseDetails}, cbk) =>
+        ({branches, getClaimKey, requestDetails, responseDetails}, cbk) =>
       {
         // Exit early when using MuSig2 with Lightning Loop
         if (!!args.is_loop_service) {
@@ -502,7 +498,7 @@ module.exports = (args, cbk) => {
         const privateKey = requestDetails.coop_private_key;
 
         const jointPublicKey = pointAdd(
-          ecp.fromPrivateKey(hexAsBuffer(privateKey)).publicKey,
+          publicKeyFor(hexAsBuffer(privateKey)),
           hexAsBuffer(responseDetails.coop_public_key)
         );
 
@@ -551,7 +547,6 @@ module.exports = (args, cbk) => {
       payToDeposit: [
         'checkSwapId',
         'deadline',
-        'ecp',
         'getDepositPayment',
         'getNetwork',
         'requestDetails',
@@ -560,7 +555,6 @@ module.exports = (args, cbk) => {
         'swap',
         ({
           deadline,
-          ecp,
           getNetwork,
           getDepositPayment,
           requestDetails,
@@ -651,7 +645,7 @@ module.exports = (args, cbk) => {
               max_fee: args.max_fee_deposit,
               messages: [{
                 type: typePayMetadata,
-                value: bufferAsHex(ecp.fromPrivateKey(privateKey).publicKey),
+                value: bufferAsHex(publicKeyFor(privateKey)),
               }],
               mtokens: responseDetails.deposit_mtokens,
               payment: responseDetails.deposit_payment,
@@ -762,7 +756,6 @@ module.exports = (args, cbk) => {
         'checkOutput',
         'createAddress',
         'deadline',
-        'ecp',
         'findOutput',
         'getFeeRate',
         'getNetwork',
@@ -771,7 +764,6 @@ module.exports = (args, cbk) => {
         ({
           createAddress,
           deadline,
-          ecp,
           findOutput,
           getFeeRate,
           getNetwork,
@@ -801,7 +793,6 @@ module.exports = (args, cbk) => {
 
         const claims = feeRates.map(({rate, height}) => {
           const {transaction} = taprootClaimTransaction({
-            ecp,
             block_height: height - fuzzTimelock,
             claim_script: swap.claim_script,
             external_key: swap.external_key,
@@ -895,14 +886,12 @@ module.exports = (args, cbk) => {
 
       // Push the preimage to allow for a cooperative swap
       pushPreimage: [
-        'ecp',
         'findOutput',
         'loopService',
         'requestDetails',
         'responseDetails',
         'signClaims',
         asyncReflect(({
-          ecp,
           loopService,
           requestDetails,
           responseDetails,
@@ -941,7 +930,7 @@ module.exports = (args, cbk) => {
         const privateKey = requestDetails.coop_private_key;
         const to = parsePaymentRequest({request: responseDetails.request});
 
-        const pubKey = ecp.fromPrivateKey(hexAsBuffer(privateKey)).publicKey;
+        const pubKey = publicKeyFor(hexAsBuffer(privateKey));
 
         const id = sha256(pubKey);
 
@@ -1024,7 +1013,6 @@ module.exports = (args, cbk) => {
         'branches',
         'createAddress',
         'deadline',
-        'ecp',
         'findCoopKey',
         'findOutput',
         'getClaimKey',
@@ -1039,7 +1027,6 @@ module.exports = (args, cbk) => {
           branches,
           createAddress,
           deadline,
-          ecp,
           findCoopKey,
           findOutput,
           getClaimKey,
@@ -1139,24 +1126,23 @@ module.exports = (args, cbk) => {
 
         const privateKeys = privateKeysHex.map(hexAsBuffer);
 
-        const coopKey = ecp.fromPrivateKey(from(privateAdd(...privateKeys)));
+        const coopKey = publicKeyFor(from(privateAdd(...privateKeys)));
 
         const coopPrivateKey = hexAsBuffer(requestDetails.coop_private_key);
 
         const jointPublicKey = pointAdd(
-          ecp.fromPrivateKey(coopPrivateKey).publicKey,
+          publicKeyFor(coopPrivateKey),
           hexAsBuffer(responseDetails.coop_public_key)
         );
 
         // The public key from the private keys should be the combined pubkeys
-        if (!coopKey.publicKey.equals(jointPublicKey)) {
+        if (!coopKey.equals(from(jointPublicKey))) {
           return cbk([503, 'ReceivedIncorrectPrivateCoopKey']);
         }
 
         // Derive sweep transactions at different fee rates
         const coop = feeRates.map(({height, rate}) => {
           const {transaction} = taprootCoopTransaction({
-            ecp,
             fee_tokens_per_vbyte: rate,
             network: getNetwork.network,
             output_script: swap.output_script,

package/swaps/complete_on_to_off_swap.js

@@ -22,6 +22,7 @@ const {getNetwork} = require('ln-sync');
 const {getPublicKey} = require('ln-service');
 const {hashForTree} = require('p2tr');
 const {pointAdd} = require('tiny-secp256k1');
+const {pointFromScalar} = require('tiny-secp256k1');
 const {returnResult} = require('asyncjs-util');
 const {sendToChainOutputScripts} = require('ln-service');
 const {settleHodlInvoice} = require('ln-service');
@@ -32,7 +33,6 @@ const {subscribeToInvoice} = require('ln-service');
 const {subscribeToSpend} = require('goldengate');
 const {swapScriptBranches} = require('goldengate');
 const {taprootRefundTransaction} = require('goldengate');
-const tinysecp = require('tiny-secp256k1');
 const {Transaction} = require('bitcoinjs-lib');
 const {v1OutputScript} = require('p2tr');
 
@@ -54,12 +54,14 @@ const hexAsBase64 = hex => Buffer.from(hex, 'hex').toString('base64');
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const historicBlocksRange = 144 * 30;
 const isAnnex = element => element[0] === 0x50;
+const isCompressed = true;
 const maxRefundMultiple = (r, t) => Math.min(100, ((1000 + t) / 150) / r);
 const {min} = Math;
 const minBlocks = 50;
 const pollInterval = {btcregtest: 100};
 const pubKeyAsInternalKey = key => Buffer.from(key).slice(1).toString('hex');
 const pubKeyAsSecret = hexPublicKey => hexPublicKey.slice(2);
+const publicKeyFor = key => Buffer.from(pointFromScalar(key, isCompressed));
 const removeAnnex = stack => stack.slice(0, -1);
 const sha256 = preimage => createHash('sha256').update(preimage).digest('hex');
 const sighash = Transaction.SIGHASH_DEFAULT;
@@ -86,9 +88,6 @@ const witnessLengthTimeoutSweep = 3;
 module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
-      // Import the ECPair library
-      ecp: async () => (await import('ecpair')).ECPairFactory(tinysecp),
-
       // Check arguments
       validate: cbk => {
         if (!args.emitter) {
@@ -190,16 +189,12 @@ module.exports = (args, cbk) => {
       }],
 
       // Get the refund key
-      getRefundKey: [
-        'ecp',
-        'recoveryDetails',
-        ({ecp, recoveryDetails}, cbk) =>
-      {
+      getRefundKey: ['recoveryDetails', ({recoveryDetails}, cbk) => {
         // Exit early when a unilateral private key is defined
         if (!!recoveryDetails.solo_private_key) {
           const privateKey = hexAsBuffer(recoveryDetails.solo_private_key);
 
-          const {publicKey} = ecp.fromPrivateKey(privateKey);
+          const publicKey = publicKeyFor(privateKey);
 
           return cbk(null, {public_key: bufferAsHex(publicKey)});
         }
@@ -296,21 +291,19 @@ module.exports = (args, cbk) => {
 
       // Derive swap details
       swap: [
-        'ecp',
         'getRefundKey',
         'recoveryDetails',
         'waitForDepositHold',
-        ({ecp, getRefundKey, recoveryDetails, waitForDepositHold}, cbk) =>
+        ({getRefundKey, recoveryDetails, waitForDepositHold}, cbk) =>
       {
         const privateKey = recoveryDetails.refund_coop_private_key;
 
         const jointPublicKey = pointAdd(
-          ecp.fromPrivateKey(hexAsBuffer(privateKey)).publicKey,
+          publicKeyFor(hexAsBuffer(privateKey)),
           hexAsBuffer(waitForDepositHold.claim_coop_public_key)
         );
 
         const swapScript = swapScriptBranches({
-          ecp,
           claim_public_key: recoveryDetails.claim_solo_public_key,
           hash: recoveryDetails.hash,
           refund_public_key: getRefundKey.public_key,
@@ -335,7 +328,6 @@ module.exports = (args, cbk) => {
 
       // Generate the refund transactions against the inbound HTLC deadline
       refunds: [
-        'ecp',
         'getChainFee',
         'getNetwork',
         'getRefundKey',
@@ -345,7 +337,6 @@ module.exports = (args, cbk) => {
         'swap',
         'waitForFundHold',
         ({
-          ecp,
           getChainFee,
           getNetwork,
           getRefundKey,
@@ -378,7 +369,6 @@ module.exports = (args, cbk) => {
           }
 
           return taprootRefundTransaction({
-            ecp,
             block_height: height,
             external_key: swap.external_key,
             fee_tokens_per_vbyte: rate,

package/swaps/make_private_key.js

@@ -0,0 +1,26 @@
+const {randomBytes} = require('crypto');
+
+const {isPrivate} = require('tiny-secp256k1');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const privateKeyByteLength = 32;
+
+/** Make a random private key
+
+  {}
+
+  @returns
+  {
+    private_key: <Private Key Hex String>
+  }
+*/
+module.exports = ({}) => {
+  const key = {};
+
+  // Random bytes have a negligible chance of being outside the key range
+  do {
+    key.bytes = randomBytes(privateKeyByteLength);
+  } while (!isPrivate(key.bytes));
+
+  return {private_key: bufferAsHex(key.bytes)};
+};

package/swaps/request_loop_out.js

@@ -17,7 +17,6 @@ const {parsePaymentRequest} = require('ln-service');
 const {pay} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const {swapScriptBranches} = require('goldengate');
-const tinysecp = require('tiny-secp256k1');
 
 const decodeLoopResponse = require('./decode_loop_response');
 const decodeOffToOnRecovery = require('./decode_off_to_on_recovery');
@@ -47,9 +46,6 @@ const timeoutHeight = current => 400 + current - 3;
 module.exports = ({before, lnd, recovery}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
-      // Import ECPair library
-      ecp: async () => (await import('ecpair')).ECPairFactory(tinysecp),
-
       // Check arguments
       validate: cbk => {
         if (!lnd) {
@@ -197,15 +193,13 @@ module.exports = ({before, lnd, recovery}, cbk) => {
       // Derive swap script branches
       script: [
         'create',
-        'ecp',
         'getKey',
         'requestDetails',
         'startHeight',
-        ({create, ecp, getKey, requestDetails, startHeight}, cbk) =>
+        ({create, getKey, requestDetails, startHeight}, cbk) =>
       {
         try {
           const swap = swapScriptBranches({
-            ecp,
             claim_public_key: getKey.public_key,
             hash: requestDetails.hash,
             refund_public_key: create.service_public_key,

package/swaps/start_off_to_on_swap.js

@@ -7,15 +7,18 @@ const {getIdentity} = require('ln-service');
 const {getNetwork} = require('ln-sync');
 const {getPublicKey} = require('ln-service');
 const {networks} = require('bitcoinjs-lib');
+const {pointFromScalar} = require('tiny-secp256k1');
 const {returnResult} = require('asyncjs-util');
-const tinysecp = require('tiny-secp256k1');
 
 const encodeOffToOnRequest = require('./encode_off_to_on_request');
+const makePrivateKey = require('./make_private_key');
 
 const bufferAsHex = buffer => buffer.toString('hex');
 const family = 805;
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const isCompressed = true;
 const makeSecret = () => randomBytes(32);
+const publicKeyFor = key => Buffer.from(pointFromScalar(key, isCompressed));
 const sha256 = preimage => createHash('sha256').update(preimage).digest('hex');
 
 /** Initialize the claim details of a swap
@@ -35,9 +38,6 @@ const sha256 = preimage => createHash('sha256').update(preimage).digest('hex');
 module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
-      // Import the ECPair library
-      ecp: async () => (await import('ecpair')).ECPairFactory(tinysecp),
-
       // Check arguments
       validate: cbk => {
         if (!args.lnd) {
@@ -89,8 +89,9 @@ module.exports = (args, cbk) => {
       }],
 
       // Generate the claim coop key
-      generateCoopKey: ['ecp', 'network', ({ecp, network}, cbk) => {
-        const {privateKey, publicKey} = ecp.makeRandom({network});
+      generateCoopKey: ['network', ({}, cbk) => {
+        const privateKey = hexAsBuffer(makePrivateKey({}).private_key);
+        const publicKey = publicKeyFor(privateKey);
 
         return cbk(null, {
           hash: sha256(publicKey),
@@ -99,13 +100,14 @@ module.exports = (args, cbk) => {
       }],
 
       // Generate the claim solo key
-      generateSoloKey: ['ecp', 'network', ({ecp, network}, cbk) => {
+      generateSoloKey: ['network', ({}, cbk) => {
         // Exit early when the solo key is derived from the internal seed
         if (!args.is_external_solo_key) {
           return cbk(null, {});
         }
 
-        const {publicKey, privateKey} = ecp.makeRandom({network});
+        const privateKey = hexAsBuffer(makePrivateKey({}).private_key);
+        const publicKey = publicKeyFor(privateKey);
 
         return cbk(null, {
           pub: bufferAsHex(publicKey),

package/swaps/start_on_to_off_swap.js

@@ -7,20 +7,24 @@ const {getHeight} = require('ln-service');
 const {getIdentity} = require('ln-service');
 const {getNetwork} = require('ln-sync');
 const {getPublicKey} = require('ln-service');
-const {parsePaymentRequest} = require('ln-service');
 const {networks} = require('bitcoinjs-lib');
+const {parsePaymentRequest} = require('ln-service');
+const {pointFromScalar} = require('tiny-secp256k1');
 const {returnResult} = require('asyncjs-util');
-const tinysecp = require('tiny-secp256k1');
 
 const decodeOffToOnRequest = require('./decode_off_to_on_request');
 const encodeOffToOnResponse = require('./encode_off_to_on_response');
+const makePrivateKey = require('./make_private_key');
 
 const bufferAsHex = buffer => buffer.toString('hex');
 const defaultSwapExpiryMs = 1000 * 60 * 30;
 const family = 805;
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const isCompressed = true;
 const maxSwapDelta = 144 * 30;
 const minSwapDelta = 80;
 const {now} = Date;
+const publicKeyFor = key => Buffer.from(pointFromScalar(key, isCompressed));
 const refundDelta = 144;
 const sha256 = preimage => createHash('sha256').update(preimage).digest('hex');
 
@@ -45,9 +49,6 @@ const sha256 = preimage => createHash('sha256').update(preimage).digest('hex');
 module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
-      // Import the ECPair library
-      ecp: async () => (await import('ecpair')).ECPairFactory(tinysecp),
-
       // Check arguments
       validate: cbk => {
         if (!args.delta) {
@@ -118,8 +119,9 @@ module.exports = (args, cbk) => {
       }],
 
       // Generate the refund coop key
-      generateCoopKey: ['ecp', 'network', ({ecp, network}, cbk) => {
-        const {privateKey, publicKey} = ecp.makeRandom({network});
+      generateCoopKey: ['network', ({}, cbk) => {
+        const privateKey = hexAsBuffer(makePrivateKey({}).private_key);
+        const publicKey = publicKeyFor(privateKey);
 
         return cbk(null, {
           hash: sha256(privateKey),
@@ -129,12 +131,13 @@ module.exports = (args, cbk) => {
       }],
 
       // Generate the refund solo key
-      generateSoloKey: ['ecp', 'network', ({ecp, network}, cbk) => {
+      generateSoloKey: ['network', ({}, cbk) => {
         if (!args.is_external_solo_key) {
           return cbk(null, {});
         }
 
-        const {privateKey, publicKey} = ecp.makeRandom({network});
+        const privateKey = hexAsBuffer(makePrivateKey({}).private_key);
+        const publicKey = publicKeyFor(privateKey);
 
         return cbk(null, {
           private: bufferAsHex(privateKey),