balanceofsatoshis 13.6.0 → 13.7.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## 13.7.0
+
+- `invoice`: Add command to create a new invoice
+
 ## 13.6.0
 
 - `tags`: Support tag icons in routing failure source descriptions

package/bos

@@ -32,6 +32,7 @@ const lnurl = importLazy('./lnurl');
 const {lnurlFunctions} = commandConstants;
 const network = importLazy('./network');
 const nodes = importLazy('./nodes');
+const offchain = importLazy('./offchain');
 const {peerSortOptions} = commandConstants;
 const peers = importLazy('./peers');
 const {priceProviders} = commandConstants;
@@ -1051,6 +1052,37 @@ prog
     });
   })
 
+  // Create an invoice
+  .command('invoice', 'Create an invoice and get a BOLT 11 payment request')
+  .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(', ')}`)
+  .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')
+  .action((args, options, logger) => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        return await offchain.createInvoice({
+          amount: args.amount,
+          ask: await commands.interrogate({}),
+          description: options.for,
+          is_hinting: options.includeHints || undefined,
+          is_selecting_hops: options.selectHints || undefined,
+          lnd: (await lnd.authenticatedLnd({logger, node: options.node})).lnd,
+          rate_provider: options.rateProvider || undefined,
+          request: commands.simpleRequest,
+        },
+        responses.returnObject({exit, logger, reject, resolve}));
+      } catch (err) {
+        return logger.error({err}) && reject();
+      }
+    });
+  })
+
   // Join a group channel open
   .command('join-group-channel', 'Join a balanced channels group')
   .visible(false)

package/offchain/create_invoice.js

@@ -0,0 +1,290 @@
+const asyncAuto = require('async/auto');
+const asyncMap = require('async/map');
+const {createInvoice} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {getChannel} = require('ln-service');
+const {getIdentity} = require('ln-service');
+const {getNetwork} = require('ln-sync');
+const {getNodeAlias} = require('ln-sync');
+const {getPrices} = require('@alexbosworth/fiat');
+const {parseAmount} = require('ln-accounting');
+const {parsePaymentRequest} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const signPaymentRequest = require('./sign_payment_request');
+
+const coins = ['BTC'];
+const defaultFiatRateProvider = 'coinbase';
+const defaultInvoiceDescription = '';
+const fiats = ['EUR', 'USD'];
+const hasFiat = n => /(eur|usd)/gim.test(n);
+const {isArray} = Array;
+const {isInteger} = Number;
+const isNumber = n => !isNaN(n);
+const networks = {btc: 'BTC', btctestnet: 'BTC', btcregtest: 'BTC'};
+const parseRequest = request => parsePaymentRequest({request});
+const rateAsTokens = rate => 1e10 / rate;
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
+const uniq = arr => Array.from(new Set(arr));
+
+/** Create an invoice for a requested amount
+
+  {
+    amount: <Invoice Amount String>
+    ask: <Inquirer Function>
+    [description]: <Invoice Description String>
+    [is_hinting]: <Include Private Channels Bool>
+    [is_selecting_hops]: <Is Selecting Hops Bool>
+    lnd: <Authenticated LND API Object>
+    [rate_provider]: <Fiat Rate Provider String>
+    request: <Request Function>
+  }
+
+  @returns via cbk or Promise
+  {
+    request: <BOLT 11 Payment Request String>
+    tokens: <Invoice Amount Number>
+  }
+ */
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.amount) {
+          return cbk([400, 'ExpectedInvoiceAmountToCreateNewInvoice']);
+        }
+
+        if (isNumber(args.amount) && !isInteger(Number(args.amount))) {
+          return cbk([400, 'ExpectedIntegerAmountToInvoice']);
+        }
+
+        if (!args.ask) {
+          return cbk([400, 'ExpectedAskFunctionToCreateNewInvoice']);
+        }
+
+        if (!!args.is_hinting && !!args.is_selecting_hops) {
+          return cbk([400, 'CannotUseDefaultHintsAndAlsoSelectHints']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToCreateNewInvoice']);
+        }
+
+        if (!args.request) {
+          return cbk([400, 'ExpectedRequestFunctionToCreateNewInvoice']);
+        }
+
+        return cbk();
+      },
+
+      // Get the current price of BTC in USD/EUR
+      getFiatPrice: ['validate', ({}, cbk) => {
+        // Exit early when no fiat is referenced
+        if (!hasFiat(args.amount)) {
+          return cbk();
+        }
+
+        return getPrices({
+          from: args.rate_provider || defaultFiatRateProvider,
+          request: args.request,
+          symbols: [].concat(fiats),
+        },
+        cbk);
+      }],
+
+      // Get channels to allow for selecting individual hop hints
+      getChannels: ['validate', ({}, cbk) => {
+        // Exit early when not selecting hop hints
+        if (!args.is_selecting_hops) {
+          return cbk();
+        }
+
+        return getChannels({
+          is_active: true,
+          is_private: true,
+          lnd: args.lnd,
+        },
+        cbk);
+      }],
+
+      // Get node aliases for channels for selecting hop hints
+      getAliases: ['getChannels', ({getChannels}, cbk) => {
+        // Exit early when not selecting hop hints
+        if (!args.is_selecting_hops) {
+          return cbk();
+        }
+
+        const ids = uniq(getChannels.channels.map(n => n.partner_public_key));
+
+        return asyncMap(ids, (id, cbk) => {
+          return getNodeAlias({id, lnd: args.lnd}, cbk);
+        },
+        cbk);
+      }],
+
+      // Get network name
+      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
+
+      // Get wallet info
+      getIdentity: ['validate', ({}, cbk) => getIdentity({lnd: args.lnd}, cbk)],
+
+      // Fiat rates
+      rates: [
+        'getFiatPrice',
+        'getNetwork',
+        ({getFiatPrice, getNetwork}, cbk) =>
+      {
+        // Exit early when there is no fiat
+        if (!getFiatPrice) {
+          return cbk();
+        }
+
+        if (!networks[getNetwork.network]) {
+          return cbk([400, 'UnsupportedNetworkForFiatPriceConversion']);
+        }
+
+        const rates = fiats.map(fiat => {
+          const {rate} = getFiatPrice.tickers.find(n => n.ticker === fiat);
+
+          return {fiat, unit: rateAsTokens(rate)};
+        });
+
+        return cbk(null, rates);
+      }],
+
+      // Parse the amount
+      parseAmount: ['rates', ({rates}, cbk) => {
+        const eur = !!rates ? rates.find(n => n.fiat === 'EUR') : null;
+        const usd = !!rates ? rates.find(n => n.fiat === 'USD') : null;
+
+        // Variables to use in amount
+        const variables = {
+          eur: !!eur ? eur.unit : undefined,
+          usd: !!usd ? usd.unit : undefined,
+        };
+
+        try {
+          const {tokens} = parseAmount({variables, amount: args.amount});
+
+          return cbk(null, {tokens});
+        } catch (err) {
+          return cbk([400, 'FailedToParseAmount', {err}]);
+        }
+      }],
+
+      // Select hop hint channels
+      selectChannels: [
+        'getAliases',
+        'getChannels',
+        'parseAmount',
+        ({getAliases, getChannels}, cbk) =>
+      {
+        // Exit early if not selecting channels
+        if (!args.is_selecting_hops) {
+          return cbk();
+        }
+
+        if (!getChannels.channels.length) {
+          return cbk([400, 'NoRelevantChannelsToSelectAsHints']);
+        }
+
+        return args.ask({
+          choices: getChannels.channels.map(channel => {
+            const node = getAliases.find(({id}) => {
+              return id === channel.partner_public_key
+            });
+
+            const value = channel.id;
+            const inbound = `in: ${tokensAsBigUnit(channel.remote_balance)}`;
+            const outbound = `out: ${tokensAsBigUnit(channel.local_balance)}`;
+
+            return {
+              value,
+              name: `${value} ${node.alias}: ${inbound} | ${outbound}.`,
+            };
+          }),
+          loop: false,
+          message: `Channels to include as hints in the invoice?`,
+          name: 'id',
+          type: 'checkbox',
+          validate: input => !!input.length,
+        },
+        ({id}) => cbk(null, id));
+      }],
+
+      // Get the policies of selected channels
+      getPolicies: ['selectChannels', ({selectChannels}, cbk) => {
+        return asyncMap(selectChannels, (channel, cbk) => {
+          return getChannel({id: channel, lnd: args.lnd}, (err, res) => {
+            if (isArray(err) && err.slice().shift() === 404) {
+              return cbk();
+            }
+
+            if (!!err) {
+              return cbk(err);
+            }
+
+            // Exit early when the channel policies are not defined
+            if (!!res.policies.find(n => n.cltv_delta === undefined)) {
+              return cbk();
+            }
+
+            return cbk(null, res);
+          });
+        },
+        cbk);
+      }],
+
+      // Create the invoice in the LND database
+      addInvoice: ['getPolicies', 'parseAmount', ({parseAmount}, cbk) => {
+        return createInvoice({
+          description: args.description || defaultInvoiceDescription,
+          is_including_private_channels: args.is_hinting || undefined,
+          lnd: args.lnd,
+          tokens: parseAmount.tokens,
+        },
+        cbk);
+      }],
+
+      // Create the final signed public payment request
+      publicRequest: [
+        'addInvoice',
+        'getIdentity',
+        'getNetwork',
+        'getPolicies',
+        'parseAmount',
+        ({
+          addInvoice,
+          getIdentity,
+          getNetwork,
+          getPolicies,
+          parseAmount,
+        },
+        cbk) =>
+      {
+        // Exit early if not selecting custom hop hints
+        if (!args.is_selecting_hops) {
+          return cbk(null, {
+            request: addInvoice.request,
+            tokens: addInvoice.tokens,
+          });
+        }
+
+        return signPaymentRequest({
+          channels: getPolicies,
+          cltv_delta: parseRequest(addInvoice.request).cltv_delta,
+          description: args.description || defaultInvoiceDescription,
+          destination: getIdentity.public_key,
+          id: addInvoice.id,
+          lnd: args.lnd,
+          network: getNetwork.bitcoinjs,
+          payment: addInvoice.payment,
+          tokens: parseAmount.tokens,
+        },
+        cbk);
+      }],
+    },
+    returnResult({reject, resolve, of: 'publicRequest'}, cbk));
+  });
+};

package/offchain/index.js

@@ -0,0 +1,3 @@
+const createInvoice = require('./create_invoice');
+
+module.exports = {createInvoice};

package/offchain/sign_payment_request.js

@@ -0,0 +1,166 @@
+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 {signBytes} = require('ln-service');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const {concat} = Buffer;
+const defaultBaseFee = '1000';
+const defaultCltvDelta = 144;
+const defaultFeeRate = '1';
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const {isArray} = Array;
+const keyFamilyIdentity = 6;
+const keyIndexIdentity = 0;
+const rValue = r => r.length === 33 ? r.slice(1) : r;
+
+/** Create a signed BOLT 11 payment request
+
+  {
+    channels: [{
+      id: <Channel Id String>
+      policies: [{
+        [base_fee_mtokens]: <Base Routing Fee Millitokens String>
+        [cltv_delta]: <Routing CLTV Delta Number>
+        [fee_rate]: <Routing PPM Fee Rate Number>
+        public_key: <Node Identity Public Key Hex String>
+      }]
+    }]
+    cltv_delta: <Invoice Final CLTV Delta Number>
+    description: <Invoice Description String>
+    destination: <Destination Public Key Hex String>
+    id: <Payment Hash Hex String>
+    lnd: <Authenticated LND API Object>
+    network: <BitcoinJs Network Name String>
+    payment: <Payment Nonce Hex String>
+    tokens: <Invoiced Amount Tokens Number>
+  }
+
+  @returns via cbk or Promise
+  {
+    request: <BOLT 11 Payment Request String>
+    tokens: <Invoiced Tokens Number>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isArray(args.channels)) {
+          return cbk([400, 'ExpectedArrayOfChannelsToSignPaymentRequest']);
+        }
+
+        if (!args.cltv_delta) {
+          return cbk([400, 'ExpectedFinalCltvDeltaToSignPaymentRequest']);
+        }
+
+        if (args.description === undefined) {
+          return cbk([400, 'ExpectedInvoiceDescriptionToSignPaymentRequest']);
+        }
+
+        if (!args.destination) {
+          return cbk([400, 'ExpectedDestinationNodeIdToSignPaymentRequest']);
+        }
+
+        if (!args.id) {
+          return cbk([400, 'ExpectedPaymentHashToSignPaymentRequest']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToSignPaymentRequest']);
+        }
+
+        if (!args.network) {
+          return cbk([400, 'ExpectedNetworkNameToSignPaymentRequest']);
+        }
+
+        if (!args.payment) {
+          return cbk([400, 'ExpectedPaymentNonceToSignPaymentRequest']);
+        }
+
+        if (args.tokens === undefined) {
+          return cbk([400, 'ExpectedTokensToInvoiceToSignPaymentRequest']);
+        }
+
+        return cbk();
+      },
+
+      // Assemble the hop hints from the chosen hint channels
+      hints: ['validate', ({}, cbk) => {
+        const routes = args.channels.map(({id, policies}) => {
+          const peerPolicy = policies.find(policy => {
+            return policy.public_key !== args.destination;
+          });
+
+          return [
+            {
+              public_key: peerPolicy.public_key,
+            },
+            {
+              base_fee_mtokens: peerPolicy.base_fee_mtokens || defaultBaseFee,
+              channel: id,
+              cltv_delta: peerPolicy.cltv_delta || defaultCltvDelta,
+              fee_rate: peerPolicy.fee_rate || defaultFeeRate,
+              public_key: args.destination,
+            },
+          ];
+        });
+
+        return cbk(null, routes);
+      }],
+
+      // Create the unsigned payment request
+      unsigned: ['hints', ({hints}, cbk) => {
+        try {
+          const unsigned = createUnsignedRequest({
+            cltv_delta: args.cltv_delta,
+            description: args.description,
+            destination: args.destination,
+            id: args.id,
+            network: args.network,
+            payment: args.payment,
+            routes: !!hints.length ? hints : undefined,
+            tokens: args.tokens,
+          });
+
+          return cbk(null, unsigned);
+        } catch (err) {
+          return cbk([500, 'UnexpectedErrorCreatingUnsignedRequest', {err}]);
+        }
+      }],
+
+      // Sign the unsigned payment request
+      sign: ['unsigned', ({unsigned}, cbk) => {
+        return signBytes({
+          key_family: keyFamilyIdentity,
+          key_index: keyIndexIdentity,
+          lnd: args.lnd,
+          preimage: unsigned.preimage,
+        },
+        cbk);
+      }],
+
+      // Assemble the signed request
+      request: ['sign', 'unsigned', ({sign, unsigned}, cbk) => {
+        try {
+          const {r, s} = decode(hexAsBuffer(sign.signature));
+
+          const {request} = createSignedRequest({
+            destination: args.destination,
+            hrp: unsigned.hrp,
+            signature: bufferAsHex(concat([rValue(r), s])),
+            tags: unsigned.tags,
+          });
+      
+          return cbk(null, {request, tokens: args.tokens});
+        } catch (err) {
+          return cbk([503, 'UnexpectedErrorSigningRequest', {err}]);
+        }
+      }],
+    },
+    returnResult({reject, resolve, of: 'request'}, cbk));
+  });
+};

package/package.json

@@ -36,7 +36,7 @@
     "ini": "3.0.1",
     "inquirer": "9.1.4",
     "ln-accounting": "6.1.1",
-    "ln-service": "54.2.6",
+    "ln-service": "54.3.0",
     "ln-sync": "4.0.5",
     "ln-telegram": "4.2.0",
     "moment": "2.29.4",
@@ -53,8 +53,8 @@
   "description": "Lightning balance CLI",
   "devDependencies": {
     "@alexbosworth/tap": "15.0.11",
-    "invoices": "2.2.0",
-    "ln-docker-daemons": "3.1.4",
+    "invoices": "2.2.1",
+    "ln-docker-daemons": "3.1.5",
     "mock-lnd": "1.4.4",
     "tiny-secp256k1": "2.2.1"
   },
@@ -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.6.0"
+  "version": "13.7.0"
 }