balanceofsatoshis 11.52.1 → 11.52.2

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## 11.52.2
+
+- `telegram`: Fix connected node offline notifications
+
 ## 11.52.1
 
 - `fees`, `open`: Fix regression crash when setting fees on a pending channel

package/package.json

@@ -37,14 +37,14 @@
     "ln-accounting": "5.0.5",
     "ln-service": "53.8.0",
     "ln-sync": "3.10.0",
-    "ln-telegram": "3.16.0",
+    "ln-telegram": "3.17.1",
     "moment": "2.29.1",
     "paid-services": "3.11.0",
     "probing": "2.0.3",
     "psbt": "2.0.0",
     "qrcode-terminal": "0.12.0",
     "sanitize-filename": "1.6.3",
-    "socks-proxy-agent": "6.1.1",
+    "socks-proxy-agent": "6.2.0-beta.0",
     "table": "6.8.0",
     "update-notifier": "5.1.0",
     "window-size": "1.1.1"
@@ -79,7 +79,7 @@
     "integration-tests": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 120 test/integration/*.js",
     "postpack": "PACKAGE_VERSION=$(cat package.json | grep \\\"version\\\" | head -1 | awk -F: '{ print $2 }' | sed 's/[\",]//g' | tr -d '[[:space:]]') && git tag -s v$PACKAGE_VERSION -m v$PACKAGE_VERSION && git push github --tags",
     "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/wallets/*.js"
+    "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": "11.52.1"
+  "version": "11.52.2"
 }

package/telegram/connect_to_telegram.js

@@ -1,16 +1,15 @@
-const {homedir} = require('os');
-const {join} = require('path');
-
 const asyncAuto = require('async/auto');
 const asyncForever = require('async/forever');
 const asyncMap = require('async/map');
-const {getWalletVersion} = require('ln-service');
+const {getWalletInfo} = require('ln-service');
+const {postNodesOffline} = require('ln-telegram');
 const {returnResult} = require('asyncjs-util');
 
 const {getLnds} = require('./../lnd');
-const startTelegramBot = require('./start_telegram_bot');
+const getTelegramBot = require('./get_telegram_bot');
+const runTelegramBot = require('./run_telegram_bot');
 
-const home = '.bos';
+const defaultPaymentsBudget = 0;
 const restartDelayMs = 1000 * 60 * 3;
 
 /** Connect nodes to Telegram
@@ -63,68 +62,72 @@ module.exports = (args, cbk) => {
         return cbk();
       },
 
-      // Check nodes
-      checkNodes: ['validate', async () => {
+      // Get the nodes
+      getNodes: ['validate', async () => {
         const {nodes} = args;
 
         const {lnds} = await getLnds({nodes, logger: args.logger});
 
         const withName = lnds.map((lnd, i) => ({lnd, node: (nodes || [])[i]}));
 
-        return await asyncMap(withName, async ({lnd, node}) => {
+        return asyncMap(withName, async ({lnd, node}) => {
           try {
-            return await getWalletVersion({lnd});
+            const wallet = await getWalletInfo({lnd});
+
+            return {node, alias: wallet.alias, id: wallet.public_key};
           } catch (err) {
             args.logger.error({node, err: 'failed_to_connect'});
-          }
 
-          return;
+            throw err;
+          }
         });
       }],
 
-      // Home directory path
-      path: ['checkNodes', ({}, cbk) => {
-        return cbk(null, join(...[homedir(), home]));
+      // Get the telegram bot
+      getBot: ['validate', ({}, cbk) => {
+        return getTelegramBot({fs: args.fs, proxy: args.proxy}, cbk);
       }],
 
       // Start bot
-      startTelegram: ['checkNodes', ({}, cbk) => {
+      start: ['getBot', 'getNodes', ({getBot, getNodes}, cbk) => {
         let {limit} = args.payments;
+        let online = getNodes.map(n => n.id);
 
         return asyncForever(cbk => {
-          return getLnds({
+          return runTelegramBot({
+            bot: getBot.bot,
+            fs: args.fs,
+            id: args.id,
+            min_forward_tokens: args.min_forward_tokens,
             logger: args.logger,
-            nodes: args.nodes
+            nodes: args.nodes,
+            payments_limit: limit || defaultPaymentsBudget,
+            request: args.request,
           },
           (err, res) => {
-            // Exit the loop when the backing LNDs cannot be found
             if (!!err) {
               return cbk(err);
             }
 
-            const {lnds} = res;
-
-            args.logger.info({connecting_to_telegram: args.nodes});
-
-            return startTelegramBot({
-              lnds,
-              fs: args.fs,
-              id: args.id,
-              limits: {
-                min_forward_tokens: args.min_forward_tokens || undefined,
-              },
-              logger: args.logger,
-              payments: {limit},
-              proxy: args.proxy,
-              request: args.request,
+            const offline = online.filter(id => !res.online.includes(id));
+
+            // Refresh the current online status
+            online = res.online.slice();
+
+            // Reset payment budget
+            limit = Number();
+
+            return postNodesOffline({
+              bot: getBot.bot,
+              connected: res.connected,
+              offline: getNodes.filter(n => offline.includes(n.id)),
             },
             err => {
-              args.logger.error(err || [503, 'TelegramBotFailed']);
-
-              // Reset payment budget
-              limit = Number();
+              if (!!err) {
+                return cbk(err);
+              }
 
-              return setTimeout(() => cbk(), restartDelayMs);
+              return setTimeout(cbk, restartDelayMs);
             });
           });
         },

package/telegram/get_socks_proxy.js

@@ -0,0 +1,78 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+const {SocksProxyAgent} = require('socks-proxy-agent');
+
+const {parse} = JSON;
+
+/** Get a SOCKS proxy given a JSON configuration file path
+
+  {
+    fs: {
+      getFile: <Get File From Filesystem Function>
+    }
+    path: <Path To Proxy Configuration JSON File String>
+  }
+
+  @returns via cbk or Promise
+  {
+    agent: <Socks Proxy Agent Object>
+  }
+*/
+module.exports = ({fs, path}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!fs) {
+          return cbk([400, 'ExpectedFileSystemMethodsToGetSocksProxyAgent']);
+        }
+
+        if (!path) {
+          return cbk([400, 'ExpectedPathToSocksJsonFileToGetSocksProxyAgent']);
+        }
+
+        return cbk();
+      },
+
+      // Get the configuration file
+      getFile: ['validate', ({}, cbk) => {
+        return fs.getFile(path, (err, res) => {
+          if (!!err) {
+            return cbk([400, 'FailedToFindFileAtProxySpecifiedPath', {err}]);
+          }
+
+          if (!res) {
+            return cbk([400, 'ExpectedFileDataAtProxySpecifiedPath']);
+          }
+
+          return cbk(null, res.toString());
+        });
+      }],
+
+      // Construct the SOCKS proxy agent
+      agent: ['getFile', ({getFile}, cbk) => {
+        try {
+          parse(getFile);
+        } catch (err) {
+          return cbk([400, 'ExpectedValidJsonConfigFileForProxy', {err}]);
+        }
+
+        const {host, password, port, userId} = parse(getFile);
+
+        try {
+          const agent = new SocksProxyAgent({
+            password,
+            port,
+            userId,
+            hostname: host,
+          });
+
+          return cbk(null, {agent});
+        } catch (err) {
+          return cbk([503, 'FailedToCreateSocksProxyAgent', {err}]);
+        }
+      }],
+    },
+    returnResult({reject, resolve, of: 'agent'}, cbk));
+  });
+};

package/telegram/get_telegram_bot.js

@@ -0,0 +1,122 @@
+const {homedir} = require('os');
+const {join} = require('path');
+
+const asyncAuto = require('async/auto');
+const asyncReflect = require('async/reflect');
+const {Bot} = require('grammy');
+const inquirer = require('inquirer');
+const {returnResult} = require('asyncjs-util');
+
+const getSocksProxy = require('./get_socks_proxy');
+const interaction = require('./interaction');
+
+const botKeyFile = 'telegram_bot_api_key';
+const home = '.bos';
+
+/** Get the Telegram Bot object
+
+  {
+    fs: {
+      getFile: <Get File Contents Function>
+      getFileStatus: <Get File Status Function>
+      makeDirectory: <Make Directory Function>
+      writeFile: <Write File Function>
+    }
+    [proxy]: <Proxy Details JSON File Path String>
+  }
+
+  @returns via cbk or Promise
+  {
+    bot: <Telegram Bot Object>
+    key: <Telegram API Key String>
+  }
+*/
+module.exports = ({fs, proxy}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!fs) {
+          return cbk([400, 'ExpectedFileSystemMethodsToGetTelegramBot']);
+        }
+
+        return cbk();
+      },
+
+      // Get proxy agent
+      getProxy: ['validate', ({}, cbk) => {
+        // Exit early if not using a proxy
+        if (!proxy) {
+          return cbk();
+        }
+
+        return getSocksProxy({fs, path: proxy}, cbk);
+      }],
+
+      // Home directory path
+      path: ['validate', ({}, cbk) => cbk(null, join(...[homedir(), home]))],
+
+      // Ask for an API key
+      apiKey: ['path', ({path}, cbk) => {
+        return fs.getFile(join(...[path, botKeyFile]), (err, res) => {
+          // Exit early when resetting the API key
+          if (!!err || !res || !res.toString() || !!fs.is_reset_state) {
+            const token = interaction.api_token_prompt;
+
+            inquirer.prompt([token]).then(({key}) => cbk(null, {key}));
+
+            return;
+          }
+
+          return cbk(null, {is_saved: true, key: res.toString()});
+        });
+      }],
+
+      // Create the bot
+      createBot: ['apiKey', 'getProxy', ({apiKey, getProxy}, cbk) => {
+        const {key} = apiKey;
+
+        // Exit early when there is no SOCKS proxy
+        if (!getProxy) {
+          return cbk(null, {key, bot: new Bot(key)});
+        }
+
+        // Initiate bot using proxy agent when configured
+        const bot = new Bot(key, {
+          client: {baseFetchConfig: {agent: getProxy.agent, compress: true}},
+        });
+
+        return cbk(null, {bot, key});
+      }],
+
+      // Test the created bot
+      test: ['createBot', async ({createBot}) => {
+        // Start the bot
+        return await createBot.bot.init();
+      }],
+
+      // Make the home directory if it's not already present
+      makeDir: ['apiKey', 'path', 'test', asyncReflect(({path}, cbk) => {
+        return fs.makeDirectory(path, cbk);
+      })],
+
+      // Save the bot API key so it doesn't need to be entered next run
+      saveKey: ['apiKey', 'path', 'makeDir', ({apiKey, path}, cbk) => {
+        // Exit early when API key is already saved
+        if (!!apiKey.is_saved) {
+          return cbk();
+        }
+
+        // Ignore errors when making directory, it may already be present
+        return fs.writeFile(join(...[path, botKeyFile]), apiKey.key, err => {
+          if (!!err) {
+            return cbk([503, 'FailedToSaveTelegramApiToken', {err}]);
+          }
+
+          return cbk();
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'createBot'}, cbk));
+  });
+};

package/telegram/run_telegram_bot.js

@@ -0,0 +1,128 @@
+const asyncAuto = require('async/auto');
+const asyncFilter = require('async/filter');
+const asyncMap = require('async/map');
+const {getIdentity} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const {getLnds} = require('./../lnd');
+const startTelegramBot = require('./start_telegram_bot');
+
+const defaultError = [503, 'TelegramBotStopped'];
+const {isArray} = Array;
+
+/** Run the telegram bot for a node or multiple nodes
+
+  {
+    bot: <Telegram Bot Object>
+    fs: {
+      getFile: <Get File Contents Function>
+      [is_reset_state]: <Reset File Status Bool>
+      makeDirectory: <Make Directory Function>
+      writeFile: <Write File Function>
+    }
+    [id]: <Authorized User Id Number>
+    [min_forward_tokens]: <Minimum Forward Tokens To Notify Number>
+    logger: <Winston Logger Object>
+    nodes: [<Node Name String>]
+    payments_limit: <Total Spendable Budget Tokens Limit Number>
+    [proxy]: <Socks Proxy Agent Object>
+    request: <Request Function>
+  }
+
+  @returns via cbk or Promise
+  {
+    [connected]: <Connected Id Number>
+    online: [{
+      alias: <Node Alias String>
+      id: <Node Public Key Id Hex String>
+    }]
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.bot) {
+          return cbk([400, 'ExpectedTelegramBotToRunTelegramBot']);
+        }
+
+        if (!args.fs) {
+          return cbk([400, 'ExpectedFilesystemMethodsToRunTelegramBot']);
+        }
+
+        if (!args.logger) {
+          return cbk([400, 'ExpectedWinstonLoggerToRunTelegramBot']);
+        }
+
+        if (!isArray(args.nodes)) {
+          return cbk([400, 'ExpectedArrayOfSavedNodesToRunTelegramBot']);
+        }
+
+        if (args.payments_limit === undefined) {
+          return cbk([400, 'ExpectedPaymentsLimitToRunTelegramBot']);
+        }
+
+        if (!args.request) {
+          return cbk([400, 'ExpectedRequestFunctionToRunTelegrambot']);
+        }
+
+        return cbk();
+      },
+
+      // Get associated LNDs
+      getLnds: ['validate', ({}, cbk) => {
+        return getLnds({logger: args.logger, nodes: args.nodes}, cbk);
+      }],
+
+      // Start the bot going
+      startBot: ['getLnds', ({getLnds}, cbk) => {
+        args.logger.info({connecting_to_telegram: args.nodes});
+
+        return startTelegramBot({
+          bot: args.bot,
+          fs: args.fs,
+          id: args.id,
+          min_forward_tokens: args.min_forward_tokens,
+          lnds: getLnds.lnds,
+          logger: args.logger,
+          payments_limit: args.payments_limit,
+          proxy: args.proxy,
+          request: args.request,
+        },
+        cbk);
+      }],
+
+      // Check the LNDs that they can connect
+      getConnected: ['getLnds', 'startBot', ({getLnds}, cbk) => {
+        return asyncMap(getLnds.lnds, (lnd, cbk) => {
+          return getIdentity({lnd}, (err, res) => {
+            // Return no id when there is an error getting the wallet info
+            if (!!err) {
+              return cbk();
+            }
+
+            return cbk(null, res.public_key);
+          });
+        },
+        cbk);
+      }],
+
+      // Final set of connected nodes
+      online: ['getConnected', 'startBot', ({getConnected, startBot}, cbk) => {
+        // Report the failure that killed the bot
+        if (!!startBot.failure) {
+          args.logger.error({err: startBot.failure});
+        }
+
+        const online = getConnected.filter(n => !!n);
+
+        return cbk(null, {
+          connected: startBot.connected,
+          online: getConnected.filter(n => !!n),
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'online'}, cbk));
+  });
+};