astra-lightning 1.0.0

package/test/lnd_responses/test_rpc_channel_as_channel.js

@@ -0,0 +1,310 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const {rpcChannelAsChannel} = require('./../../lnd_responses');
+
+const makeArgs = overrides => {
+  const args = {
+    active: true,
+    alias_scids: [],
+    capacity: '1',
+    chan_id: '1',
+    channel_point: '00:1',
+    chan_status_flags: '1',
+    close_address: undefined,
+    commit_fee: '1',
+    commit_weight: '1',
+    commitment_type: 'ANCHORS',
+    csv_delay: 1,
+    fee_per_kw: '1',
+    initiator: false,
+    lifetime: 1,
+    local_balance: '1',
+    local_chan_reserve_sat: '0',
+    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: [{
+      amount: '1',
+      expiration_height: 1,
+      hash_lock: Buffer.alloc(32),
+      incoming: true,
+    }],
+    private: true,
+    push_amount_sat: '0',
+    remote_balance: '1',
+    remote_chan_reserve_sat: '0',
+    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: '00',
+    static_remote_key: false,
+    thaw_height: 0,
+    total_satoshis_received: '1',
+    total_satoshis_sent: '1',
+    unsettled_balance: '1',
+    uptime: 1,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const makeExpected = overrides => {
+  const expected = {
+    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: true,
+    is_closing: false,
+    is_opening: false,
+    is_partner_initiated: true,
+    is_private: true,
+    is_trusted_funding: undefined,
+    local_balance: 1,
+    local_csv: 1,
+    local_dust: 1,
+    local_given: 0,
+    local_max_htlcs: 1,
+    local_max_pending_mtokens: '1',
+    local_min_htlc_mtokens: '1',
+    local_reserve: 1,
+    other_ids: [],
+    partner_public_key: '00',
+    past_states: 1,
+    pending_payments: [{
+      id: '0000000000000000000000000000000000000000000000000000000000000000',
+      in_channel: undefined,
+      in_payment: undefined,
+      is_forward: undefined,
+      is_outgoing: false,
+      out_channel: undefined,
+      out_payment: undefined,
+      payment: undefined,
+      timeout: 1,
+      tokens: 1,
+    }],
+    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: '00',
+    transaction_vout: 1,
+    type: 'anchor',
+    unsettled_balance: 1,
+  };
+
+  Object.keys(overrides).forEach(k => expected[k] = overrides[k]);
+
+  return expected;
+};
+
+const tests = [
+  {
+    args: makeArgs({active: undefined}),
+    description: 'Channel active is expected',
+    error: 'ExpectedChannelActiveStateInChannelMessage',
+  },
+  {
+    args: makeArgs({alias_scids: undefined}),
+    description: 'Alias scids are expected',
+    error: 'ExpectedArrayOfAliasShortChannelIdsInChannelMessage',
+  },
+  {
+    args: makeArgs({capacity: undefined}),
+    description: 'Channel capacity is expected',
+    error: 'ExpectedChannelCapacityInChannelMessage',
+  },
+  {
+    args: makeArgs({chan_id: undefined}),
+    description: 'Channel id is expected',
+    error: 'ExpectedChannelIdNumberInChannelsList',
+  },
+  {
+    args: makeArgs({channel_point: undefined}),
+    description: 'Channel point is expected',
+    error: 'ExpectedChannelPointInChannelMessage',
+  },
+  {
+    args: makeArgs({commit_fee: undefined}),
+    description: 'Channel commit fee is expected',
+    error: 'ExpectedCommitFeeInChannelMessage',
+  },
+  {
+    args: makeArgs({commit_weight: undefined}),
+    description: 'Channel commit weight is expected',
+    error: 'ExpectedCommitWeightInChannelMessage',
+  },
+  {
+    args: makeArgs({commitment_type: undefined}),
+    description: 'Channel commit type is expected',
+    error: 'ExpectedChannelCommitmentTypeInChannelMessage',
+  },
+  {
+    args: makeArgs({fee_per_kw: undefined}),
+    description: 'Channel fee per kw is expected',
+    error: 'ExpectedFeePerKwInChannelMessage',
+  },
+  {
+    args: makeArgs({local_balance: undefined}),
+    description: 'Local balance is expected',
+    error: 'ExpectedLocalBalanceInChannelMessage',
+  },
+  {
+    args: makeArgs({local_chan_reserve_sat: undefined}),
+    description: 'Local chan reserve is expected',
+    error: 'ExpectedLocalChannelReserveAmountInChannelMessage',
+  },
+  {
+    args: makeArgs({local_constraints: undefined}),
+    description: 'Local constraints are expected',
+    error: 'ExpectedLocalChannelConstraintsInChannelMessage',
+  },
+  {
+    args: makeArgs({num_updates: undefined}),
+    description: 'Channel update count is expected',
+    error: 'ExpectedNumUpdatesInChannelMessage',
+  },
+  {
+    args: makeArgs({pending_htlcs: undefined}),
+    description: 'Pending HTLCs array is expected',
+    error: 'ExpectedChannelPendingHtlcsInChannelMessage',
+  },
+  {
+    args: makeArgs({private: undefined}),
+    description: 'Private status is expected',
+    error: 'ExpectedChannelPrivateStatusInChannelMessage',
+  },
+  {
+    args: makeArgs({remote_balance: undefined}),
+    description: 'Remote balance is expected',
+    error: 'ExpectedRemoteBalanceInChannelMessage',
+  },
+  {
+    args: makeArgs({remote_chan_reserve_sat: undefined}),
+    description: 'Remote channel reserve is expected',
+    error: 'ExpectedRemoteChannelReserveAmountInChannelMessage',
+  },
+  {
+    args: makeArgs({remote_constraints: undefined}),
+    description: 'Remote constraints are expected',
+    error: 'ExpectedRemoteChannelConstraintsInChannelMessage',
+  },
+  {
+    args: makeArgs({remote_pubkey: undefined}),
+    description: 'Remote public key is expected',
+    error: 'ExpectedRemotePubkeyInChannelMessage',
+  },
+  {
+    args: makeArgs({thaw_height: undefined}),
+    description: 'Channel thaw height is expected',
+    error: 'ExpectedCooperativeCloseThawHeightInChannelMessage',
+  },
+  {
+    args: makeArgs({total_satoshis_received: undefined}),
+    description: 'Total satoshis received is expected',
+    error: 'ExpectedTotalSatoshisReceivedInChannelMessage',
+  },
+  {
+    args: makeArgs({total_satoshis_sent: undefined}),
+    description: 'Total satoshis received is expected',
+    error: 'ExpectedTotalSatoshisSentInChannelMessage',
+  },
+  {
+    args: makeArgs({unsettled_balance: undefined}),
+    description: 'Unsettled balance is expected',
+    error: 'ExpectedUnsettledBalanceInChannelMessage',
+  },
+  {
+    args: makeArgs({}),
+    description: 'RPC channel is mapped to channel',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({alias_scids: ['2', '3'], zero_conf_confirmed_scid: '2'}),
+    description: 'RPC channel is mapped to channel with scids',
+    expected: makeExpected({id: '0x0x2', other_ids: ['0x0x3']}),
+  },
+  {
+    args: makeArgs({commitment_type: 'ANCHORS', initiator: true}),
+    description: 'Initiated RPC channel is mapped to channel',
+    expected: makeExpected({
+      is_partner_initiated: false,
+    }),
+  },
+  {
+    args: makeArgs({
+      commitment_type: 'ANCHORS',
+      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',
+      },
+      remote_constraints: {
+        chan_reserve_sat: '2',
+        csv_delay: 2,
+        dust_limit_sat: '2',
+        max_accepted_htlcs: 2,
+        max_pending_amt_msat: '2',
+        min_htlc_msat: '2',
+      },
+    }),
+    description: 'Local constraints RPC channel is mapped to channel',
+    expected: makeExpected({
+      local_csv: 1,
+      local_dust: 1,
+      local_max_htlcs: 1,
+      local_max_pending_mtokens: '1',
+      local_min_htlc_mtokens: '1',
+      local_reserve: 1,
+      remote_csv: 2,
+      remote_dust: 2,
+      remote_max_htlcs: 2,
+      remote_max_pending_mtokens: '2',
+      remote_min_htlc_mtokens: '2',
+      remote_reserve: 2,
+    }),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => rpcChannelAsChannel(args), new Error(error), 'Got error');
+    } else {
+      const channel = rpcChannelAsChannel(args);
+
+      deepStrictEqual(channel, expected, 'Channel cast as channel');
+    }
+
+    return end();
+  });
+});

package/test/lnd_responses/test_rpc_channel_closed_as_closed.js

@@ -0,0 +1,113 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const {rpcChannelClosedAsClosed} = require('./../../lnd_responses');
+
+const makeArgs = overrides => {
+  const args = {
+    capacity: '1',
+    chan_id: 1,
+    chan_point: {
+      funding_txid_bytes: Buffer.from('0102', 'hex'),
+      output_index: 1,
+    },
+    closed_height: 1,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const makeExpected = overrides => {
+  const expected = {
+    capacity: 1,
+    close_height: 1,
+    id: '0x0x1',
+    transaction_id: '0201',
+    transaction_vout: 1,
+  };
+
+  Object.keys(overrides).forEach(k => expected[k] = overrides[k]);
+
+  return expected;
+};
+
+const tests = [
+  {
+    args: undefined,
+    description: 'An update is expected',
+    error: 'ExpectedChannelClosedUpdateDetails',
+  },
+  {
+    args: makeArgs({capacity: undefined}),
+    description: 'Channel capacity is expected',
+    error: 'ExpectedChanCapacity',
+  },
+  {
+    args: makeArgs({chan_id: undefined}),
+    description: 'Channel id is expected',
+    error: 'ExpectedChannelId',
+  },
+  {
+    args: makeArgs({chan_id: 'chan_id'}),
+    description: 'Valid channel id is expected',
+    error: 'ExpectedValidChannelId',
+  },
+  {
+    args: makeArgs({chan_point: undefined}),
+    description: 'Channel funding outpoint is expected',
+    error: 'ExpectedChanOutpoint',
+  },
+  {
+    args: makeArgs({chan_point: {}}),
+    description: 'Channel funding outpoint tx id is expected',
+    error: 'ExpectedChannelTxId',
+  },
+  {
+    args: makeArgs({chan_point: {funding_txid_bytes: Buffer.alloc(32)}}),
+    description: 'Channel funding outpoint tx vout is expected',
+    error: 'ExpectedChanPointVout',
+  },
+  {
+    args: makeArgs({closed_height: undefined}),
+    description: 'Closed height is expected',
+    error: 'ExpectedCloseHeight',
+  },
+  {
+    args: makeArgs({}),
+    description: 'RPC channel closed is mapped to closed',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({
+      capacity: '0',
+      chan_point: {funding_txid_bytes: Buffer.alloc(32), output_index: 0},
+    }),
+    description: 'RPC channel closed without details is mapped to update',
+    expected: makeExpected({
+      capacity: undefined,
+      transaction_id: undefined,
+      transaction_vout: undefined,
+    }),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => rpcChannelClosedAsClosed(args), new Error(error), 'Error');
+    } else {
+      const update = rpcChannelClosedAsClosed(args);
+
+      deepStrictEqual(!!update.updated_at, true, 'Has last updated date');
+
+      delete update.updated_at;
+
+      deepStrictEqual(update, expected, 'Channel closed cast as close');
+    }
+
+    return end();
+  });
+});

package/test/lnd_responses/test_rpc_channel_update_as_update.js

@@ -0,0 +1,208 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const {rpcChannelUpdateAsUpdate} = require('./../../lnd_responses');
+
+const makeRoutingPolicy = overrides => {
+  const policy = {
+    disabled: false,
+    fee_base_msat: '1',
+    fee_rate_milli_msat: '1',
+    inbound_fee_base_msat: 0,
+    inbound_fee_rate_milli_msat: 0,
+    max_htlc_msat: '1',
+    min_htlc: '1',
+    time_lock_delta: 1,
+  };
+
+  Object.keys(overrides).forEach(k => policy[k] = overrides[k]);
+
+  return policy;
+};
+
+const makeArgs = overrides => {
+  const args = {
+    advertising_node: Buffer.alloc(33, 1).toString('hex'),
+    capacity: '1',
+    chan_id: 1,
+    chan_point: {
+      funding_txid_bytes: Buffer.from('0102', 'hex'),
+      output_index: 1,
+    },
+    connecting_node: Buffer.alloc(33, 2).toString('hex'),
+    routing_policy: makeRoutingPolicy({}),
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const makeExpected = overrides => {
+  const expected = {
+    base_fee_mtokens: '1',
+    capacity: 1,
+    cltv_delta: 1,
+    fee_rate: 1,
+    id: '0x0x1',
+    inbound_base_discount_mtokens: '0',
+    inbound_rate_discount: 0,
+    is_disabled: false,
+    max_htlc_mtokens: '1',
+    min_htlc_mtokens: '1',
+    public_keys: [
+      Buffer.alloc(33, 1).toString('hex'),
+      Buffer.alloc(33, 2).toString('hex'),
+    ],
+    transaction_id: '0201',
+    transaction_vout: 1,
+  };
+
+  Object.keys(overrides).forEach(k => expected[k] = overrides[k]);
+
+  return expected;
+};
+
+const tests = [
+  {
+    args: undefined,
+    description: 'An update is expected',
+    error: 'ExpectedChannelUpdateDetails',
+  },
+  {
+    args: makeArgs({advertising_node: undefined}),
+    description: 'An advertising node is expected',
+    error: 'ExpectedAnnouncingKey',
+  },
+  {
+    args: makeArgs({capacity: undefined}),
+    description: 'Channel capacity is expected',
+    error: 'ExpectedChanCapacity',
+  },
+  {
+    args: makeArgs({chan_id: undefined}),
+    description: 'Channel id is expected',
+    error: 'ExpectedChannelId',
+  },
+  {
+    args: makeArgs({chan_id: 'chan_id'}),
+    description: 'Valid channel id is expected',
+    error: 'ExpectedValidChannelId',
+  },
+  {
+    args: makeArgs({chan_point: undefined}),
+    description: 'Channel funding outpoint is expected',
+    error: 'ExpectedChanPoint',
+  },
+  {
+    args: makeArgs({chan_point: {}}),
+    description: 'Channel funding outpoint tx id is expected',
+    error: 'ExpectedChanPointTxId',
+  },
+  {
+    args: makeArgs({chan_point: {funding_txid_bytes: Buffer.alloc(32)}}),
+    description: 'Channel funding outpoint tx vout is expected',
+    error: 'ExpectedChanPointVout',
+  },
+  {
+    args: makeArgs({connecting_node: undefined}),
+    description: 'Channel funding outpoint tx vout is expected',
+    error: 'ExpectedConnectingNode',
+  },
+  {
+    args: makeArgs({routing_policy: undefined}),
+    description: 'A routing policy is expected',
+    error: 'ExpectedRoutingPolicy',
+  },
+  {
+    args: makeArgs({routing_policy: makeRoutingPolicy({disabled: undefined})}),
+    description: 'Routing policy disabled is expected',
+    error: 'ExpectedDisabledStatus',
+  },
+  {
+    args: makeArgs({
+      routing_policy: makeRoutingPolicy({fee_base_msat: undefined}),
+    }),
+    description: 'Routing policy fee base msat is expected',
+    error: 'ExpectedFeeBaseMsat',
+  },
+  {
+    args: makeArgs({
+      routing_policy: makeRoutingPolicy({fee_rate_milli_msat: undefined}),
+    }),
+    description: 'Routing policy fee rate is expected',
+    error: 'ExpectedFeeRate',
+  },
+  {
+    args: makeArgs({
+      routing_policy: makeRoutingPolicy({max_htlc_msat: undefined}),
+    }),
+    description: 'Routing policy max htlc millitokens is expected',
+    error: 'ExpectedMaxHtlcInChannelUpdate',
+  },
+  {
+    args: makeArgs({
+      routing_policy: makeRoutingPolicy({min_htlc: undefined}),
+    }),
+    description: 'Routing policy min htlc millitokens is expected',
+    error: 'ExpectedMinHtlc',
+  },
+  {
+    args: makeArgs({
+      routing_policy: makeRoutingPolicy({time_lock_delta: undefined}),
+    }),
+    description: 'Routing policy min cltv delta is expected',
+    error: 'ExpectedCltvDelta',
+  },
+  {
+    args: makeArgs({}),
+    description: 'RPC channel update is mapped to update',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({
+      routing_policy: makeRoutingPolicy({
+        inbound_fee_base_msat: -1,
+        inbound_fee_rate_milli_msat: -1,
+      }),
+    }),
+    description: 'RPC channel with inbound rates is mapped',
+    expected: makeExpected({
+      inbound_base_discount_mtokens: '1',
+      inbound_rate_discount: 1,
+    }),
+  },
+  {
+    args: makeArgs({
+      capacity: '0',
+      chan_point: {funding_txid_bytes: Buffer.alloc(32), output_index: 0},
+      routing_policy: makeRoutingPolicy({max_htlc_msat: '0'}),
+    }),
+    description: 'RPC channel update without details is mapped to update',
+    expected: makeExpected({
+      capacity: undefined,
+      max_htlc_mtokens: undefined,
+      transaction_id: undefined,
+      transaction_vout: undefined,
+    }),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => rpcChannelUpdateAsUpdate(args), new Error(error), 'Error');
+    } else {
+      const update = rpcChannelUpdateAsUpdate(args);
+
+      deepStrictEqual(!!update.updated_at, true, 'Has last updated date');
+
+      delete update.updated_at;
+
+      deepStrictEqual(update, expected, 'Channel update cast as update');
+    }
+
+    return end();
+  });
+});