ln-accounting 10.0.8 → 10.0.9

package/test/harmony/test_forwards_as_records.js

@@ -1,52 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const test = require('node:test');
-const {throws} = require('node:assert').strict;
-
-const {forwardsAsRecords} = require('./../../harmony');
-
-const date = new Date().toISOString();
-
-const tests = [
-  {
-    args: {
-      forwards: [{
-        created_at: date,
-        fee: 1,
-        incoming_channel: 'incoming',
-        outgoing_channel: 'outgoing',
-        tokens: 2,
-      }]
-    },
-    description: 'Forwards as records',
-    expected: {
-      records: [{
-        amount: 1,
-        category: 'forwards',
-        created_at: date,
-        from_id: 'incoming',
-        notes: '2',
-        to_id: 'outgoing',
-        type: 'income',
-      }],
-    },
-  },
-  {
-    args: {},
-    description: 'Array of forwards required',
-    error: 'ExpectedArrayOfForwardsToFormatAsAccountingRecords',
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, (t, end) => {
-    if (!!error) {
-      throws(() => forwardsAsRecords(args), new Error(error), 'Got error');
-    } else {
-      const {records} = forwardsAsRecords(args);
-
-      deepEqual(records, expected.records, 'Forwards formatted as records');
-    }
-
-    return end();
-  });
-});

package/test/harmony/test_harmonize.js

@@ -1,24 +0,0 @@
-const test = require('node:test');
-const {throws} = require('node:assert').strict;
-
-const {harmonize} = require('./../../harmony');
-
-const tests = [
-  {
-    args: {},
-    description: 'Records are required',
-    error: 'ExpectedRecordsToConvertToHarmonyFormat',
-  },
-];
-
-tests.forEach(({args, description, error}) => {
-  return test(description, (t, end) => {
-    if (!!error) {
-      throws(() => harmonize(args), new Error(error), 'Got error');
-    } else {
-      harmonize(args);
-    }
-
-    return end();
-  });
-});

package/test/harmony/test_invoices_as_records.js

@@ -1,77 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const test = require('node:test');
-const {throws} = require('node:assert').strict;
-
-const {invoicesAsRecords} = require('./../../harmony');
-
-const date = new Date().toISOString();
-
-const tests = [
-  {
-    args: {
-      invoices: [{
-        confirmed_at: date,
-        created_at: date,
-        description: 'description',
-        id: 'id',
-        is_confirmed: true,
-        payments: [],
-        received: 1,
-      }],
-    },
-    description: 'Invoices as records',
-    expected: {
-      records: [{
-        amount: 1,
-        category: 'invoices',
-        created_at: date,
-        id: 'id',
-        notes: 'description',
-        type: 'income',
-      }],
-    },
-  },
-  {
-    args: {
-      invoices: [{
-        confirmed_at: date,
-        created_at: date,
-        description: '',
-        id: 'id',
-        is_confirmed: true,
-        payments: [{messages: [{type: '5482373484'}]}],
-        received: 1,
-      }],
-    },
-    description: 'Push payment is represented',
-    expected: {
-      records: [{
-        amount: 1,
-        category: 'invoices',
-        created_at: date,
-        id: 'id',
-        notes: '[Push Payment]',
-        type: 'income',
-      }],
-    },
-  },
-  {
-    args: {},
-    description: 'Expects array of invoices',
-    error: 'ExpectedArrayOfInvoicesToMapToAccountingRecords',
-  }
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, (t, end) => {
-    if (!!error) {
-      throws(() => invoicesAsRecords(args), new Error(error), 'Got error');
-    } else {
-      const {records} = invoicesAsRecords(args);
-
-      deepEqual(records, expected.records, 'Forwards formatted as records');
-    }
-
-    return end();
-  });
-});

package/test/harmony/test_notes_for_chain_transaction.js

@@ -1,43 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-
-const notesForChainTx = require('./../../harmony/notes_for_chain_transaction');
-
-const tests = [
-  {
-    args: {
-      output_addresses: ['a', 'b'],
-      transaction: '010000000001010cb9318f1cbe8688e71ca9e61a9b2e361d1fb47adf92ee4152d274f15cca2ebd00000000232200206f569f1dcbb18b78883398b66a52c7c50938119ed4567cc3c2e5bb6d7b36c65000000000016d26000000000000160014362a2872a1c9988ef71c31bb332dfff68d895f0d0347304402207651e5bfabb17ec044f7e3cafc4817df07c3d81a72cdcdc4706f20bf0a1ff01302206b08d9f5ac317279b30b597dd91ddddc07d9f6c82b42a47e4453ff2ae9d6eafa01006a8201208763a914d1a70126ff7a149ca6f9b638db084480440ff8428821000000000000000000000000000000000000000000000000000000000000000000677503fbfa17b175210280a5a994052abe443adb74851387b389386306c690a94ddf3bfd71234cd2a72b68acfbfa1700',
-    },
-    description: 'Notes for timeout sweep are returned',
-    expected: {notes: 'Submarine swap failure, swept out to a b'},
-  },
-  {
-    args: {
-      output_addresses: ['a', 'b'],
-      transaction: '020000000001010cb9318f1cbe8688e71ca9e61a9b2e361d1fb47adf92ee4152d274f15cca2ebd000000000000000000018826000000000000160014362a2872a1c9988ef71c31bb332dfff68d895f0d0347304402203f4e9e57ac637980d380ecd634db6ff42a7def7086f0e08391c51a595bbd67cb022036010e360ef844381a6d271505d809e4cc9ca783dc6859aeae02f1de04df2c78012000000000000000000000000000000000000000000000000000000000000000006a8201208763a914b8bcb07f6344b42ab04250c86a6e8b75d3fdbbc68821020ffb4c13e0f3547a1c9b98fe8b0430643b6a4c5f49985f3dbe11564898f7040e67750327fc17b1752102e8442ed17709432b996d70838a686cbd990f19c559ea0d04e319d27ceb135b9568acfbfa1700',
-    },
-    description: 'Notes for successful sweep are returned',
-    expected: {notes: 'Submarine swap success, swept out to a b'},
-  },
-  {
-    args: {output_addresses: ['a', 'b']},
-    description: 'Notes are returned',
-    expected: {notes: 'Outputs to a b'},
-  },
-  {
-    args: {description: 'description', output_addresses: ['a', 'b']},
-    description: 'Notes with description are returned',
-    expected: {notes: 'description - Outputs to a b'},
-  },
-];
-
-tests.forEach(({args, description, expected}) => {
-  return test(description, (t, end) => {
-    const {notes} = notesForChainTx(args);
-
-    equal(notes, expected.notes, 'Notes for chain transaction');
-
-    return end();
-  });
-});

package/test/harmony/test_payments_as_records.js

@@ -1,159 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {paymentsAsRecords} = require('./../../harmony');
-
-const date = new Date().toISOString();
-
-const tests = [
-  {
-    args: {
-      payments: [{
-        created_at: date,
-        destination: 'destination',
-        fee: 1,
-        id: 'id',
-        secret: 'secret',
-        tokens: 2,
-      }],
-    },
-    description: 'Payments as records',
-    expected: {
-      records: [
-        {
-          amount: -2,
-          category: 'payments',
-          created_at: date,
-          id: 'id',
-          notes: 'secret',
-          to_id: 'destination',
-          type: 'spend',
-        },
-        {
-          amount: -1,
-          category: 'payments',
-          created_at: date,
-          id: 'id:fee',
-          notes: 'Routing fee',
-          type: 'fee:network',
-        },
-      ],
-    },
-  },
-  {
-    args: {
-      payments: [{
-        created_at: date,
-        destination: 'destination',
-        fee: 1,
-        id: 'id',
-        request: 'lnbc1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdpl2pkx2ctnv5sxxmmwwd5kgetjypeh2ursdae8g6twvus8g6rfwvs8qun0dfjkxaq8rkx3yf5tcsyz3d73gafnh3cax9rn449d9p5uxz9ezhhypd0elx87sjle52x86fux2ypatgddc6k63n7erqz25le42c4u4ecky03ylcqca784w',
-        secret: 'secret',
-        tokens: 2,
-      }],
-    },
-    description: 'Payments as records',
-    expected: {
-      records: [
-        {
-          amount: -2,
-          category: 'payments',
-          created_at: date,
-          id: 'id',
-          notes: 'Please consider supporting this project',
-          to_id: 'destination',
-          type: 'spend',
-        },
-        {
-          amount: -1,
-          category: 'payments',
-          created_at: date,
-          id: 'id:fee',
-          notes: 'Routing fee',
-          type: 'fee:network',
-        },
-      ],
-    },
-  },
-  {
-    args: {
-      payments: [{
-        created_at: date,
-        destination: 'destination',
-        fee: 1,
-        id: 'id',
-        request: 'request',
-        secret: 'secret',
-        tokens: 2,
-      }],
-    },
-    description: 'Payments as records when the request is weird',
-    expected: {
-      records: [
-        {
-          amount: -2,
-          category: 'payments',
-          created_at: date,
-          id: 'id',
-          notes: 'secret',
-          to_id: 'destination',
-          type: 'spend',
-        },
-        {
-          amount: -1,
-          category: 'payments',
-          created_at: date,
-          id: 'id:fee',
-          notes: 'Routing fee',
-          type: 'fee:network',
-        },
-      ],
-    },
-  },
-  {
-    args: {
-      payments: [{
-        created_at: date,
-        destination: 'destination',
-        fee: 1,
-        id: 'id',
-        request: 'request',
-        secret: 'secret',
-        tokens: 2,
-      }],
-      public_key: 'destination'
-    },
-    description: 'Circular payments are represented',
-    expected: {
-      records: [
-        {
-          amount: -2,
-          category: 'payments',
-          created_at: date,
-          id: 'id',
-          notes: '[To Self] secret',
-          to_id: 'destination',
-          type: 'spend',
-        },
-        {
-          amount: -1,
-          category: 'payments',
-          created_at: date,
-          id: 'id:fee',
-          notes: 'Circular payment routing fee',
-          type: 'fee:network',
-        },
-      ],
-    },
-  },
-];
-
-tests.forEach(({args, description, expected}) => {
-  return test(description, (t, end) => {
-    const {records} = paymentsAsRecords(args);
-
-    deepEqual(records, expected.records, 'Forwards formatted as records');
-
-    return end();
-  });
-});

package/test/harmony/test_records_with_fiat.js

@@ -1,112 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const test = require('node:test');
-const {throws} = require('node:assert').strict;
-
-const {recordsWithFiat} = require('./../../harmony');
-
-const date = new Date().toISOString();
-
-const tests = [
-  {
-    args: {
-      currency: 'BTC',
-      fiat: [{date, cents: 123456}],
-      records: [{
-        amount: 1e8,
-        category: 'category',
-        created_at: date,
-        id: 'id',
-        type: 'type',
-      }],
-    },
-    description: 'Add fiat values to records',
-    expected: {
-      records: [{
-        amount: 1e8,
-        asset: 'BTC',
-        category: 'category',
-        created_at: date,
-        external_id: '',
-        fiat_amount: 1234.56,
-        from_id: '',
-        id: 'id',
-        notes: '',
-        to_id: '',
-        type: 'type',
-      }],
-    },
-  },
-  {
-    args: {
-      currency: 'BTC',
-      fiat: [{date, cents: 123456}],
-      records: [{
-        category: 'category',
-        created_at: date,
-        type: 'type',
-      }],
-    },
-    description: 'Add fiat values to records',
-    expected: {
-      records: [{
-        amount: 0,
-        asset: 'BTC',
-        category: 'category',
-        created_at: date,
-        external_id: '',
-        fiat_amount: 0,
-        from_id: '',
-        id: '',
-        notes: '',
-        to_id: '',
-        type: 'type',
-      }],
-    },
-  },
-  {
-    args: {
-      currency: 'BTC',
-      fiat: [],
-      records: [{
-        category: 'category',
-        created_at: date,
-        type: 'type',
-      }],
-    },
-    description: 'No fiat is known',
-    expected: {
-      records: [{
-        amount: 0,
-        asset: 'BTC',
-        category: 'category',
-        created_at: date,
-        external_id: '',
-        fiat_amount: undefined,
-        from_id: '',
-        id: '',
-        notes: '',
-        to_id: '',
-        type: 'type',
-      }],
-    },
-  },
-  {
-    args: {},
-    description: 'Records are required',
-    error: 'ExpectedArrayOfRecordsToMapToFiatRecords',
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, (t, end) => {
-    if (!!error) {
-      throws(() => recordsWithFiat(args), new Error(error), 'Got error');
-    } else {
-      const {records} = recordsWithFiat(args);
-
-      deepEqual(records, expected.records, 'Fiat added to records');
-    }
-
-    return end();
-  });
-});

package/test/records/test_get_all_invoices.js

@@ -1,105 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const {rejects} = require('node:assert').strict;
-const test = require('node:test');
-
-const {getAllInvoices} = require('./../../records');
-
-const tests = [
-  {
-    args: {},
-    description: 'LND is required',
-    error: [400, 'ExpectedLndToGetAllInvoices'],
-  },
-  {
-    args: {lnd: {default: {listInvoices: ({}, cbk) => cbk('err')}}},
-    description: 'Errors from LND are passed back',
-    error: [503, 'UnexpectedGetInvoicesError', {err: 'err'}],
-  },
-  {
-    args: {
-      lnd: {
-        default: {
-          listInvoices: (args, cbk) => {
-            if (!!args.index_offset) {
-              return cbk(null, {
-                first_index_offset: '1',
-                invoices: [],
-                last_index_offset: '1',
-              });
-            }
-
-            return cbk(null, {
-              first_index_offset: '2',
-              invoices: [{
-                add_index: '0',
-                amt_paid_msat: '1000',
-                amt_paid_sat: '1',
-                cltv_expiry: 1,
-                creation_date: 1,
-                description_hash: Buffer.alloc(32),
-                expiry: 1,
-                features: {},
-                htlcs: [],
-                memo: '',
-                payment_addr: Buffer.alloc(32),
-                payment_request: 'request',
-                private: false,
-                r_hash: Buffer.alloc(32),
-                r_preimage: Buffer.alloc(32),
-                settle_date: 1,
-                settled: true,
-                state: 'SETTLED',
-                value: '1',
-                value_msat: '1000',
-              }],
-              last_index_offset: '5',
-            });
-          },
-        },
-      },
-    },
-    description: 'Invoices are returned',
-    expected: {
-      invoices: [{
-        chain_address: undefined,
-        cltv_delta: 1,
-        confirmed_at: '1970-01-01T00:00:01.000Z',
-        confirmed_index: undefined,
-        created_at: '1970-01-01T00:00:01.000Z',
-        description: '',
-        description_hash: '0000000000000000000000000000000000000000000000000000000000000000',
-        expires_at: '1970-01-01T00:00:02.000Z',
-        features: [],
-        id: '0000000000000000000000000000000000000000000000000000000000000000',
-        index: 0,
-        is_canceled: undefined,
-        is_confirmed: true,
-        is_held: undefined,
-        is_private: false,
-        is_push: undefined,
-        mtokens: '1000',
-        payment: undefined,
-        payments: [],
-        received: 1,
-        received_mtokens: '1000',
-        request: 'request',
-        secret: '0000000000000000000000000000000000000000000000000000000000000000',
-        tokens: 1,
-      }],
-    },
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async () => {
-    if (!!error) {
-      await rejects(getAllInvoices(args), error, 'Got expected error');
-    } else {
-      const {invoices} = await getAllInvoices(args);
-
-      deepEqual(invoices, expected.invoices, 'Got expected result');
-    }
-
-    return;
-  });
-});