lightning 10.9.2 → 10.10.1

package/test/lnd_methods/onchain/test_send_to_chain_address.js

@@ -1,4 +1,4 @@
-const {deepStrictEqual} = require('node:assert').strict;
+const {deepEqual} = require('node:assert').strict;
 const {rejects} = require('node:assert').strict;
 const test = require('node:test');
 
@@ -22,6 +22,20 @@ const makeArgs = overrides => {
   return args;
 };
 
+const makeExpected = overrides => {
+  const args = {
+    confirmation_count: 0,
+    id: Buffer.alloc(32).toString('hex'),
+    is_confirmed: false,
+    is_outgoing: true,
+    tokens: 1,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
 const tests = [
   {
     args: makeArgs({address: undefined}),
@@ -89,35 +103,17 @@ const tests = [
   {
     args: makeArgs({log: console.log, wss: [{clients: [null]}]}),
     description: 'Send coins with null wss client',
-    expected: {
-      confirmation_count: 0,
-      id: Buffer.alloc(32).toString('hex'),
-      is_confirmed: false,
-      is_outgoing: true,
-      tokens: 1,
-    },
+    expected: makeExpected({}),
   },
   {
     args: makeArgs({log: console.log, wss: [{clients: [{}]}]}),
     description: 'Send coins with no ready state',
-    expected: {
-      confirmation_count: 0,
-      id: Buffer.alloc(32).toString('hex'),
-      is_confirmed: false,
-      is_outgoing: true,
-      tokens: 1,
-    },
+    expected: makeExpected({}),
   },
   {
     args: makeArgs({log: () => {}, wss: [{clients: [{readyState: 1}]}]}),
     description: 'Send coins with no send method',
-    expected: {
-      confirmation_count: 0,
-      id: Buffer.alloc(32).toString('hex'),
-      is_confirmed: false,
-      is_outgoing: true,
-      tokens: 1,
-    },
+    expected: makeExpected({}),
   },
   {
     args: makeArgs({
@@ -127,35 +123,22 @@ const tests = [
       tokens: undefined,
     }),
     description: 'Send coins with broadcast',
-    expected: {
-      confirmation_count: 0,
-      id: Buffer.alloc(32).toString('hex'),
-      is_confirmed: false,
-      is_outgoing: true,
-      tokens: undefined,
-    },
+    expected: makeExpected({tokens: undefined}),
   },
   {
     args: makeArgs({}),
     description: 'Send coins',
-    expected: {
-      confirmation_count: 0,
-      id: Buffer.alloc(32).toString('hex'),
-      is_confirmed: false,
-      is_outgoing: true,
-      tokens: 1,
-    },
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({fee_tokens_per_vbyte: 1}),
+    description: 'Send coins with a fee rate',
+    expected: makeExpected({}),
   },
   {
     args: makeArgs({utxo_selection: 'random'}),
     description: 'Send coins with coin selection',
-    expected: {
-      confirmation_count: 0,
-      id: Buffer.alloc(32).toString('hex'),
-      is_confirmed: false,
-      is_outgoing: true,
-      tokens: 1,
-    },
+    expected: makeExpected({}),
   },
 ];
 
@@ -166,7 +149,7 @@ tests.forEach(({args, description, error, expected}) => {
     } else {
       const res = await sendToChainAddress(args);
 
-      deepStrictEqual(res, expected, 'Got expected result');
+      deepEqual(res, expected, 'Got expected result');
     }
 
     return;

package/test/lnd_methods/onchain/test_send_to_chain_addresses.js

@@ -21,6 +21,20 @@ const makeArgs = overrides => {
   return args;
 };
 
+const makeExpected = overrides => {
+  const args = {
+    confirmation_count: 0,
+    id: Buffer.alloc(32).toString('hex'),
+    is_confirmed: false,
+    is_outgoing: true,
+    tokens: 1,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
 const tests = [
   {
     args: makeArgs({lnd: undefined}),
@@ -75,35 +89,17 @@ const tests = [
   {
     args: makeArgs({log: console.log, wss: [{clients: [null]}]}),
     description: 'Send coins with null wss client',
-    expected: {
-      confirmation_count: 0,
-      id: Buffer.alloc(32).toString('hex'),
-      is_confirmed: false,
-      is_outgoing: true,
-      tokens: 1,
-    },
+    expected: makeExpected({}),
   },
   {
     args: makeArgs({log: console.log, wss: [{clients: [{}]}]}),
     description: 'Send coins with no ready state',
-    expected: {
-      confirmation_count: 0,
-      id: Buffer.alloc(32).toString('hex'),
-      is_confirmed: false,
-      is_outgoing: true,
-      tokens: 1,
-    },
+    expected: makeExpected({}),
   },
   {
     args: makeArgs({log: () => {}, wss: [{clients: [{readyState: 1}]}]}),
     description: 'Send coins with no send method',
-    expected: {
-      confirmation_count: 0,
-      id: Buffer.alloc(32).toString('hex'),
-      is_confirmed: false,
-      is_outgoing: true,
-      tokens: 1,
-    },
+    expected: makeExpected({}),
   },
   {
     args: makeArgs({
@@ -111,35 +107,22 @@ const tests = [
       wss: [{clients: [{readyState: 1, send: () => {}}]}],
     }),
     description: 'Send coins with broadcast',
-    expected: {
-      confirmation_count: 0,
-      id: Buffer.alloc(32).toString('hex'),
-      is_confirmed: false,
-      is_outgoing: true,
-      tokens: 1,
-    },
+    expected: makeExpected({}),
   },
   {
     args: makeArgs({}),
     description: 'Send coins',
-    expected: {
-      confirmation_count: 0,
-      id: Buffer.alloc(32).toString('hex'),
-      is_confirmed: false,
-      is_outgoing: true,
-      tokens: 1,
-    },
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({fee_tokens_per_vbyte: 1}),
+    description: 'Send coins with fee rate',
+    expected: makeExpected({}),
   },
   {
     args: makeArgs({utxo_selection: 'random'}),
     description: 'Send coins with coin selection',
-    expected: {
-      confirmation_count: 0,
-      id: Buffer.alloc(32).toString('hex'),
-      is_confirmed: false,
-      is_outgoing: true,
-      tokens: 1,
-    },
+    expected: makeExpected({}),
   },
 ];
 

package/test/lnd_responses/test_rpc_sweep_as_sweep.js

@@ -0,0 +1,135 @@
+const {deepEqual} = require('node:assert').strict;
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const {rpcSweepAsSweep} = require('./../../lnd_responses');
+
+const makeArgs = overrides => {
+  const response = {
+    amount_sat: 0,
+    broadcast_attempts: 0,
+    budget: '0',
+    deadline_height: 0,
+    immediate: true,
+    outpoint: {
+      output_index: 0,
+      txid_str: Buffer.alloc(32).toString('hex'),
+    },
+    requested_sat_per_vbyte: '0',
+    sat_per_vbyte: '0',
+    witness_type: 'witness_type',
+  };
+
+  Object.keys(overrides || {}).forEach(key => response[key] = overrides[key]);
+
+  return response;
+};
+
+
+const makeExpected = overrides => {
+  const expected = {
+    broadcasts_count: 0,
+    current_fee_rate: undefined,
+    initial_fee_rate: undefined,
+    is_batching: false,
+    max_fee: undefined,
+    max_height: undefined,
+    tokens: 0,
+    transaction_id: Buffer.alloc(32).toString('hex'),
+    transaction_vout: 0,
+    type: 'witness_type',
+  };
+
+  Object.keys(overrides || {}).forEach(key => expected[key] = overrides[key]);
+
+  return expected;
+};
+
+const tests = [
+  {
+    description: 'Pending sweep details are expected',
+    error: 'ExpectedSweepDetailsToDerivePendingSweep',
+  },
+  {
+    args: makeArgs({amount_sat: undefined}),
+    description: 'The sweep amount is expected',
+    error: 'ExpectedSweepOutpointValueAmountInPendingSweep',
+  },
+  {
+    args: makeArgs({broadcast_attempts: undefined}),
+    description: 'The broadcasts count is expected',
+    error: 'ExpectedBroadcastAttemptsForSweepInPendingSweep',
+  },
+  {
+    args: makeArgs({budget: undefined}),
+    description: 'The sweep budget is expected',
+    error: 'ExpectedSweepBudgetAmountForSweepInPendingSweeps',
+  },
+  {
+    args: makeArgs({deadline_height: undefined}),
+    description: 'The target deadline is expected',
+    error: 'ExpectedSweepConfirmationDeadlineHeightInPendingSweep',
+  },
+  {
+    args: makeArgs({immediate: undefined}),
+    description: 'The immediate status is expected',
+    error: 'ExpectedImmediateStatusOfSweepInPendingSweeps',
+  },
+  {
+    args: makeArgs({outpoint: undefined}),
+    description: 'The outpoint being swept is expected',
+    error: 'ExpectedUnspentOutpointOfSweepInPendingSweeps',
+  },
+  {
+    args: makeArgs({outpoint: {}}),
+    description: 'The outpoint vout being swept is expected',
+    error: 'ExpectedOutputIndexOfSweepInPendingSweeps',
+  },
+  {
+    args: makeArgs({outpoint: {output_index: 0}}),
+    description: 'The outpoint transaction id being swept is expected',
+    error: 'ExpectedOutpointTransactionIdHexStringInSweep',
+  },
+  {
+    args: makeArgs({requested_sat_per_vbyte: undefined}),
+    description: 'The requested sweeping chain fee rate is expected',
+    error: 'ExpectedRequestedSatPerVByteForSweepInPendingSweeps',
+  },
+  {
+    args: makeArgs({sat_per_vbyte: undefined}),
+    description: 'The sweeping chain fee rate is expected',
+    error: 'ExpectedSatPerVByteForSweepInPendingSweeps',
+  },
+  {
+    args: makeArgs({}),
+    description: 'RPC sweep is mapped to pending sweep details',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({
+      budget: '1',
+      deadline_height: 1,
+      requested_sat_per_vbyte: '1',
+      sat_per_vbyte: '1',
+    }),
+    description: 'RPC sweep with all details is mapped to pending sweep ',
+    expected: makeExpected({
+      current_fee_rate: 1,
+      initial_fee_rate: 1,
+      max_fee: 1,
+      max_height: 1,
+    }),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => rpcSweepAsSweep(args), new Error(error), 'Got err');
+    } else {
+      deepEqual(rpcSweepAsSweep(args), expected, 'RPC sweep mapped');
+    }
+
+    return end();
+  });
+});