balanceofsatoshis 12.5.1 → 12.6.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Versions
 
+## 12.6.2
+
+- `telegram`: Avoid bot crash when receiving an AMP push payment
+
+## 12.6.1
+
+- `lnurl`: Add support for `channel` to request an inbound channel
+
 ## 12.5.1
 
 - `open-balanced-channel`: Correct potential future regression in signing

package/bos

@@ -1024,6 +1024,7 @@ prog
   .argument('<function>', 'lnurl function', keys(lnurlFunctions))
   .help(`Functions: ${keys(lnurlFunctions).join(', ')}`)
   .help('lnurl auth will request authorization')
+  .help('lnurl channel will request an incoming payment channel')
   .help('lnurl pay will request a payment request from a service')
   .help('lnurl withdraw will create an invoice and send it to a service')
   .option('--avoid <avoid>', 'Avoid forwarding via node/chan/tag', REPEATABLE)

package/commands/constants.json

@@ -9,6 +9,7 @@
   },
   "lnurlFunctions": {
     "auth": "auth",
+    "channel": "channel",
     "pay": "pay",
     "withdraw": "withdraw"
   },

package/lnurl/channel.js

@@ -0,0 +1,295 @@
+const {isIP} = require('net');
+
+const asyncAuto = require('async/auto');
+const {bech32} = require('bech32');
+const {addPeer} = require('ln-service');
+const {getIdentity} = require('ln-service');
+const {getNodeAlias} = require('ln-sync');
+const {getPeers} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const asLnurl = n => n.substring(n.startsWith('lightning:') ? 10 : 0);
+const bech32CharLimit = 2000;
+const {decode} = bech32;
+const errorStatus = 'ERROR';
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const okStatus = 'OK';
+const parseUri = n => n.split('@');
+const prefix = 'lnurl';
+const sslProtocol = 'https:';
+const tag = 'channelRequest';
+const typeDefault = '0';
+const types = [{name: 'Public', value: '0'}, {name: 'Private', value: '1'}];
+const wordsAsUtf8 = n => Buffer.from(bech32.fromWords(n)).toString('utf8');
+
+/** Request inbound channel from lnurl
+
+  {
+    ask: <Ask Function>
+    lnd: <Authenticated LND API Object>
+    lnurl: <Lnurl String>
+    logger: <Winston Logger Object>
+    request: <Request Function>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.ask) {
+          return cbk([400, 'ExpectedAskFunctionToRequestChannelFromLnurl']);
+        }
+
+        if (!args.lnurl) {
+          return cbk([400, 'ExpectedUrlToRequestChannelFromLnurl']);
+        }
+
+        try {
+          decode(asLnurl(args.lnurl), bech32CharLimit);
+        } catch (err) {
+          return cbk([400, 'FailedToDecodeLnurlToRequestChannel', {err}]);
+        }
+
+        if (decode(asLnurl(args.lnurl), bech32CharLimit).prefix !== prefix) {
+          return cbk([400, 'ExpectedLnUrlPrefixToRequestChannel']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndToRequestChannelFromLnurl']);
+        }
+
+        if (!args.logger) {
+          return cbk([400, 'ExpectedLoggerToRequestChannelFromLnurl']);
+        }
+
+        if (!args.request) {
+          return cbk([400, 'ExpectedRequestFunctionToGetLnurlRequestChannel']);
+        }
+
+        return cbk();
+      },
+
+      // Get node identity public key
+      getIdentity: ['validate', ({}, cbk) => {
+        return getIdentity({lnd: args.lnd}, cbk);
+      }],
+
+      // Get the list of connected peers to determine if connection is needed
+      getPeers: ['validate', ({}, cbk) => getPeers({lnd: args.lnd}, cbk)],
+
+      // Get accepted terms from the encoded url
+      getTerms: ['validate', ({}, cbk) => {
+        const {words} = decode(asLnurl(args.lnurl), bech32CharLimit);
+
+        const url = wordsAsUtf8(words);
+
+        return args.request({url, json: true}, (err, r, json) => {
+          if (!!err) {
+            return cbk([503, 'FailureGettingLnurlDataFromUrl', {err}]);
+          }
+
+          if (!json) {
+            return cbk([503, 'ExpectedJsonObjectReturnedInLnurlResponse']);
+          }
+
+          if (json.status === errorStatus) {
+            return cbk([503, 'UnexpectedServiceError', {err: json.reason}]);
+          }
+
+          if (!json.callback) {
+            return cbk([503, 'ExpectedCallbackInLnurlResponseJson']);
+          }
+
+          try {
+            new URL(json.callback);
+          } catch (err) {
+            return cbk([503, 'ExpectedValidLnurlResponseCallbackUrl', {err}]);
+          }
+
+          if ((new URL(json.callback)).protocol !== sslProtocol) {
+            return cbk([400, 'LnurlsThatSpecifyNonSslUrlsAreUnsupported']);
+          }
+
+          if (!json.k1) {
+            return cbk([503, 'ExpectedK1InLnurlChannelResponseJson']);
+          }
+
+          if (!json.tag) {
+            return cbk([503, 'ExpectedTagInLnurlChannelResponseJson']);
+          }
+
+          if (json.tag !== tag) {
+            return cbk([503, 'ExpectedTagToBeChannelRequestInLnurlResponse']);
+          }
+
+          if (!json.uri) {
+            return cbk([503, 'ExpectedUriInLnurlResponseJson']);
+          }
+
+          // uri: remote node address of form node_key@ip_address:port_number
+          const [id, socket] = parseUri(json.uri);
+
+          if (!isPublicKey(id)) {
+            return cbk([503, 'ExpectedValidPublicKeyIdInLnurlResponseJson']);
+          }
+
+          if (!socket) {
+            return cbk([503, 'ExpectedNetworkSocketAddressInLnurlResponse']);
+          }
+
+          return cbk(null, {id, socket, k1: json.k1, url: json.callback});
+        });
+      }],
+
+      // Get the node alias
+      getAlias: ['getTerms', ({getTerms}, cbk) => {
+        return getNodeAlias({id: getTerms.id, lnd: args.lnd}, cbk);
+      }],
+
+      // Connect to the peer returned in the lnurl response
+      connect: [
+        'getAlias',
+        'getPeers',
+        'getTerms',
+        ({getAlias, getPeers, getTerms}, cbk) =>
+      {
+        // Exit early when the node is already connected
+        if (getPeers.peers.map(n => n.public_key).includes(getTerms.id)) {
+          return cbk();
+        }
+
+        args.logger.info({
+          connecting_to: {
+            alias: getAlias.alias || undefined,
+            public_key: getTerms.id,
+            socket: getTerms.socket,
+          },
+        });
+
+        return addPeer({
+          lnd: args.lnd,
+          public_key: getTerms.id,
+          socket: getTerms.socket,
+        },
+        cbk);
+      }],
+
+      // Select private or public mode for the channel
+      askPrivate: ['connect', 'getTerms', ({getTerms}, cbk) => {
+        return args.ask({
+          choices: types,
+          default: typeDefault,
+          message: 'Channel type?',
+          name: 'priv',
+          type: 'list',
+        },
+        ({priv}) => cbk(null, priv));
+      }],
+
+      // Confirm that an inbound channel should be requested
+      ok: ['askPrivate', 'getAlias', ({askPrivate, getAlias}, cbk) => {
+        const node = getAlias.alias || getAlias.id;
+        const type = !!askPrivate ? 'a private' : 'an';
+
+        return args.ask({
+          default: true,
+          message: `Request ${type} inbound channel from ${node}?`,
+          name: 'ok',
+          type: 'confirm',
+        },
+        ({ok}) => cbk(null, ok));
+      }],
+
+      // Send a signal to cancel the channel request
+      sendCancelation: [
+        'getIdentity',
+        'getTerms',
+        'ok',
+        ({channel, getTerms, ok}, cbk) =>
+      {
+        // Exit early when user wants to proceed with the channel request
+        if (!!ok) {
+          return cbk();
+        }
+
+        return args.request({
+          json: true,
+          qs: {
+            cancel: Number(!ok),
+            k1: getTerms.k1,
+            remoteid: getIdentity.public_key,
+          },
+          url: getTerms.url,
+        },
+        (err, r, json) => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorCancelingChannelRequest', {err}]);
+          }
+
+          if (!json) {
+            return cbk([503, 'ExpectedJsonObjectInCancelChannelResponse']);
+          }
+
+          if (json.status === errorStatus) {
+            return cbk([503, 'ChannelCancelReturnedErr', {err: json.reason}]);
+          }
+
+          if (json.status !== okStatus) {
+            return cbk([503, 'ExpectedOkStatusInCancelChannelResponse']);
+          }
+
+          return cbk([400, 'CanceledRequestForInboundChannel']);
+        });
+      }],
+
+      // Make the request to confirm a request for an inbound channel
+      sendConfirmation: [
+        'askPrivate',
+        'getIdentity',
+        'getTerms',
+        'ok',
+        ({askPrivate, getIdentity, getTerms, ok}, cbk) =>
+      {
+        // Exit early when the user decides to cancel
+        if (!ok) {
+          return cbk();
+        }
+
+        return args.request({
+          json: true,
+          qs: {
+            k1: getTerms.k1,
+            private: askPrivate,
+            remoteid: getIdentity.public_key,
+          },
+          url: getTerms.url,
+        },
+        (err, r, json) => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorRequestingLnurlChannel', {err}]);
+          }
+
+          if (!json) {
+            return cbk([503, 'ExpectedJsonObjectReturnedInChannelResponse']);
+          }
+
+          if (json.status === errorStatus) {
+            return cbk([503, 'ChannelRequestReturnedErr', {err: json.reason}]);
+          }
+
+          if (json.status !== okStatus) {
+            return cbk([503, 'ExpectedOkStatusInChannelRequestResponse']);
+          }
+
+          args.logger.info({requested_channel_open: true});
+
+          return cbk();
+        });
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/lnurl/manage_lnurl.js

@@ -2,13 +2,16 @@ const asyncAuto = require('async/auto');
 const {returnResult} = require('asyncjs-util');
 
 const auth = require('./auth');
+const channel = require('./channel');
 const pay = require('./pay');
 const withdraw = require('./withdraw');
 
 const functionAuth = 'auth';
+const functionChannel = 'channel';
 const functionPay = 'pay';
 const functionWithdraw = 'withdraw';
 const {isArray} = Array;
+const supportedFunctions = ['auth', 'channel', 'pay', 'withdraw'];
 
 /** Manage Lnurl functions
 
@@ -40,7 +43,7 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedArrayOfAvoidsToManageLnurl']);
         }
 
-        if (![functionAuth, functionPay, functionWithdraw].includes(args.function)) {
+        if (!supportedFunctions.includes(args.function)) {
           return cbk([400, 'ExpectedLnurlFunctionToManageLnurl']);
         }
 
@@ -84,6 +87,23 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
+      // Request inbound channel
+      channel: ['validate', ({}, cbk) => {
+        // Exit early if not lnurl channel
+        if (args.function !== functionChannel) {
+          return cbk();
+        }
+
+        return channel({
+          ask: args.ask,
+          lnd: args.lnd,
+          lnurl: args.lnurl,
+          logger: args.logger,
+          request: args.request,
+        },
+        cbk);
+      }],
+
       // Pay to lnurl
       pay: ['validate', ({}, cbk) => {
         // Exit early if not lnurl pay

package/package.json

@@ -36,11 +36,11 @@
     "ini": "3.0.0",
     "inquirer": "8.2.2",
     "ln-accounting": "5.0.6",
-    "ln-service": "53.14.1",
+    "ln-service": "53.15.0",
     "ln-sync": "3.12.0",
     "ln-telegram": "3.21.2",
     "moment": "2.29.3",
-    "paid-services": "3.15.2",
+    "paid-services": "3.15.4",
     "probing": "2.0.5",
     "psbt": "2.0.1",
     "qrcode-terminal": "0.12.0",
@@ -84,5 +84,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": "12.5.1"
+  "version": "12.6.2"
 }

package/telegram/start_telegram_bot.js

@@ -58,6 +58,7 @@ const ask = (n, cbk) => inquirer.prompt(n).then(n => cbk(n));
 const fileAsDoc = file => new InputFile(file.source, file.filename);
 const fromName = node => `${node.alias} ${node.public_key.substring(0, 8)}`;
 const {isArray} = Array;
+const isHash = n => /^[0-9A-F]{64}$/i.test(n);
 let isBotInit = false;
 const isNumber = n => !isNaN(n);
 const limit = 99999;
@@ -694,6 +695,11 @@ module.exports = (args, cbk) => {
           subscriptions.push(sub);
 
           sub.on('invoice_updated', invoice => {
+            // Exit early when an invoice has no associated hash
+            if (!isHash(invoice.id)) {
+              return;
+            }
+
             return postSettledInvoice({
               from: node.from,
               id: connectedId,