balanceofsatoshis 12.8.2 → 12.8.5

package/CHANGELOG.md

@@ -1,6 +1,10 @@
 # Versions
 
-## 12.8.2
+## 12.8.5
+
+- `telegram`: Fix error logging on /blocknotify
+
+## 12.8.4
 
 - `telegram`: Add safeguards to deal with errors on /graph command
 

package/README.md

@@ -499,7 +499,7 @@ On Umbrel this would be:
 ## --network="host"
 ## --add-host=umbrel.local:192.168.1.23
 ## -v $HOME/umbrel/lnd:/home/node/.lnd:ro
-docker run -it --rm --network="host" --add-host=umbrel.local:192.168.1.23 -v $HOME/.bos:/home/node/.bos -v $HOME/umbrel/lnd:/home/node/.lnd:ro alexbosworth/balanceofsatoshis report
+docker run -it --rm --network=umbrel_main_network --add-host=umbrel.local:192.168.1.23 -v $HOME/.bos:/home/node/.bos -v $HOME/umbrel/lnd:/home/node/.lnd:ro alexbosworth/balanceofsatoshis report
 ```
 
 Note: For [umbrel-os](https://github.com/getumbrel/umbrel-os) users, when

package/bos

@@ -42,6 +42,7 @@ const services = importLazy('./services');
 const {swapTypes} = commandConstants;
 const swaps = importLazy('./swaps');
 const telegram = importLazy('./telegram');
+const triggers = importLazy('./triggers');
 const wallets = importLazy('./wallets');
 const {version} = importLazy('./package');
 
@@ -1817,6 +1818,25 @@ prog
     });
   })
 
+  // Manage triggers
+  .command('triggers', 'Manage event triggers')
+  .option('--node <name>', 'Node to manage triggers on')
+  .visible(false)
+  .action((args, options, logger) => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        return triggers.manageTriggers({
+          logger,
+          ask: (n, cbk) => inquirer.prompt([n]).then(res => cbk(res)),
+          lnd: (await lndForNode(logger, options.node)).lnd,
+        },
+        responses.returnObject({exit, logger, reject, resolve}));
+      } catch (err) {
+        return logger.error({err}) && reject();
+      }
+    });
+  })
+
   // Unlock wallet
   .command('unlock', 'Unlock wallet if locked')
   .help('Check if the wallet is locked, if so use a password file to unlock')

package/package.json

@@ -36,7 +36,7 @@
     "ini": "3.0.0",
     "inquirer": "8.2.4",
     "ln-accounting": "5.0.6",
-    "ln-service": "53.16.0",
+    "ln-service": "53.17.0",
     "ln-sync": "3.12.0",
     "ln-telegram": "3.21.5",
     "moment": "2.29.3",
@@ -55,7 +55,7 @@
   "devDependencies": {
     "@alexbosworth/tap": "15.0.11",
     "invoices": "2.0.6",
-    "ln-docker-daemons": "2.2.10",
+    "ln-docker-daemons": "2.2.11",
     "mock-lnd": "1.4.1",
     "tiny-secp256k1": "2.2.1"
   },
@@ -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.8.2"
+  "version": "12.8.5"
 }

package/telegram/start_telegram_bot.js

@@ -211,7 +211,7 @@ module.exports = (args, cbk) => {
             reply: n => ctx.reply(n, markdown),
             request: args.request,
           },
-          err => !!err ? logger.error({err}) : null);
+          err => !!err ? args.logger.error({err}) : null);
         });
 
         // Handle command to get the connect id
@@ -335,7 +335,7 @@ module.exports = (args, cbk) => {
               });
             });
           } catch (err) {
-            args.logger.error(err);
+            args.logger.error({err});
           }
         });
 

package/triggers/create_connectivity_trigger.js

@@ -0,0 +1,59 @@
+const asyncAuto = require('async/auto');
+const {createInvoice} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const encodeTrigger = require('./encode_trigger');
+
+const daysAsMs = days => Number(days) * 1000 * 60 * 60 * 24;
+const defaultTriggerDays = 365;
+const futureDate = ms => new Date(Date.now() + ms).toISOString();
+
+/** Create a connectivity with peer trigger
+
+  {
+    id: <Node Id Public Key Hex String>
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = ({id, lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!id) {
+          return cbk([400, 'ExpectedNodeIdToCreateConnectivityTrigger']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedLndToCreateConnectivityTrigger']);
+        }
+
+        return cbk();
+      },
+
+      // Encode the trigger
+      description: ['validate', ({}, cbk) => {
+        try {
+          const {encoded} = encodeTrigger({connectivity: {id}});
+
+          return cbk(null, encoded);
+        } catch (err) {
+          return cbk([400, err.message]);
+        }
+      }],
+
+      // Add the trigger invoice
+      create: ['description', ({description}, cbk) => {
+        return createInvoice({
+          description,
+          lnd,
+          expires_at: futureDate(daysAsMs(defaultTriggerDays)),
+        },
+        cbk);
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/triggers/create_follow_node_trigger.js

@@ -0,0 +1,59 @@
+const asyncAuto = require('async/auto');
+const {createInvoice} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const encodeTrigger = require('./encode_trigger');
+
+const daysAsMs = days => Number(days) * 1000 * 60 * 60 * 24;
+const defaultTriggerDays = 365;
+const futureDate = ms => new Date(Date.now() + ms).toISOString();
+
+/** Create a follow node trigger
+
+  {
+    id: <Node Id Public Key Hex String>
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = ({id, lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!id) {
+          return cbk([400, 'ExpectedNodeIdToFollowToCreateFollowNodeTrigger']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedLndToCreateFollowNodeTrigger']);
+        }
+
+        return cbk();
+      },
+
+      // Encode the trigger
+      description: ['validate', ({}, cbk) => {
+        try {
+          const {encoded} = encodeTrigger({follow: {id}});
+
+          return cbk(null, encoded);
+        } catch (err) {
+          return cbk([400, err.message]);
+        }
+      }],
+
+      // Add the trigger invoice
+      create: ['description', ({description}, cbk) => {
+        return createInvoice({
+          description,
+          lnd,
+          expires_at: futureDate(daysAsMs(defaultTriggerDays)),
+        },
+        cbk);
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/triggers/decode_connectivity_params.js

@@ -0,0 +1,45 @@
+const {decodeTlvStream} = require('bolt01');
+
+const findRecord = (records, type) => records.find(n => n.type === type);
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const typeId = '1';
+const typeVersion = '0';
+
+/** Decode connectivity trigger parameters
+
+  {
+    parameters: <Encoded Parameters Hex String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    id: <Node Id Hex String>
+  }
+*/
+module.exports = ({parameters}) => {
+  if (!parameters) {
+    throw new Error('ExpectedEncodedParametersToDecodeConnectivityParameters');
+  }
+
+  const {records} = decodeTlvStream({encoded: parameters});
+
+  // Check the parameters version
+  if (!!findRecord(records, typeVersion)) {
+    throw new Error('UnexpectedVersionForEncodedConnectivityTrigger');
+  }
+
+  const idRecord = findRecord(records, typeId);
+
+  if (!idRecord) {
+    throw new Error('ExpectedNodePublicKeyForEncodedConnectivityTrigger');
+  }
+
+  if (!isPublicKey(idRecord.value)) {
+    throw new Error('ExpectedValidNodePublicKeyForEncodedConnectivityTrigger');
+  }
+
+  return {id: idRecord.value};
+};

package/triggers/decode_follow_params.js

@@ -0,0 +1,45 @@
+const {decodeTlvStream} = require('bolt01');
+
+const findRecord = (records, type) => records.find(n => n.type === type);
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const typeId = '1';
+const typeVersion = '0';
+
+/** Decode follow trigger parameters
+
+  {
+    parameters: <Encoded Parameters Hex String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    id: <Node Id Hex String>
+  }
+*/
+module.exports = ({parameters}) => {
+  if (!parameters) {
+    throw new Error('ExpectedEncodedParametersToDecodeFollowParameters');
+  }
+
+  const {records} = decodeTlvStream({encoded: parameters});
+
+  // Check the parameters version
+  if (!!findRecord(records, typeVersion)) {
+    throw new Error('UnexpectedVersionForEncodedTrigger');
+  }
+
+  const idRecord = findRecord(records, typeId);
+
+  if (!idRecord) {
+    throw new Error('ExpectedNodePublicKeyForEncodedTrigger');
+  }
+
+  if (!isPublicKey(idRecord.value)) {
+    throw new Error('ExpectedValidNodePublicKeyForEncodedTrigger');
+  }
+
+  return {id: idRecord.value};
+};

package/triggers/decode_trigger.js

@@ -0,0 +1,81 @@
+const {decodeTlvStream} = require('bolt01');
+
+const decodeConnectivityParams = require('./decode_connectivity_params');
+const decodeFollowParams = require('./decode_follow_params');
+
+const base64AsHex = base64 => Buffer.from(base64, 'base64').toString('hex');
+const defaultMethodRecord = {value: '00'};
+const defaultVersionRecord = {value: '00'};
+const findRecord = (records, type) => records.find(n => n.type === type);
+const knownVersions = ['00', '01'];
+const methodConnectivity = '01';
+const methodFollow = '00';
+const triggerPrefix = 'bos-trigger:';
+const typeMethod = '1';
+const typeParams = '2';
+const typeVersion = '0';
+
+/** Decode an encoded trigger
+
+  {
+    encoded: <Encoded Trigger String>
+  }
+
+  @throws <Error>
+
+  @returns
+  {
+    [connectivity]: {
+      id: <Node Id Hex String>
+    }
+    [follow]: {
+      id: <Node Id Hex String>
+    }
+  }
+*/
+module.exports = ({encoded}) => {
+  if (!encoded) {
+    throw new Error('ExpectedEncodedTriggerToDecode');
+  }
+
+  if (!encoded.startsWith(triggerPrefix)) {
+    throw new Error('ExpectedTriggerPrefixForEncodedPrefix');
+  }
+
+  const data = base64AsHex(encoded.slice(triggerPrefix.length));
+
+  const {records} = decodeTlvStream({encoded: data});
+
+  const version = findRecord(records, typeVersion) || defaultVersionRecord;
+
+  // Check the trigger version
+  if (!knownVersions.includes(version.value)) {
+    throw new Error('UnexpectedVersionForEncodedTrigger');
+  }
+
+  const methodRecord = findRecord(records, typeMethod) || defaultMethodRecord;
+
+  // Trigger parameters are encoded into a stream record
+  const parametersRecord = findRecord(records, typeParams);
+
+  if (!parametersRecord) {
+    throw new Error('ExpectedParametersForTrigger');
+  }
+
+  const parameters = parametersRecord.value;
+
+  switch (methodRecord.value) {
+  case methodConnectivity:
+    const connectivity = decodeConnectivityParams({parameters});
+
+    return {connectivity};
+
+  case methodFollow:
+    const follow = decodeFollowParams({parameters});
+
+    return {follow};
+
+  default:
+    throw new Error('UnrecognizedMethodTypeForTrigger');
+  }
+};

package/triggers/encode_connectivity_params.js

@@ -0,0 +1,29 @@
+const {encodeTlvStream} = require('bolt01');
+
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const typeNodeId = '1';
+
+/** Encode the connectivity with node params
+
+  [0]: <Version>
+  1: <Node Id>
+
+  {
+    id: <Node Identity Public Key Hex String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    encoded: <Trigger Parameters Hex String>
+  }
+*/
+module.exports = ({id}) => {
+  if (!isPublicKey(id)) {
+    throw new Error('ExpectedPublicKeyToEncodeConnectivityParams');
+  }
+
+  return encodeTlvStream({records: [{type: typeNodeId, value: id}]});
+};

package/triggers/encode_follow_params.js

@@ -0,0 +1,29 @@
+const {encodeTlvStream} = require('bolt01');
+
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const typeNodeId = '1';
+
+/** Encode the follow node params
+
+  [0]: <Version>
+  1: <Node Id>
+
+  {
+    id: <Node Identity Public Key Hex String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    encoded: <Trigger Parameters Hex String>
+  }
+*/
+module.exports = ({id}) => {
+  if (!isPublicKey(id)) {
+    throw new Error('ExpectedPublicKeyToEncodeFollowParams');
+  }
+
+  return encodeTlvStream({records: [{type: typeNodeId, value: id}]});
+};

package/triggers/encode_trigger.js

@@ -0,0 +1,73 @@
+const {encodeTlvStream} = require('bolt01');
+
+const encodeConnectivityParams = require('./encode_connectivity_params');
+const encodeFollowParams = require('./encode_follow_params');
+
+const hexAsBase64 = hex => Buffer.from(hex, 'hex').toString('base64');
+const methodConnectivity = '01';
+const triggerPrefix = 'bos-trigger:';
+const typeTriggerMethod = '1';
+const typeTriggerParameters = '2';
+const typeVersion = '0';
+const version = '01';
+
+/** Encode a trigger
+
+  [0]: <Version>
+  [1]: <Method>
+  [2]: <Parameters>
+
+  {
+    [connectivity]: {
+      id: <Node Id Hex String>
+    }
+    [follow]: {
+      id: <Node Id Hex String>
+    }
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    encoded: <Encoded Trigger String>
+  }
+*/
+module.exports = ({connectivity, follow}) => {
+  if (!connectivity && !follow) {
+    throw new Error('ExpectedConnectivityOrFollowDetailsToEncodeTrigger');
+  }
+
+  if (!!connectivity) {
+    // Encode the trigger parameters for a connectivity trigger
+    const {encoded} = encodeTlvStream({
+      records: [
+        {
+          type: typeTriggerMethod,
+          value: methodConnectivity,
+        },
+        {
+          type: typeTriggerParameters,
+          value: encodeConnectivityParams({id: connectivity.id}).encoded,
+        },
+        {
+          type: typeVersion,
+          value: version,
+        },
+      ],
+    });
+
+    return {encoded: `${triggerPrefix}${hexAsBase64(encoded)}`};
+  }
+
+  // Encode the trigger parameters for a follow trigger
+  const {encoded} = encodeTlvStream({
+    records: [{
+      type: typeTriggerParameters,
+      value: encodeFollowParams({id: follow.id}).encoded,
+    }],
+  });
+
+  return {encoded: `${triggerPrefix}${hexAsBase64(encoded)}`};
+};

package/triggers/get_triggers.js

@@ -0,0 +1,93 @@
+const asyncAuto = require('async/auto');
+const asyncUntil = require('async/until');
+const {getInvoices} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const decodeTrigger = require('./decode_trigger');
+
+const defaultInvoicesLimit = 100;
+
+/** Get registered triggers
+
+  {
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    triggers: [{
+      [connectivity]: {
+        id: <Node Identity Public Key Hex String>
+      }
+      [follow]: {
+        id: <Node Identity Public Key Hex String>
+      }
+      id: <Trigger Id Hex String>
+    }]
+  }
+*/
+module.exports = ({lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToGetTriggers']);
+        }
+
+        return cbk();
+      },
+
+      // Get the past triggers
+      getTriggers: ['validate', ({}, cbk) => {
+        let token;
+        const triggers = [];
+
+        // Register past trigger invoices
+        return asyncUntil(
+          cbk => cbk(null, token === false),
+          cbk => {
+            return getInvoices({
+              lnd,
+              token,
+              is_unconfirmed: true,
+              limit: !token ? defaultInvoicesLimit : undefined,
+            },
+            (err, res) => {
+              if (!!err) {
+                return cbk(err);
+              }
+
+              token = res.next || false;
+
+              res.invoices.forEach(({description, id}) => {
+                try {
+                  const trigger = decodeTrigger({encoded: description});
+
+                  return triggers.push({
+                    id,
+                    connectivity: trigger.connectivity,
+                    follow: trigger.follow,
+                  });
+                } catch (err) {
+                  // Ignore invoices that are not triggers
+                  return;
+                }
+              });
+
+              return cbk();
+            });
+          },
+          err => {
+            if (!!err) {
+              return cbk(err);
+            }
+
+            return cbk(null, triggers);
+          },
+        );
+      }],
+    },
+    returnResult({reject, resolve, of: 'getTriggers'}, cbk));
+  });
+};

package/triggers/index.js

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

package/triggers/manage_triggers.js

@@ -0,0 +1,243 @@
+const asyncAuto = require('async/auto');
+const {cancelHodlInvoice} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const createConnectivityTrigger = require('./create_connectivity_trigger');
+const createFollowNodeTrigger = require('./create_follow_node_trigger');
+const getTriggers = require('./get_triggers');
+const subscribeToTriggers = require('./subscribe_to_triggers');
+
+const actionAddConnectivityTrigger = 'action-add-connectivity-trigger';
+const actionAddFollowTrigger = 'action-add-follow-trigger';
+const actionDeleteTrigger = 'action-delete-trigger';
+const actionListTriggers = 'action-list-triggers';
+const actionSubscribeToTriggers = 'action-subscribe-to-triggers';
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+
+/** Manage trigger actions
+
+  {
+    ask: <Ask Function>
+    lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = ({ask, lnd, logger}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!ask) {
+          return cbk([400, 'ExpectedAskFunctionToManageTriggers']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToManageTriggers']);
+        }
+
+        if (!logger) {
+          return cbk([400, 'ExpectedWinstonLoggerToManageTriggers']);
+        }
+
+        return cbk();
+      },
+
+      // Select trigger action
+      selectAction: ['validate', ({}, cbk) => {
+        return ask({
+          choices: [
+            {
+              name: 'Add Node Connectivity Trigger',
+              value: actionAddConnectivityTrigger,
+            },
+            {
+              name: 'Add Follow Node Trigger',
+              value: actionAddFollowTrigger,
+            },
+            {
+              name: 'View Triggers',
+              value: actionListTriggers,
+            },
+            {
+              name: 'Subscribe to Triggers',
+              value: actionSubscribeToTriggers,
+            },
+          ],
+          message: 'Trigger action?',
+          name: 'action',
+          type: 'list',
+        },
+        ({action}) => cbk(null, action));
+      }],
+
+      // Ask for details about a new connectivity trigger
+      askForConnectivityTrigger: ['selectAction', ({selectAction}, cbk) => {
+        // Exit early when not adding a trigger
+        if (selectAction !== actionAddConnectivityTrigger) {
+          return cbk();
+        }
+
+        return ask({
+          message: 'Node public key to watch connectivity with?',
+          name: 'id',
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            if (!isPublicKey(input)) {
+              return 'Enter a node identity public key';
+            }
+
+            return true;
+          },
+        },
+        ({id}) => cbk(null, id));
+      }],
+
+      // Ask for details about a new follow trigger
+      askForFollowTrigger: ['selectAction', ({selectAction}, cbk) => {
+        // Exit early when not adding a trigger
+        if (selectAction !== actionAddFollowTrigger) {
+          return cbk();
+        }
+
+        return ask({
+          message: 'Node public key to follow?',
+          name: 'id',
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            if (!isPublicKey(input)) {
+              return 'Enter a node identity public key to follow';
+            }
+
+            return true;
+          },
+        },
+        ({id}) => cbk(null, id));
+      }],
+
+      // Get the list of triggers
+      getTriggers: ['selectAction', ({selectAction}, cbk) => {
+        // Exit early when not listing triggers
+        if (selectAction !== actionListTriggers) {
+          return cbk();
+        }
+
+        logger.info({finding_triggers: true});
+
+        return getTriggers({lnd}, cbk);
+      }],
+
+      // Subscribe to triggers
+      subscribeToTriggers: ['selectAction', ({selectAction}, cbk) => {
+        // Exit early when not subscribing
+        if (selectAction !== actionSubscribeToTriggers) {
+          return cbk();
+        }
+
+        const sub = subscribeToTriggers({lnds: [lnd]});
+
+        sub.on('channel_opened', opened => logger.info({opened}));
+        sub.on('peer_connected', connected => logger.info({connected}));
+        sub.on('peer_disconnected', disconnect => logger.info({disconnect}));
+        sub.on('error', err => cbk(err));
+
+        return logger.info({listening_for_trigger_events: true});
+      }],
+
+      // Create a new connectivity trigger
+      createConnectivityTrigger: [
+        'askForConnectivityTrigger',
+        ({askForConnectivityTrigger}, cbk) =>
+      {
+        if (!askForConnectivityTrigger) {
+          return cbk();
+        }
+
+        return createConnectivityTrigger({
+          lnd,
+          id: askForConnectivityTrigger,
+        },
+        cbk);
+      }],
+
+      // Create a new follow trigger
+      createFollowTrigger: [
+        'askForFollowTrigger',
+        ({askForFollowTrigger}, cbk) =>
+      {
+        if (!askForFollowTrigger) {
+          return cbk();
+        }
+
+        return createFollowNodeTrigger({lnd, id: askForFollowTrigger}, cbk);
+      }],
+
+      // Select a trigger from the list
+      selectTrigger: ['getTriggers', ({getTriggers}, cbk) => {
+        if (!getTriggers) {
+          return cbk();
+        }
+
+        if (!getTriggers.length) {
+          return cbk([404, 'NoTriggersFound']);
+        }
+
+        return ask({
+          choices: getTriggers.map(({connectivity, follow, id}) => {
+            if (!!connectivity) {
+              return {
+                name: `Connectivity with ${connectivity.id}`,
+                value: id,
+              };
+            } else {
+              return {
+                name: `Following ${follow.id}`,
+                value: id,
+              };
+            }
+          }),
+          message: 'Triggers:',
+          name: 'view',
+          type: 'list',
+        },
+        ({view}) => cbk(null, view));
+      }],
+
+      // Trigger actions
+      triggerAction: ['selectTrigger', ({selectTrigger}, cbk) => {
+        // Exit early when no trigger is selected to take actions against
+        if (!selectTrigger) {
+          return cbk();
+        }
+
+        return ask({
+          choices: [{name: 'Delete Trigger', value: actionDeleteTrigger}],
+          message: 'Action?',
+          name: 'modify',
+          type: 'list',
+        },
+        ({modify}) => cbk(null, selectTrigger));
+      }],
+
+      // Delete a trigger
+      deleteTrigger: ['triggerAction', ({triggerAction}, cbk) => {
+        // Exit early when not deleting a triger
+        if (!triggerAction) {
+          return cbk();
+        }
+
+        return cancelHodlInvoice({lnd, id: triggerAction}, cbk);
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/triggers/subscribe_to_triggers.js

@@ -0,0 +1,232 @@
+const EventEmitter = require('events');
+
+const asyncUntil = require('async/until');
+const {decodeChanId} = require('bolt07');
+const {getHeight} = require('ln-service');
+const {getInvoices} = require('ln-service');
+const {subscribeToGraph} = require('ln-service');
+const {subscribeToInvoice} = require('ln-service');
+const {subscribeToInvoices} = require('ln-service');
+const {subscribeToPeers} = require('ln-service');
+
+const decodeTrigger = require('./decode_trigger');
+
+const defaultInvoicesLimit = 100;
+const {keys} = Object;
+
+/** Subscribe to trigger events
+
+  {
+    lnds: <Authenticated LND API Object>
+  }
+
+  @event 'channel_opened'
+  {
+    [capacity]: <Channel Token Capacity Number>
+    id: <Standard Format Channel Id String>
+    public_keys: [<Announcing Public Key>, <Target Public Key String>]
+  }
+
+  @event 'peer_connected'
+  {
+    public_key: <Node Identity Public Key Hex String>
+  }
+
+  @event 'peer_disconnected'
+  {
+    public_key: <Node Identity Public Key Hex String>
+  }
+
+  @returns
+  <Event Emitter Object>
+*/
+module.exports = ({lnds}) => {
+  const channels = new Set();
+  const emitter = new EventEmitter();
+  const subs = [];
+  const triggers = {};
+
+  // Stop subscription when listeners are removed
+  emitter.on('removeListener', () => {
+    if (!!emitter.listenerCount('channel_opened')) {
+      return;
+    }
+
+    return cbk([400, 'RemovedAllListeners']);
+  });
+
+  // Clean up when there is an error
+  const errored = err => {
+    subs.forEach(n => n.removeAllListeners());
+
+    if (!emitter.listenerCount('error')) {
+      return;
+    }
+
+    return emitter.emit('error', err);
+  };
+
+  // Register trigger if present
+  const register = ({description, id}, lnd) => {
+    try {
+      decodeTrigger({encoded: description});
+    } catch (err) {
+      // Exit early when the invoice is not a trigger invoice
+      return;
+    }
+
+    triggers[id] = decodeTrigger({encoded: description});
+
+    // Listen for the trigger invoice to be canceled to stop it
+    const sub = subscribeToInvoice({id, lnd});
+
+    subs.push(sub);
+
+    // Listen for an error on the invoice
+    sub.on('error', err => errored(err));
+
+    // Listen for the trigger to get canceled
+    sub.on('invoice_updated', invoice => {
+      if (!invoice.is_canceled) {
+        return;
+      }
+
+      delete triggers[invoice.id];
+    });
+
+    return;
+  };
+
+  lnds.forEach(lnd => {
+    const graphSub = subscribeToGraph({lnd});
+    const invoicesSub = subscribeToInvoices({lnd});
+    const peersSub = subscribeToPeers({lnd});
+    let startHeight;
+    let token;
+
+    subs.push(graphSub);
+    subs.push(invoicesSub);
+    subs.push(peersSub);
+
+    getHeight({lnd}, (err, res) => {
+      if (!!err) {
+        return errored(err);
+      }
+
+      return startHeight = res.current_block_height;
+    });
+
+    // Listen for errors on the invoices subscription
+    invoicesSub.on('error', err => errored(err));
+
+    // Listen for new trigger invoices
+    invoicesSub.on('invoice_updated', updated => register(updated, lnd));
+
+    // Listen for errors on the graph subscription
+    graphSub.on('error', err => errored(err));
+
+    // Listen for updates to a channel that may match a trigger
+    graphSub.on('channel_updated', (update, cbk) => {
+      // Exit early when start height is not known yet
+      if (!startHeight) {
+        return;
+      }
+
+      // Exit early when the channel exists in the set
+      if (channels.has(update.id)) {
+        return;
+      }
+
+      // See if the channel matches a relevant trigger
+      const follows = keys(triggers)
+        .filter(id => !!triggers[id].follow)
+        .filter(id => update.public_keys.includes(triggers[id].follow.id));
+
+      // Exit early when this channel doesn't match any follow trigger
+      if (!follows.length) {
+        return;
+      }
+
+      const height = decodeChanId({channel: update.id}).block_height;
+
+      // Exit early when the channel id is less than the start height
+      if (height < startHeight) {
+        return;
+      }
+
+      // Mark new channel as announced
+      channels.add(update.id);
+
+      // This is a new channel that confirmed after the start height
+      return emitter.emit('channel_opened', {
+        capacity: update.capacity,
+        id: update.id,
+        public_keys: update.public_keys,
+      });
+    });
+
+    // Listen for errors on the peers subscription
+    peersSub.on('error', err => errored(err));
+
+    // Listen for connected peers subscription
+    peersSub.on('connected', (update, cbk) => {
+      const id = update.public_key;
+
+      // See if the peer matches a relevant trigger
+      const follows = keys(triggers)
+        .filter(id => !!triggers[id].connectivity)
+        .filter(id => update.public_key === triggers[id].connectivity.id);
+
+      // Exit early when this peer doesn't match any connectivity trigger
+      if (!follows.length) {
+        return;
+      }
+
+      return emitter.emit('peer_connected', update);
+    });
+
+    // Listen for disconnected peers subscription
+    peersSub.on('disconnected', (update, cbk) => {
+      const id = update.public_key;
+
+      // See if the peer matches a relevant trigger
+      const follows = keys(triggers)
+        .filter(id => !!triggers[id].connectivity)
+        .filter(id => update.public_key === triggers[id].connectivity.id);
+
+      // Exit early when this peer doesn't match any connectivity trigger
+      if (!follows.length) {
+        return;
+      }
+
+      return emitter.emit('peer_disconnected', update);
+    });
+
+    // Register past trigger invoices
+    asyncUntil(
+      cbk => cbk(null, token === false),
+      cbk => {
+        return getInvoices({
+          lnd,
+          token,
+          is_unconfirmed: true,
+          limit: !token ? defaultInvoicesLimit : undefined,
+        },
+        (err, res) => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          token = res.next || false;
+
+          res.invoices.forEach(invoice => register(invoice, lnd));
+
+          return cbk();
+        });
+      },
+      err => !!err ? errored(err) : null,
+    );
+  });
+
+  return emitter;
+};