balanceofsatoshis 13.7.2 → 13.8.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## 13.8.0
+
+- `invoice`: Add `--virtual` and `--virtual-fee-rate` to use virtual channel
+
 ## 13.7.2
 
 - `invoice`: Fix payment encoding to include invoice feature bits

package/bos

@@ -1057,24 +1057,31 @@ prog
   .help('Amount can take m/k variables: 5*m for 5 million, 250*k = 0.0025')
   .help('Fiat conversion is supported in amount, N*USD or N*EUR')
   .help(`Fiat rate providers: ${priceProviders.join(', ')}`)
+  .help('--virtual invoices cannot be used with payers who probe before pay')
+  .help('Only one --virtual invoice can be active at a time')
   .argument('[amount]', 'Amount for invoice', STRING, '0')
   .option('--for <description>', 'What is the invoice requesting payment for')
   .option('--include-hints', 'Include the default set of hop hint channels')
   .option('--node <node_name>', 'Use saved node to create invoice')
   .option('--rate-provider <rate_provider>', 'Rate provider', priceProviders)
   .option('--select-hints', 'Select hop hints to be added to the request')
+  .option('--virtual', 'Request payment over a virtual channel')
+  .option('--virtual-fee-rate <pm>', 'Fee rate to use on virtual channel', INT)
   .action((args, options, logger) => {
     return new Promise(async (resolve, reject) => {
       try {
         return await offchain.createInvoice({
+          logger,
           amount: args.amount,
           ask: await commands.interrogate({}),
           description: options.for,
           is_hinting: options.includeHints || undefined,
           is_selecting_hops: options.selectHints || undefined,
+          is_virtual: options.virtual || undefined,
           lnd: (await lnd.authenticatedLnd({logger, node: options.node})).lnd,
           rate_provider: options.rateProvider || undefined,
           request: commands.simpleRequest,
+          virtual_fee_rate: options.virtualFeeRate,
         },
         responses.returnObject({exit, logger, reject, resolve}));
       } catch (err) {

package/offchain/create_invoice.js

@@ -1,5 +1,6 @@
 const asyncAuto = require('async/auto');
 const asyncMap = require('async/map');
+const asyncRetry = require('async/retry');
 const {createInvoice} = require('ln-service');
 const {getChannels} = require('ln-service');
 const {getChannel} = require('ln-service');
@@ -10,6 +11,7 @@ const {getPrices} = require('@alexbosworth/fiat');
 const {parseAmount} = require('ln-accounting');
 const {parsePaymentRequest} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
+const {subscribeToForwardRequests} = require('ln-service');
 
 const signPaymentRequest = require('./sign_payment_request');
 
@@ -18,12 +20,15 @@ const defaultFiatRateProvider = 'coinbase';
 const defaultInvoiceDescription = '';
 const fiats = ['EUR', 'USD'];
 const hasFiat = n => /(eur|usd)/gim.test(n);
+const interval = 3000;
 const {isArray} = Array;
 const {isInteger} = Number;
 const isNumber = n => !isNaN(n);
+const mtokensAsBigUnit = n => (Number(n / BigInt(1000)) / 1e8).toFixed(8);
 const networks = {btc: 'BTC', btctestnet: 'BTC', btcregtest: 'BTC'};
 const parseRequest = request => parsePaymentRequest({request});
 const rateAsTokens = rate => 1e10 / rate;
+const times = 20 * 60 * 24;
 const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 const uniq = arr => Array.from(new Set(arr));
 
@@ -35,6 +40,7 @@ const uniq = arr => Array.from(new Set(arr));
     [description]: <Invoice Description String>
     [is_hinting]: <Include Private Channels Bool>
     [is_selecting_hops]: <Is Selecting Hops Bool>
+    [is_virtual]: <Is Using Virtual Channel for Invoice Bool>
     lnd: <Authenticated LND API Object>
     [rate_provider]: <Fiat Rate Provider String>
     request: <Request Function>
@@ -42,8 +48,9 @@ const uniq = arr => Array.from(new Set(arr));
 
   @returns via cbk or Promise
   {
-    request: <BOLT 11 Payment Request String>
-    tokens: <Invoice Amount Number>
+    [is_settled]: <Invoice Was Paid Bool>
+    [request]: <BOLT 11 Payment Request String>
+    [tokens]: <Invoice Amount Number>
   }
  */
 module.exports = (args, cbk) => {
@@ -67,10 +74,22 @@ module.exports = (args, cbk) => {
           return cbk([400, 'CannotUseDefaultHintsAndAlsoSelectHints']);
         }
 
+        if (!!args.is_virtual && !!args.is_hinting) {
+          return cbk([400, 'UsingHopHintsIsUnsupportedWithVirtualChannels']);
+        }
+
+        if (!!args.is_virtual && !!args.is_selecting_hops) {
+          return cbk([400, 'ChoosingHopHintsUnsupportedWithVirtualChannels']);
+        }
+
         if (!args.lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToCreateNewInvoice']);
         }
 
+        if (!args.logger) {
+          return cbk([400, 'ExpectedWinstonLoggerObjectToCreateNewInvoice']);
+        }
+
         if (!args.request) {
           return cbk([400, 'ExpectedRequestFunctionToCreateNewInvoice']);
         }
@@ -127,7 +146,7 @@ module.exports = (args, cbk) => {
       getNetwork: ['validate', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
 
       // Get wallet info
-      getIdentity: ['validate', ({}, cbk) => getIdentity({lnd: args.lnd}, cbk)],
+      getId: ['validate', ({}, cbk) => getIdentity({lnd: args.lnd}, cbk)],
 
       // Fiat rates
       rates: [
@@ -185,6 +204,7 @@ module.exports = (args, cbk) => {
           return cbk();
         }
 
+        // Make sure there are some channels to select
         if (!getChannels.channels.length) {
           return cbk([400, 'NoRelevantChannelsToSelectAsHints']);
         }
@@ -217,6 +237,7 @@ module.exports = (args, cbk) => {
       getPolicies: ['selectChannels', ({selectChannels}, cbk) => {
         return asyncMap(selectChannels, (channel, cbk) => {
           return getChannel({id: channel, lnd: args.lnd}, (err, res) => {
+            // Exit early when the channel isn't found
             if (isArray(err) && err.slice().shift() === 404) {
               return cbk();
             }
@@ -247,24 +268,100 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
+      // Intercept virtual invoice forwards
+      interceptVirtualInvoice: ['addInvoice', ({addInvoice}, cbk) => {
+        // Exit early when not intercepting the virtual forward
+        if (!args.is_virtual) {
+          return cbk();
+        }
+
+        args.logger.info({listening_for_virtual_channel_payment: true});
+
+        const sub = subscribeToForwardRequests({lnd: args.lnd});
+
+        // Stop listening for the HTLC when the invoice expires
+        const timeout = setTimeout(() => {
+          sub.removeAllListeners();
+
+          return cbk([408, 'TimedOutWaitingForPayment']);
+        },
+        new Date(parseRequest(addInvoice.request).expires_at) - new Date());
+
+        const finished = (err, res) => {
+          clearTimeout(timeout);
+
+          sub.removeAllListeners();
+
+          return cbk(err, res);
+        };
+
+        // Listen for a payment to the virtual channel invoice
+        sub.on('forward_request', async forward => {
+          // Exit early and accept requests that are not for this invoice
+          if (forward.hash !== addInvoice.id) {
+            return forward.accept({});
+          }
+
+          args.logger.info({accepting_payment: true});
+
+          forward.settle({secret: addInvoice.secret});
+
+          // Listen for an error on the requests subscription
+          sub.on('error', err => {
+            args.logger.error({err});
+
+            return finished(err);
+          });
+
+          // Wait until the payment is no longer pending
+          await asyncRetry({interval, times}, async () => {
+            const {channels} = await getChannels({lnd: args.lnd});
+
+            const channel = channels.find(n => n.id === forward.in_channel);
+
+            if (!channel) {
+              throw new Error('FailedToFindForwardChannel');
+            }
+
+            const pending = channel.pending_payments.find(({payment}) => {
+              return payment === forward.in_channel;
+            });
+
+            if (!!pending) {
+              throw new Error('PaymentIsStillPending');
+            }
+
+            return;
+          });
+
+          const got = BigInt(forward.mtokens) + BigInt(forward.fee_mtokens);
+
+          args.logger.info({received: mtokensAsBigUnit(got)});
+
+          return finished();
+        });
+
+        return;
+      }],
+
       // Create the final signed public payment request
       publicRequest: [
         'addInvoice',
-        'getIdentity',
+        'getId',
         'getNetwork',
         'getPolicies',
         'parseAmount',
         ({
           addInvoice,
-          getIdentity,
+          getId,
           getNetwork,
           getPolicies,
           parseAmount,
         },
         cbk) =>
       {
-        // Exit early if not selecting custom hop hints
-        if (!args.is_selecting_hops) {
+        // Exit early if not using custom hop hints
+        if (!args.is_selecting_hops && !args.is_virtual) {
           return cbk(null, {
             request: addInvoice.request,
             tokens: addInvoice.tokens,
@@ -275,17 +372,35 @@ module.exports = (args, cbk) => {
           channels: getPolicies,
           cltv_delta: parseRequest(addInvoice.request).cltv_delta,
           description: args.description || defaultInvoiceDescription,
-          destination: getIdentity.public_key,
+          destination: getId.public_key,
           features: parseRequest(addInvoice.request).features,
           id: addInvoice.id,
+          is_virtual: args.is_virtual,
           lnd: args.lnd,
           network: getNetwork.bitcoinjs,
           payment: addInvoice.payment,
           tokens: parseAmount.tokens,
+          virtual_fee_rate: args.virtual_fee_rate,
         },
         cbk);
       }],
+
+      // Log the virtual channel payment request
+      logRequest: ['publicRequest', ({publicRequest}, cbk) => {
+        // Exit early when not using a virtual channel
+        if (!args.is_virtual) {
+          return cbk(null, publicRequest);
+        }
+
+        args.logger.info({
+          request: publicRequest.request,
+          tokens: parseRequest(publicRequest.request).tokens,
+          virtual_fee_rate: args.virtual_fee_rate || undefined,
+        });
+
+        return cbk(null, {is_settled: true});
+      }],
     },
-    returnResult({reject, resolve, of: 'publicRequest'}, cbk));
+    returnResult({reject, resolve, of: 'logRequest'}, cbk));
   });
 };

package/offchain/sign_payment_request.js

@@ -1,9 +1,13 @@
+const {randomBytes} = require('crypto');
+
 const asyncAuto = require('async/auto');
 const {createSignedRequest} = require('ln-service');
 const {createUnsignedRequest} = require('ln-service');
 const {decode} = require('bip66');
 const {returnResult} = require('asyncjs-util');
+const secp256k1 = require('secp256k1');
 const {signBytes} = require('ln-service');
+const tinysecp256k1 = require('tiny-secp256k1');
 
 const bufferAsHex = buffer => buffer.toString('hex');
 const {concat} = Buffer;
@@ -14,7 +18,11 @@ const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const {isArray} = Array;
 const keyFamilyIdentity = 6;
 const keyIndexIdentity = 0;
+const makePrivateKey = () => randomBytes(32);
+const minimalCltvDelta = 18;
 const rValue = r => r.length === 33 ? r.slice(1) : r;
+const unit8AsHex = n => Buffer.from(n).toString('hex');
+const virtualChannelId = '805x805x805';
 
 /** Create a signed BOLT 11 payment request
 
@@ -95,8 +103,38 @@ module.exports = (args, cbk) => {
         return cbk();
       },
 
+      // Create a key pair for a virtual channel invoice
+      getKeyPair: ['validate', ({}, cbk) => {
+        // Exit early when not using a virtual channel
+        if (!args.is_virtual) {
+          return cbk();
+        }
+
+        const privateKey = makePrivateKey();
+
+        const publicKey = unit8AsHex(secp256k1.publicKeyCreate(privateKey));
+
+        return cbk(null, {private_key: privateKey, public_key: publicKey});
+      }],
+
       // Assemble the hop hints from the chosen hint channels
-      hints: ['validate', ({}, cbk) => {
+      hints: ['getKeyPair', ({getKeyPair}, cbk) => {
+        // Exit early when using a virtual channel
+        if (!!args.is_virtual) {
+          return cbk(null, [[
+            {
+              public_key: args.destination,
+            },
+            {
+              base_fee_mtokens: Number().toString(),
+              channel: virtualChannelId,
+              cltv_delta: minimalCltvDelta,
+              fee_rate: args.virtual_fee_rate || Number(),
+              public_key: getKeyPair.public_key,
+            },
+          ]]);
+        }
+
         const routes = args.channels.map(({id, policies}) => {
           const peerPolicy = policies.find(policy => {
             return policy.public_key !== args.destination;
@@ -121,11 +159,13 @@ module.exports = (args, cbk) => {
 
       // Create the unsigned payment request
       unsigned: ['hints', ({hints}, cbk) => {
+        const [destination] = hints.slice().reverse();
+
         try {
           const unsigned = createUnsignedRequest({
             cltv_delta: args.cltv_delta,
             description: args.description,
-            destination: args.destination,
+            destination: destination.public_key,
             features: args.features,
             id: args.id,
             network: args.network,
@@ -141,28 +181,52 @@ module.exports = (args, cbk) => {
       }],
 
       // Sign the unsigned payment request
-      sign: ['unsigned', ({unsigned}, cbk) => {
+      sign: ['getKeyPair', 'unsigned', ({getKeyPair, unsigned}, cbk) => {
+        // Exit early when signing using the virtual key
+        if (!!args.is_virtual) {
+          const signature = tinysecp256k1.sign(
+            hexAsBuffer(unsigned.hash),
+            getKeyPair.private_key
+          );
+
+          return cbk(null, {
+            destination: getKeyPair.public_key,
+            signature: unit8AsHex(signature),
+          });
+        }
+
+        // Sign the modified payment request using the identity public key
         return signBytes({
           key_family: keyFamilyIdentity,
           key_index: keyIndexIdentity,
           lnd: args.lnd,
           preimage: unsigned.preimage,
         },
-        cbk);
+        (err, res) => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          // Convert the signature format
+          const {r, s} = decode(hexAsBuffer(res.signature));
+
+          return cbk(null, {
+            destination: args.destination,
+            signature: bufferAsHex(concat([rValue(r), s])),
+          });
+        });
       }],
 
-      // Assemble the signed request
+      // Assemble the full signed request
       request: ['sign', 'unsigned', ({sign, unsigned}, cbk) => {
         try {
-          const {r, s} = decode(hexAsBuffer(sign.signature));
-
           const {request} = createSignedRequest({
-            destination: args.destination,
+            destination: sign.destination,
             hrp: unsigned.hrp,
-            signature: bufferAsHex(concat([rValue(r), s])),
+            signature: sign.signature,
             tags: unsigned.tags,
           });
-      
+
           return cbk(null, {request, tokens: args.tokens});
         } catch (err) {
           return cbk([503, 'UnexpectedErrorSigningRequest', {err}]);

package/package.json

@@ -83,5 +83,5 @@
     "postpublish": "docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t alexbosworth/balanceofsatoshis --push .",
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 60 test/arrays/*.js test/balances/*.js test/chain/*.js test/display/*.js test/encryption/*.js test/lnd/*.js test/network/*.js test/nodes/*.js test/peers/*.js test/responses/*.js test/routing/*.js test/services/*.js test/swaps/*.js test/tags/*.js test/telegram/*.js test/wallets/*.js"
   },
-  "version": "13.7.2"
+  "version": "13.8.0"
 }