astra-lightning 1.0.0

package/test/lnd_methods/offchain/test_subscribe_to_backups.js

@@ -0,0 +1,117 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const EventEmitter = require('node:events');
+const {promisify} = require('node:util');
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const {subscribeToBackups} = require('./../../../');
+
+const nextTick = promisify(process.nextTick);
+
+const makeLnd = ({data, err}) => {
+  return {
+    default: {
+      subscribeChannelBackups: ({}) => {
+        const emitter = new EventEmitter();
+
+        emitter.cancel = () => {};
+
+        process.nextTick(() => {
+          emitter.emit('data', data || {
+            single_chan_backups: {
+              chan_backups: [{
+                chan_backup: Buffer.alloc(1),
+                chan_point: {
+                  funding_txid_bytes: Buffer.alloc(32),
+                  output_index: 0,
+                },
+              }],
+            },
+            multi_chan_backup: {
+              chan_points: [{
+                funding_txid_bytes: Buffer.alloc(32),
+                output_index: 0,
+              }],
+              multi_chan_backup: Buffer.alloc(1),
+            },
+          });
+
+          emitter.emit('status', {status: 'status'});
+          emitter.emit('end', {});
+          emitter.emit('error', {details: 'Cancelled on client'});
+
+          return;
+        });
+
+        return emitter;
+      },
+    },
+  };
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'An LND object is required to subscribe to channels',
+    error: 'ExpectedAuthenticatedLndToSubscribeToBackups',
+  },
+  {
+    args: {lnd: makeLnd({data: 'data'})},
+    description: 'An error event is triggered when getting an invalid backup',
+    expected: {
+      events: [
+        {event: 'error', data: [503, 'ExpectedMultiChannelBackupInSnapshot']},
+        {event: 'error', data: {details: 'Cancelled on client'}}
+      ],
+    },
+  },
+  {
+    args: {lnd: makeLnd({})},
+    description: 'Channel events are returned from channels subscription',
+    expected: {
+      events: [
+        {
+          event: 'backup',
+          data: {
+            backup: '00',
+            channels: [{
+              backup: '00',
+              transaction_id: '0000000000000000000000000000000000000000000000000000000000000000',
+              transaction_vout: 0,
+            }],
+          },
+        },
+        {event: 'error', data: {details: 'Cancelled on client'}},
+      ],
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      throws(() => subscribeToBackups(args), new Error(error), 'Got error');
+    } else {
+      const events = [];
+      const sub = subscribeToBackups(args);
+
+      ['backup', 'error',].forEach(event => {
+        return sub.on(event, data => events.push({event, data}));
+      });
+
+      await nextTick();
+
+      sub.removeAllListeners('error');
+
+      sub.removeAllListeners();
+
+      const sub2 = subscribeToBackups(args);
+
+      await nextTick();
+
+      deepStrictEqual(events, expected.events);
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/offchain/test_subscribe_to_channels.js

@@ -0,0 +1,333 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const EventEmitter = require('node:events');
+const {promisify} = require('node:util');
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const {subscribeToChannels} = require('./../../../');
+
+const nextTick = promisify(process.nextTick);
+
+const makeLnd = ({data, err}) => {
+  return {
+    default: {
+      subscribeChannelEvents: ({}) => {
+        const emitter = new EventEmitter();
+
+        emitter.cancel = () => {};
+
+        process.nextTick(() => {
+          if (data !== undefined) {
+            return emitter.emit('data', data);
+          }
+
+          emitter.emit('data', {data: {}, type: 'data'});
+
+          emitter.emit('data', {
+            active_channel: {
+              funding_txid_bytes: Buffer.alloc(32),
+              output_index: 0,
+            },
+            type: 'active_channel',
+          });
+
+          emitter.emit('data', {
+            closed_channel: {
+              alias_scids: [],
+              capacity: '1',
+              chan_id: '1',
+              channel_point: '00:0',
+              close_height: 1,
+              closing_tx_hash: Buffer.alloc(32).toString('hex'),
+              open_initiator: 'LOCAL',
+              remote_pubkey: Buffer.alloc(33).toString('hex'),
+              resolutions: [],
+              settled_balance: '1',
+              time_locked_balance: '1',
+            },
+            type: 'closed_channel',
+          });
+
+          emitter.emit('data', {
+            inactive_channel: {
+              funding_txid_bytes: Buffer.alloc(32),
+              output_index: 0,
+            },
+            type: 'inactive_channel',
+          });
+
+          emitter.emit('data', {
+            open_channel: {
+              active: false,
+              alias_scids: [],
+              capacity: '1',
+              chan_id: '1',
+              channel_point: `${Buffer.alloc(32).toString('hex')}:0`,
+              chan_status_flags: 'ChanStatusDefault',
+              close_address: '',
+              commit_fee: '1',
+              commit_weight: '1',
+              commitment_type: 'ANCHORS',
+              csv_delay: 1,
+              fee_per_kw: '1',
+              initiator: true,
+              lifetime: 1,
+              local_balance: '1',
+              local_chan_reserve_sat: '1',
+              local_constraints: {
+                chan_reserve_sat: '1',
+                csv_delay: 1,
+                dust_limit_sat: '1',
+                max_accepted_htlcs: 1,
+                max_pending_amt_msat: '1',
+                min_htlc_msat: '1',
+              },
+              num_updates: '1',
+              pending_htlcs: [],
+              private: false,
+              push_amount_sat: '1',
+              remote_balance: '1',
+              remote_chan_reserve_sat: '1',
+              remote_constraints: {
+                chan_reserve_sat: '1',
+                csv_delay: 1,
+                dust_limit_sat: '1',
+                max_accepted_htlcs: 1,
+                max_pending_amt_msat: '1',
+                min_htlc_msat: '1',
+              },
+              remote_pubkey: Buffer.alloc(33).toString('hex'),
+              static_remote_key: false,
+              thaw_height: 0,
+              total_satoshis_received: '1',
+              total_satoshis_sent: '1',
+              unsettled_balance: '1',
+              uptime: 1,
+            },
+            type: 'open_channel',
+          });
+
+          emitter.emit('data', {
+            pending_open_channel: {
+              funding_txid_bytes: Buffer.alloc(32),
+              output_index: 0,
+            },
+            type: 'pending_open_channel',
+          });
+
+          emitter.emit('status', {status: 'status'});
+          emitter.emit('end', {});
+          emitter.emit('error', {details: 'Cancelled'});
+
+          return;
+        });
+
+        return emitter;
+      },
+    },
+    version: {
+      getVersion: ({}, cbk) => cbk(err, {
+        app_minor: 1,
+        app_patch: 1,
+        build_tags: ['autopilotrpc'],
+        commit_hash: Buffer.alloc(20).toString('hex'),
+      }),
+    },
+  };
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'An LND object is required to subscribe to channels',
+    error: 'ExpectedAuthenticatedLndToSubscribeToChannels',
+  },
+  {
+    args: {lnd: makeLnd({data: null})},
+    description: 'Channel data is expected',
+    expected: {
+      events: [{
+        data: new Error('ExpectedEventDetailsInChannelSubscription'),
+        event: 'error',
+      }],
+    },
+  },
+  {
+    args: {lnd: makeLnd({data: {}})},
+    description: 'Channel data type is expected',
+    expected: {
+      events: [{
+        data: new Error('ExpectedEventTypeInChannelSubscription'),
+        event: 'error',
+      }],
+    },
+  },
+  {
+    args: {lnd: makeLnd({data: {type: 1}})},
+    description: 'Channel data type string is expected',
+    expected: {
+      events: [{
+        data: new Error('ExpectedEventTypeInChannelSubscription'),
+        event: 'error',
+      }],
+    },
+  },
+  {
+    args: {lnd: makeLnd({data: {type: 'event'}})},
+    description: 'Channel data details are expected',
+    expected: {
+      events: [{
+        data: new Error('ExpectedEventDetailsForTypeInChannelSub'),
+        event: 'error',
+      }],
+    },
+  },
+  {
+    args: {lnd: makeLnd({data: {active_channel: {}, type: 'active_channel'}})},
+    description: 'Channel data details are expected',
+    expected: {
+      events: [{
+        data: new Error('ExpectedTransactionIdBufferForRpcOutpoint'),
+        event: 'error',
+      }],
+    },
+  },
+  {
+    args: {lnd: makeLnd({})},
+    description: 'Channel events are returned from channels subscription',
+    expected: {
+      events: [
+        {
+          event: 'channel_active_changed',
+          data: {
+            is_active: true,
+            transaction_id: '0000000000000000000000000000000000000000000000000000000000000000',
+            transaction_vout: 0,
+          },
+        },
+        {
+          event: 'channel_closed',
+          data: {
+            capacity: 1,
+            close_balance_spent_by: undefined,
+            close_balance_vout: undefined,
+            close_confirm_height: 1,
+            close_payments: [],
+            close_transaction_id: undefined,
+            final_local_balance: 1,
+            final_time_locked_balance: 1,
+            id: '0x0x1',
+            is_breach_close: false,
+            is_cooperative_close: false,
+            is_funding_cancel: false,
+            is_local_force_close: false,
+            is_partner_closed: undefined,
+            is_partner_initiated: false,
+            is_remote_force_close: false,
+            other_ids: [],
+            partner_public_key: '000000000000000000000000000000000000000000000000000000000000000000',
+            transaction_id: '00',
+            transaction_vout: 0,
+          },
+        },
+        {
+          event: 'channel_active_changed',
+          data: {
+            is_active: false,
+            transaction_id: '0000000000000000000000000000000000000000000000000000000000000000',
+            transaction_vout: 0,
+          },
+        },
+        {
+          event: 'channel_opened',
+          data: {
+            capacity: 1,
+            commit_transaction_fee: 1,
+            commit_transaction_weight: 1,
+            cooperative_close_address: undefined,
+            cooperative_close_delay_height: undefined,
+            description: undefined,
+            id: '0x0x1',
+            is_active: false,
+            is_closing: false,
+            is_opening: false,
+            is_partner_initiated: false,
+            is_private: false,
+            is_trusted_funding: undefined,
+            local_balance: 1,
+            local_csv: 1,
+            local_dust: 1,
+            local_given: 1,
+            local_max_htlcs: 1,
+            local_max_pending_mtokens: '1',
+            local_min_htlc_mtokens: '1',
+            local_reserve: 1,
+            other_ids: [],
+            partner_public_key: '000000000000000000000000000000000000000000000000000000000000000000',
+            past_states: 1,
+            pending_payments: [],
+            received: 1,
+            remote_balance: 1,
+            remote_csv: 1,
+            remote_dust: 1,
+            remote_given: 0,
+            remote_max_htlcs: 1,
+            remote_max_pending_mtokens: '1',
+            remote_min_htlc_mtokens: '1',
+            remote_reserve: 1,
+            sent: 1,
+            time_offline: 0,
+            time_online: 1000,
+            transaction_id: '0000000000000000000000000000000000000000000000000000000000000000',
+            transaction_vout: 0,
+            type: 'anchor',
+            unsettled_balance: 1,
+          },
+        },
+        {
+          event: 'channel_opening',
+          data: {
+            transaction_id: '0000000000000000000000000000000000000000000000000000000000000000',
+            transaction_vout: 0,
+          },
+        },
+        {
+          data: {details: 'Cancelled'},
+          event: 'error',
+        },
+      ],
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      throws(() => subscribeToChannels(args), new Error(error), 'Got error');
+    } else {
+      const events = [];
+      const sub = subscribeToChannels(args);
+
+      [
+        'channel_active_changed',
+        'channel_closed',
+        'channel_opened',
+        'channel_opening',
+        'error',
+      ]
+      .forEach(event => sub.on(event, data => events.push({event, data})));
+
+      await nextTick();
+
+      sub.removeAllListeners();
+
+      const sub2 = subscribeToChannels(args);
+
+      await nextTick();
+
+      deepStrictEqual(events, expected.events);
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/offchain/test_subscribe_to_forwards.js

@@ -0,0 +1,104 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const EventEmitter = require('node:events');
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const {subscribeToForwards} = require('./../../../');
+
+const emitter = new EventEmitter();
+
+emitter.cancel = () => {};
+
+const makeForwardResponse = () => {
+  return {
+    event_type: 'UNKNOWN',
+    incoming_channel_id: '1',
+    incoming_htlc_id: '0',
+    outgoing_channel_id: '2',
+    outgoing_htlc_id: '1',
+    settle_event: {preimage: Buffer.alloc(0)},
+    timestamp_ns: (1e6).toString(),
+  };
+};
+
+const makeLnd = ({err}) => {
+  return {router: {subscribeHtlcEvents: ({}) => emitter}};
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'An LND object is required to subscribe to forwards',
+    error: 'ExpectedAuthenticatedLndToSubscribeToForwards',
+  },
+  {
+    args: {lnd: makeLnd({})},
+    description: 'An LND object is required to subscribe to forwards',
+    expected: {
+      forward: {
+        at: '1970-01-01T00:00:00.001Z',
+        cltv_delta: undefined,
+        external_failure: undefined,
+        fee: undefined,
+        fee_mtokens: undefined,
+        in_channel: '0x0x1',
+        in_payment: 0,
+        internal_failure: undefined,
+        is_confirmed: true,
+        is_failed: false,
+        is_receive: false,
+        is_send: false,
+        mtokens: undefined,
+        out_channel: '0x0x2',
+        out_payment: 1,
+        secret: undefined,
+        timeout: undefined,
+        tokens: undefined,
+      },
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => subscribeToForwards(args), new Error(error), 'Got error');
+    } else {
+      let gotEnd;
+      let gotErr;
+      let gotErr2 = null;
+      let gotForward;
+      let gotStatus;
+      const sub = subscribeToForwards(args);
+
+      sub.on('end', () => gotEnd = true);
+      sub.on('error', err => gotErr = err);
+      sub.on('forward', forward => gotForward = forward);
+      sub.on('status', status => gotStatus = status);
+
+      emitter.emit('end', {});
+      emitter.emit('error', new Error('error'));
+
+      sub.removeAllListeners('error');
+
+      const sub2 = subscribeToForwards(args);
+
+      sub2.on('error', err => gotErr3 = err);
+      sub2.on('forward', forward => gotForward = forward);
+
+      emitter.emit('data', {});
+
+      const forwardErr = 'ExpectedHtlcEventTypeToDeriveForwardFromHtlcEvent';
+
+      deepStrictEqual(gotErr3, [503, forwardErr], 'Got forward event error');
+
+      emitter.emit('data', makeForwardResponse({}));
+
+      deepStrictEqual(gotForward, expected.forward, 'Got expected forward');
+
+      [sub, sub2].forEach(n => n.removeAllListeners());
+    }
+
+    return end();
+  });
+});

package/test/lnd_methods/offchain/test_subscribe_to_open_requests.js

@@ -0,0 +1,144 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const EventEmitter = require('node:events');
+const {promisify} = require('node:util');
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const {subscribeToOpenRequests} = require('./../../../');
+
+const nextTick = promisify(process.nextTick);
+
+const makeLnd = ({data, err}) => {
+  return {
+    default: {
+      channelAcceptor: ({}) => {
+        const emitter = new EventEmitter();
+
+        emitter.cancel = () => {};
+        emitter.write = () => {};
+
+        process.nextTick(() => {
+          emitter.emit('data', data || {
+            chain_hash: Buffer.alloc(32),
+            channel_flags: 34,
+            channel_reserve: '1',
+            commitment_type: 'LEGACY',
+            csv_delay: 1,
+            dust_limit: '1',
+            fee_per_kw: '1000',
+            funding_amt: '1',
+            max_accepted_htlcs: 1,
+            max_value_in_flight: '1000',
+            min_htlc: '1000',
+            node_pubkey: Buffer.alloc(33, 3),
+            pending_chan_id: Buffer.alloc(32),
+            push_amt: '1000',
+          });
+
+          emitter.emit('status', {status: 'status'});
+          emitter.emit('end', {});
+          emitter.emit('error', {details: 'Cancelled on client'});
+
+          return;
+        });
+
+        return emitter;
+      },
+    },
+  };
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'An LND object is required to subscribe to open requests',
+    error: 'ExpectedLndToSubscribeToChannelRequests',
+  },
+  {
+    args: {lnd: makeLnd({data: 'data'})},
+    description: 'An error event is triggered when getting an invalid request',
+    expected: {
+      events: [
+        {
+          event: 'error',
+          data: [503, 'ExpectedChainHashForChannelOpenRequest']
+        },
+        {
+          event: 'error',
+          data: {details: 'Cancelled on client'},
+        },
+      ],
+    },
+  },
+  {
+    args: {lnd: makeLnd({})},
+    description: 'Channel open request events are returned',
+    expected: {
+      events: [
+        {
+          event: 'channel_request',
+          data: {
+            capacity: 1,
+            chain: '0000000000000000000000000000000000000000000000000000000000000000',
+            commit_fee_tokens_per_vbyte: 4,
+            csv_delay: 1,
+            id: '0000000000000000000000000000000000000000000000000000000000000000',
+            is_private: true,
+            is_trusted_funding: false,
+            local_balance: 1,
+            local_reserve: 1,
+            max_pending_mtokens: '1000',
+            max_pending_payments: 1,
+            min_chain_output: 1,
+            min_htlc_mtokens: '1000',
+            partner_public_key: '030303030303030303030303030303030303030303030303030303030303030303',
+            type: 'original',
+          }
+        },
+        {event: 'error', data: {details: 'Cancelled on client'}},
+      ],
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      throws(() => subscribeToOpenRequests(args), new Error(error), 'Got err');
+    } else {
+      const events = [];
+      const sub = subscribeToOpenRequests(args);
+
+      ['channel_request', 'error',].forEach(event => {
+        return sub.on(event, data => events.push({event, data}));
+      });
+
+      await nextTick();
+
+      sub.removeAllListeners('error');
+
+      sub.removeAllListeners();
+
+      const sub2 = subscribeToOpenRequests(args);
+
+      await nextTick();
+
+      events.forEach(event => {
+        if (!!event.data && !!event.data.accept) {
+          event.data.accept();
+          event.data.reject();
+
+          event.data.accept({});
+          event.data.reject({});
+
+          delete event.data.accept;
+          delete event.data.reject;
+        }
+      });
+
+      deepStrictEqual(events, expected.events);
+    }
+
+    return;
+  });
+});