astra-lightning 1.0.0

package/test/lnd_methods/offchain/test_subscribe_to_probe_for_route.js

@@ -0,0 +1,303 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const EventEmitter = require('node:events');
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const {getInfoResponse} = require('./../fixtures');
+const {queryRoutesResponse} = require('./../fixtures');
+const {subscribeToProbeForRoute} = require('./../../../');
+
+const deletePayment = ({}, cbk) => cbk();
+
+const expectedRoute = {
+  confidence: 1000000,
+  fee: 0,
+  fee_mtokens: '1',
+  hops: [{
+    channel: '0x0x1',
+    channel_capacity: 1,
+    fee: 0,
+    fee_mtokens: '1',
+    forward: 0,
+    forward_mtokens: '1',
+    public_key: '00',
+    timeout: 1,
+  }],
+  messages: [],
+  mtokens: '1',
+  payment: undefined,
+  safe_fee: 1,
+  safe_tokens: 1,
+  timeout: 1,
+  tokens: 0,
+  total_mtokens: undefined,
+};
+
+const sendToRouteFailure = {
+  chan_id: '1',
+  code: 'INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS',
+  failure_source_index: 1,
+};
+
+const makeLnd = ({count, getInfo, sendToRouteV2}) => {
+  let returnedRoutes = 0;
+
+  const defaultSendTo = ({}, cbk) => cbk(null, {});
+
+  const lnd = {
+    default: {
+      deletePayment,
+      getInfo: getInfo || (({}, cbk) => cbk(null, getInfoResponse)),
+      queryRoutes: ({}, cbk) => {
+        if (returnedRoutes === (count || 1)) {
+          return cbk(null, {routes: []});
+        }
+
+        returnedRoutes++;
+
+        return cbk(null, queryRoutesResponse);
+      },
+    },
+    router: {
+      sendToRouteV2: sendToRouteV2 || defaultSendTo,
+    },
+  };
+
+  return lnd;
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'A destination public key is required',
+    error: 'ExpectedDestinationPublicKeyToSubscribeToProbe',
+  },
+  {
+    args: {destination: Buffer.alloc(33).toString('hex'), ignore: 'ignore'},
+    description: 'When ignore is specified, an array is expected',
+    error: 'ExpectedIgnoreEdgesArrayInProbeSubscription',
+  },
+  {
+    args: {destination: Buffer.alloc(33).toString('hex')},
+    description: 'LND is expected to probe',
+    error: 'ExpectedRouterRpcToSubscribeToProbe',
+  },
+  {
+    args: {
+      destination: Buffer.alloc(33).toString('hex'),
+      lnd: {router: {sendToRouteV2: ({}, cbk) => cbk()}},
+    },
+    description: 'A token amount is required to subscribe to a probe',
+    error: 'ExpectedTokenAmountToSubscribeToProbe',
+  },
+  {
+    args: {
+      destination: Buffer.alloc(33).toString('hex'),
+      ignore: [{from_public_key: 'from', to_public_key: 'to'}],
+      lnd: makeLnd({}),
+      probe_timeout_ms: 1,
+      tokens: 1,
+    },
+    description: 'A probe tries a route',
+    expected: {failures: [], routes: [expectedRoute]},
+  },
+  {
+    args: {
+      destination: Buffer.alloc(33).toString('hex'),
+      lnd: makeLnd({getInfo: ({}, cbk) => cbk('err')}),
+      tokens: 1,
+    },
+    description: 'A probe encounters an error getting info',
+    expected: {
+      error: [503, 'GetWalletInfoErr', {err: 'err'}],
+      failures: [],
+      routes: [],
+    },
+  },
+  {
+    args: {
+      destination: Buffer.alloc(33).toString('hex'),
+      lnd: makeLnd({getInfo: ({}, cbk) => cbk('err')}),
+      suppress_errors: true,
+      tokens: 1,
+    },
+    description: 'Non-listening errors are not emitted',
+    expected: {
+      failures: [],
+      routes: [],
+    },
+  },
+  {
+    args: {
+      destination: Buffer.alloc(33).toString('hex'),
+      lnd: makeLnd({
+        sendToRouteV2: ({}, cbk) => setTimeout(() => cbk('e'), 20),
+      }),
+      probe_timeout_ms: 1,
+      tokens: 1,
+    },
+    description: 'A probe times out',
+    expected: {
+      error: [503, 'ProbeTimeout'],
+      failures: [],
+      routes: [expectedRoute],
+    },
+  },
+  {
+    args: {
+      destination: Buffer.alloc(33).toString('hex'),
+      lnd: makeLnd({sendToRouteV2: ({}, cbk) => cbk('err')}),
+      tokens: 1,
+    },
+    description: 'A probe hits an error paying a route',
+    expected: {
+      error: [503, 'UnexpectedErrorWhenPayingViaRoute', {err: 'err'}],
+      failures: [],
+      routes: [expectedRoute],
+    },
+  },
+  {
+    args: {
+      destination: Buffer.alloc(33).toString('hex'),
+      lnd: makeLnd({
+        sendToRouteV2: ({}, cbk) => cbk(null, {
+          failure: {
+            chan_id: '1',
+            code: 'UNKNOWN_FAILURE',
+            failure_source_index: 1,
+          },
+          preimage: Buffer.alloc(Number()),
+        }),
+      }),
+      tokens: 1,
+    },
+    description: 'A probe is successful',
+    expected: {
+      failures: [],
+      routes: [expectedRoute],
+      success: expectedRoute,
+    },
+  },
+  {
+    args: {
+      destination: Buffer.alloc(33).toString('hex'),
+      lnd: makeLnd({
+        sendToRouteV2: ({}, cbk) => cbk(null, {
+          failure: {
+            chan_id: '1',
+            code: 'UNKNOWN_FAILURE',
+            failure_source_index: 0,
+          },
+          preimage: Buffer.alloc(Number()),
+        }),
+      }),
+      tokens: 1,
+    },
+    description: 'A probe hits a routing failure',
+    expected: {
+      failures: [{
+        channel: '0x0x1',
+        index: 0,
+        mtokens: undefined,
+        policy: undefined,
+        public_key: undefined,
+        reason: 'UnknownFailure',
+        route: expectedRoute,
+        update: undefined,
+      }],
+      routes: [expectedRoute],
+    },
+  },
+  {
+    args: {
+      destination: Buffer.alloc(33).toString('hex'),
+      lnd: makeLnd({
+        sendToRouteV2: ({}, cbk) => {
+          return setTimeout(() => {
+            return cbk(null, {
+              failure: {
+                chan_id: '1',
+                code: 'UNKNOWN_FAILURE',
+                failure_source_index: 0,
+              },
+              preimage: Buffer.alloc(Number()),
+            });
+          },
+          50);
+        },
+      }),
+      probe_timeout_ms: 1,
+      tokens: 1,
+    },
+    description: 'A probe hits a routing failure',
+    expected: {
+      error: [503, 'ProbeTimeout'],
+      failures: [],
+      routes: [expectedRoute],
+    },
+  },
+  {
+    args: {
+      destination: Buffer.alloc(33).toString('hex'),
+      lnd: makeLnd({
+        count: 2,
+        sendToRouteV2: ({}, cbk) => {
+          return setTimeout(() => {
+            return cbk(null, {
+              failure: {
+                chan_id: '1',
+                code: 'UNKNOWN_FAILURE',
+                failure_source_index: 0,
+              },
+              preimage: Buffer.alloc(Number()),
+            });
+          },
+          50);
+        },
+      }),
+      path_timeout_ms: 1,
+      probe_timeout_ms: 1,
+      tokens: 1,
+    },
+    description: 'A probe times out and tries something else',
+    expected: {
+      error: [503, 'ProbeTimeout'],
+      failures: [],
+      routes: [expectedRoute],
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => subscribeToProbeForRoute(args), new Error(error), 'Error');
+
+      return end();
+    } else {
+      const failures = [];
+      let gotError;
+      const routes = [];
+      let gotSuccess;
+      const sub = subscribeToProbeForRoute(args);
+
+      sub.on('error', err => gotError = err);
+      sub.on('probe_success', ({route}) => gotSuccess = route);
+      sub.on('probing', ({route}) => routes.push(route));
+      sub.on('routing_failure', failure => failures.push(failure));
+
+      if (!!args.suppress_errors) {
+        sub.removeAllListeners('error');
+      }
+
+      sub.on('end', () => {
+        deepStrictEqual(failures, expected.failures, 'Got expected failures');
+        deepStrictEqual(gotError, expected.error, 'Got expected error');
+        deepStrictEqual(gotSuccess, expected.success, 'Got expected success');
+        deepStrictEqual(routes, expected.routes, 'Got expected routes');
+
+        return end();
+      });
+    }
+  });
+});

package/test/lnd_methods/offchain/test_update_connected_watchtower.js

@@ -0,0 +1,90 @@
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {updateConnectedWatchtower} = require('./../../../lnd_methods');
+
+const makeLnd = err => {
+  return {
+    tower_client: {
+      addTower: ({}, cbk) => cbk(),
+      removeTower: ({}, cbk) => cbk(err),
+    },
+  };
+};
+
+const makeArgs = override => {
+  const args = {
+    add_socket: 'add',
+    lnd: makeLnd(),
+    public_key: Buffer.alloc(33, 3).toString('hex'),
+    remove_socket: 'remove',
+  };
+
+  Object.keys(override || {}).forEach(key => args[key] = override[key]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({add_socket: undefined, remove_socket: undefined}),
+    description: 'An add or remove socket is required',
+    error: [400, 'ExpectedASocketToAddToOrRemoveFromWatchtower'],
+  },
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'LND is required',
+    error: [400, 'ExpectedAuthenticatedLndToUpdateWatchtower'],
+  },
+  {
+    args: makeArgs({public_key: undefined}),
+    description: 'A public key is required',
+    error: [400, 'ExpectedPublicKeyToUpdateWatchtower'],
+  },
+  {
+    args: makeArgs({
+      lnd: makeLnd({
+        message: '12 UNIMPLEMENTED: unknown service wtclientrpc.WatchtowerClient',
+      }),
+    }),
+    description: 'Unimplemented error is returned',
+    error: [501, 'ExpectedWatchtowerClientLndToGetPolicy'],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        tower_client: {
+          addTower: ({}, cbk) => cbk('err'),
+          removeTower: ({}, cbk) => cbk(),
+        },
+      },
+    }),
+    description: 'Add socket error is returned',
+    error: [503, 'UnexpectedAddSocketToWatchtowerError', {err: 'err'}],
+  },
+  {
+    args: makeArgs({add_socket: undefined, lnd: makeLnd('err')}),
+    description: 'Server error is returned',
+    error: [503, 'UnexpectedRemoveSocketFromTowerError', {err: 'err'}],
+  },
+  {
+    args: makeArgs({remove_socket: undefined}),
+    description: 'A socket is added',
+  },
+  {
+    args: makeArgs({}),
+    description: 'A socket is added and a socket is removed',
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(updateConnectedWatchtower(args), error, 'Got error');
+    } else {
+      await updateConnectedWatchtower(args);
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/offchain/test_update_pathfinding_settings.js

@@ -0,0 +1,135 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {updatePathfindingSettings} = require('./../../../lnd_methods');
+
+const makeLnd = ({config, empty, err, overrides, setErr}) => {
+  if (!!empty) {
+    return {
+      router: {
+        getMissionControlConfig: ({}, cbk) => cbk(),
+        setMissionControlConfig: ({}, cbk) => cbk(),
+      },
+    };
+  }
+
+  const res = {
+    config: {
+      half_life_seconds: 1,
+      hop_probability: 0.6,
+      maximum_payment_results: 10,
+      minimum_failure_relax_interval: 1,
+      weight: 0.5,
+    },
+  };
+
+  Object.keys(overrides || {}).forEach(key => res[key] = overrides[key]);
+
+  Object.keys(config || {}).forEach(key => res.config[key] = config[key]);
+
+  return {
+    router: {
+      getMissionControlConfig: ({}, cbk) => cbk(err, res),
+      setMissionControlConfig: ({}, cbk) => cbk(setErr),
+    },
+  };
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'LND is expected to get pathfinding settings',
+    error: [400, 'ExpectedLndToUpdatePathfindingSettings'],
+  },
+  {
+    args: {baseline_success_rate: -1, lnd: makeLnd({})},
+    description: 'A valid baseline failure rate is expected',
+    error: [400, 'ExpectedValidBaselineSuccessRateForUpdate'],
+  },
+  {
+    args: {lnd: makeLnd({}), node_ignore_rate: -1},
+    description: 'A valid node ignore rate is expected',
+    error: [400, 'ExpectedValidIgnoreRateForPathfindingUpdate'],
+  },
+  {
+    args: {lnd: makeLnd({err: 'err'})},
+    description: 'An error is returned',
+    error: [503, 'UnexpectedErrorGettingPathSettings', {err: 'err'}],
+  },
+  {
+    args: {lnd: makeLnd({err: {details: 'unknown method'}})},
+    description: 'An unsupported error is returned',
+    error: [501, 'GetMissionControlConfigMethodNotSupported'],
+  },
+  {
+    args: {lnd: makeLnd({setErr: 'err'})},
+    description: 'An error is returned when setting',
+    error: [503, 'UnexpectedErrorUpdatingPathingSettings', {err: 'err'}],
+  },
+  {
+    args: {lnd: makeLnd({empty: true})},
+    description: 'A response is expected',
+    error: [503, 'ExpectedPathfindingSettingsResponse'],
+  },
+  {
+    args: {lnd: makeLnd({overrides: {config: undefined}})},
+    description: 'A config is expected',
+    error: [503, 'ExpectedPathfindingSettingsConfigInResponse'],
+  },
+  {
+    args: {lnd: makeLnd({config: {half_life_seconds: undefined}})},
+    description: 'Half life seconds are expected',
+    error: [503, 'ExpectedHalfLifeSecondsInSettingsResponse'],
+  },
+  {
+    args: {lnd: makeLnd({config: {hop_probability: undefined}})},
+    description: 'Hop probability is expected',
+    error: [503, 'ExpectedAssumedHopPriorityInSettingsResponse'],
+  },
+  {
+    args: {lnd: makeLnd({config: {maximum_payment_results: undefined}})},
+    description: 'Max payments are expected',
+    error: [503, 'ExpectedMaximumPaymentResultsInConfigResponse'],
+  },
+  {
+    args: {
+      lnd: makeLnd({config: {minimum_failure_relax_interval: undefined}}),
+    },
+    description: 'Min failure relax interval is expected',
+    error: [503, 'ExpectedMinimumFailureRelaxIntervalInResponse'],
+  },
+  {
+    args: {lnd: makeLnd({config: {weight: undefined}})},
+    description: 'Node reputation weight is expected',
+    error: [503, 'ExpectedWeightInSettingsConfigResponse'],
+  },
+  {
+    args: {lnd: makeLnd({})},
+    description: 'Pathfinding configuration is updated when nothing passed',
+  },
+  {
+    args: {
+      baseline_success_rate: 1,
+      lnd: makeLnd({}),
+      max_payment_records: 1,
+      node_ignore_rate: 1,
+      penalty_half_life_ms: 1,
+    },
+    description: 'Pathfinding configuration is updated',
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(() => updatePathfindingSettings(args), error, 'Got err');
+    } else {
+      const res = await updatePathfindingSettings(args);
+
+      deepStrictEqual(res, expected, 'Got expected result');
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/offchain/test_update_routing_fees.js

@@ -0,0 +1,194 @@
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {updateRoutingFees} = require('./../../../');
+
+const makeLnd = ({err, policy}) => {
+  return {
+    default: {
+      updateChannelPolicy: (args, cbk) => {
+        if (!!err) {
+          return cbk(err);
+        }
+
+        if (args.base_fee_msat !== policy.base_fee_msat) {
+          return cbk('UnexpectedBaseFeeMsat');
+        }
+
+        const gotPoint = args.chan_point || {};
+        const chanPoint = policy.chan_point || {};
+
+        if (gotPoint.funding_txid_str !== chanPoint.funding_txid_str) {
+          return cbk('UnexpectedChanTxId');
+        }
+
+        if (gotPoint.output_index !== chanPoint.output_index) {
+          return cbk('UnexpectedChanTxVout');
+        }
+
+        if (policy.fee_rate !== args.fee_rate) {
+          return cbk('UnexpectedFeeRate');
+        }
+
+        if (policy.global !== args.global) {
+          return cbk('UnexpectedGlobalFeeUpdate');
+        }
+
+        if (policy.max_htlc_msat !== args.max_htlc_msat) {
+          return cbk('UnexpectedMaxHtlcMsatUndefined');
+        }
+
+        if (policy.time_lock_delta !== args.time_lock_delta) {
+          return cbk('UnexpectedCltvDelta');
+        }
+
+        return cbk(null, {failed_updates: []});
+      },
+    },
+  };
+};
+
+const makeArgs = overrides => {
+  const args = {
+    base_fee_tokens: '99',
+    cltv_delta: 1,
+    fee_rate: 99,
+    lnd: makeLnd({}),
+    max_htlc_mtokens: '1',
+    transaction_id: '1',
+    transaction_vout: 0,
+  };
+
+  Object.keys(overrides).forEach(key => args[key] = overrides[key]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'Authenticated LND is required to update routing fees',
+    error: [400, 'ExpectedLndForRoutingFeesUpdate'],
+  },
+  {
+    args: makeArgs({base_fee_mtokens: '1', base_fee_tokens: 1}),
+    description: 'A single unit format base fee is expected',
+    error: [400, 'ExpectedEitherBaseFeeMtokensOrTokensNotBoth'],
+  },
+  {
+    args: makeArgs({transaction_id: undefined}),
+    description: 'A full chanpoint with vout is required for an update',
+    error: [400, 'UnexpectedTransactionIdForGlobalFeeUpdate'],
+  },
+  {
+    args: makeArgs({transaction_vout: undefined}),
+    description: 'A full chanpoint is required for a routing fee update',
+    error: [400, 'UnexpectedTxOutputIndexForGlobalFeeUpdate'],
+  },
+  {
+    args: {lnd: makeLnd({err: 'err'})},
+    description: 'Errors are returned',
+    error: [503, 'UnexpectedErrorUpdatingRoutingFees', {err: 'err'}],
+  },
+  {
+    args: {lnd: {default: {updateChannelPolicy: ({}, cbk) => cbk()}}},
+    description: 'A response is expected',
+    error: [503, 'ExpectedRoutingPolicyUpdateResponse'],
+  },
+  {
+    args: {lnd: {default: {updateChannelPolicy: ({}, cbk) => cbk(null, {})}}},
+    description: 'Failures are expected',
+    error: [503, 'ExpectedFailedUpdateArrayInUpdateResponse'],
+  },
+  {
+    args: {
+      lnd: {
+        default: {
+          updateChannelPolicy: ({}, cbk) => cbk(null, {failed_updates: [{}]}),
+        },
+      },
+    },
+    description: 'Valid failures are expected',
+    error: [503, 'ExpectedFundingTransactionOutpointForPolicyFailDetails'],
+  },
+  {
+    args: {
+      lnd: makeLnd({
+        policy: {
+          base_fee_msat: '1000',
+          chan_point: undefined,
+          fee_rate: 0.000001,
+          global: true,
+          max_htlc_msat: undefined,
+          time_lock_delta: 144,
+        },
+      }),
+      description: 'The global channel policy is updated',
+    },
+  },
+  {
+    args: {
+      base_fee_mtokens: '1',
+      lnd: makeLnd({
+        policy: {
+          base_fee_msat: '1',
+          chan_point: undefined,
+          fee_rate: 0.000001,
+          global: true,
+          max_htlc_msat: undefined,
+          time_lock_delta: 144,
+        },
+      }),
+      description: 'The global channel policy base fee mtokens is updated',
+    },
+  },
+  {
+    args: {
+      base_fee_tokens: '99',
+      cltv_delta: 1,
+      fee_rate: 99,
+      lnd: makeLnd({
+        policy: {
+          base_fee_msat: '99000',
+          chan_point: {funding_txid_str: '1', output_index: 0},
+          fee_rate: 0.000099,
+          global: undefined,
+          max_htlc_msat: '1',
+          time_lock_delta: 1,
+        },
+      }),
+      max_htlc_mtokens: '1',
+      transaction_id: '1',
+      transaction_vout: 0,
+    },
+    description: 'A local channel policy is updated',
+  },
+  {
+    args: {
+      inbound_base_discount_mtokens: '1',
+      lnd: makeLnd({
+        policy: {
+          base_fee_msat: '1000',
+          chan_point: undefined,
+          fee_rate: 0.000001,
+          global: true,
+          max_htlc_msat: undefined,
+          time_lock_delta: 144,
+        },
+      }),
+      description: 'Set a base discount',
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(updateRoutingFees(args), error, 'Got expected error');
+    } else {
+      await updateRoutingFees(args);
+    }
+
+    return;
+  });
+});