paid-services 10.3.0 → 10.3.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## Version 10.3.0
+## 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

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.3.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),