ln-accounting 10.0.7 → 10.0.9

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;
-  });
-});

package/test/records/test_get_all_payments.js

@@ -1,274 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const {rejects} = require('node:assert').strict;
-const test = require('node:test');
-
-const {getAllPayments} = require('./../../records');
-
-const tests = [
-  {
-    args: {},
-    description: 'LND is required',
-    error: [400, 'ExpectedLndToGetAllPayments'],
-  },
-  {
-    args: {lnd: {default: {listPayments: ({}, cbk) => cbk('err')}}},
-    description: 'Errors from LND are passed back',
-    error: [503, 'UnexpectedGetPaymentsError', {err: 'err'}],
-  },
-  {
-    args: {
-      lnd: {
-        default: {
-          listPayments: (args, cbk) => {
-            if (!!args.index_offset) {
-              return cbk(null, {
-                first_index_offset: '1',
-                payments: [],
-                last_index_offset: '1',
-              });
-            }
-
-            return cbk(null, {
-              first_index_offset: '2',
-              payments: [{
-                creation_date: '1',
-                creation_time_ns: '0',
-                failure_reason: 'FAILURE_REASON_TIMEOUT',
-                fee_msat: '1000',
-                fee_sat: '1',
-                htlcs: [{
-                  attempt_time_ns: '1000000',
-                  failure: {
-                    channel_update: {
-                      base_fee: '1000',
-                      chain_hash: Buffer.alloc(32),
-                      chan_id: '1',
-                      channel_flags: 1,
-                      extra_opaque_data: Buffer.alloc(1),
-                      fee_rate: 1,
-                      htlc_maximum_msat: '1000',
-                      htlc_minimum_msat: '1000',
-                      message_flags: 1,
-                      signature: Buffer.alloc(71),
-                      time_lock_delta: 1,
-                      timestamp: 1,
-                    },
-                    code: 'UNREADABLE_FAILURE',
-                    failure_source_index1: 1,
-                    height: 1,
-                    htlc_msat: '1000',
-                  },
-                  resolve_time_ns: '1000000',
-                  route: {
-                    hops: [
-                      {
-                        amt_to_forward_msat: '1000',
-                        chan_id: '1',
-                        chan_capacity: 1,
-                        expiry: 1,
-                        fee_msat: '1000',
-                        mpp_record: {
-                          payment_addr: Buffer.alloc(32),
-                          total_amt_msat: '1000',
-                        },
-                        pub_key: Buffer.alloc(33).toString('hex'),
-                        tlv_payload: true,
-                      },
-                      {
-                        amt_to_forward_msat: '1000',
-                        chan_id: '1',
-                        chan_capacity: 1,
-                        expiry: 1,
-                        fee_msat: '1000',
-                        mpp_record: {
-                          payment_addr: Buffer.alloc(32),
-                          total_amt_msat: '1000',
-                        },
-                        pub_key: Buffer.alloc(33).toString('hex'),
-                        tlv_payload: true,
-                      },
-                    ],
-                    total_amt: '1',
-                    total_amt_msat: '1000',
-                    total_fees: '1',
-                    total_fees_msat: '1000',
-                    total_time_lock: 1,
-                  },
-                  status: 'FAILED',
-                }],
-                path: [Buffer.alloc(33).toString('hex'), Buffer.alloc(33).toString('hex')],
-                payment_hash: Buffer.alloc(32).toString('hex'),
-                payment_index: '1',
-                payment_preimage: Buffer.alloc(32, 1).toString('hex'),
-                payment_request: 'lntb1500n1pdn4czkpp5ugdqer05qrrxuchrzkcue94th9w2xzasp9qm7d0yxcgp4uh4kn4qdpa2fjkzep6yprkcmmzv9kzqsmj09c8gmmrw4e8yetwvdujq5n9va6kcct5d9hkucqzysdlghdpua7uvjjkcfj49psxtlqzkp5pdncffdfk2cp3mp76thrl29qhqgzufm503pjj96586n5w6edgw3n66j4rxxs707y4zdjuhyt6qqe5weu4',
-                status: 'SUCCEEDED',
-                value: '1',
-                value_msat: '1000',
-                value_sat: '1',
-              }],
-              last_index_offset: '5',
-            });
-          },
-        },
-      },
-    },
-    description: 'Payments are returned',
-    expected: {
-      payments: [{
-        attempts: [{
-          confirmed_at: undefined,
-          created_at: '1970-01-01T00:00:00.001Z',
-          failed_at: '1970-01-01T00:00:00.001Z',
-          is_confirmed: false,
-          is_failed: true,
-          is_pending: false,
-          route: {
-            fee: 1,
-            fee_mtokens: '1000',
-            hops: [
-              {
-                channel: '0x0x1',
-                fee: 1,
-                fee_mtokens: '1000',
-                forward: 1,
-                forward_mtokens: '1000',
-                public_key: Buffer.alloc(33).toString('hex'),
-                timeout: 1,
-              },
-              {
-                channel: '0x0x1',
-                fee: 1,
-                fee_mtokens: '1000',
-                forward: 1,
-                forward_mtokens: '1000',
-                public_key: Buffer.alloc(33).toString('hex'),
-                timeout: 1,
-              },
-            ],
-            mtokens: '1000',
-            payment: Buffer.alloc(32).toString('hex'),
-            timeout: 1,
-            tokens: 1,
-            total_mtokens: '1000',
-          },
-        }],
-        confirmed_at: undefined,
-        created_at: '1970-01-01T00:00:01.000Z',
-        destination: Buffer.alloc(33).toString('hex'),
-        fee: 1,
-        fee_mtokens: '1000',
-        hops: [Buffer.alloc(33).toString('hex')],
-        id: Buffer.alloc(32).toString('hex'),
-        index: 1,
-        is_confirmed: true,
-        is_outgoing: true,
-        mtokens: '1000',
-        request: 'lntb1500n1pdn4czkpp5ugdqer05qrrxuchrzkcue94th9w2xzasp9qm7d0yxcgp4uh4kn4qdpa2fjkzep6yprkcmmzv9kzqsmj09c8gmmrw4e8yetwvdujq5n9va6kcct5d9hkucqzysdlghdpua7uvjjkcfj49psxtlqzkp5pdncffdfk2cp3mp76thrl29qhqgzufm503pjj96586n5w6edgw3n66j4rxxs707y4zdjuhyt6qqe5weu4',
-        safe_fee: 1,
-        safe_tokens: 1,
-        secret: Buffer.alloc(32, 1).toString('hex'),
-        tokens: 1,
-      }],
-    },
-  },
-  {
-    args: {
-      after: new Date().toISOString(),
-      lnd: {
-        default: {
-          listPayments: (args, cbk) => {
-            if (!!args.index_offset) {
-              return cbk(null, {
-                first_index_offset: '1',
-                payments: [],
-                last_index_offset: '1',
-              });
-            }
-
-            return cbk(null, {
-              first_index_offset: '2',
-              payments: [{
-                creation_date: '1',
-                creation_time_ns: '0',
-                failure_reason: 'FAILURE_REASON_TIMEOUT',
-                fee_msat: '1000',
-                fee_sat: '1',
-                htlcs: [{
-                  attempt_time_ns: '1000000',
-                  failure: {
-                    channel_update: {
-                      base_fee: '1000',
-                      chain_hash: Buffer.alloc(32),
-                      chan_id: '1',
-                      channel_flags: 1,
-                      extra_opaque_data: Buffer.alloc(1),
-                      fee_rate: 1,
-                      htlc_maximum_msat: '1000',
-                      htlc_minimum_msat: '1000',
-                      message_flags: 1,
-                      signature: Buffer.alloc(71),
-                      time_lock_delta: 1,
-                      timestamp: 1,
-                    },
-                    code: 'UNREADABLE_FAILURE',
-                    failure_source_index1: 1,
-                    height: 1,
-                    htlc_msat: '1000',
-                  },
-                  resolve_time_ns: '1000000',
-                  route: {
-                    hops: [{
-                      amt_to_forward_msat: '1000',
-                      chan_id: '1',
-                      chan_capacity: 1,
-                      expiry: 1,
-                      fee_msat: '1000',
-                      mpp_record: {
-                        payment_addr: Buffer.alloc(32),
-                        total_amt_msat: '1000',
-                      },
-                      pub_key: Buffer.alloc(33).toString('hex'),
-                      tlv_payload: true,
-                    }],
-                    total_amt: '1',
-                    total_amt_msat: '1000',
-                    total_fees: '1',
-                    total_fees_msat: '1000',
-                    total_time_lock: 1,
-                  },
-                  status: 'FAILED',
-                }],
-                path: [Buffer.alloc(33).toString('hex'), Buffer.alloc(33).toString('hex')],
-                payment_hash: Buffer.alloc(32).toString('hex'),
-                payment_index: '1',
-                payment_preimage: Buffer.alloc(32).toString('hex'),
-                payment_request: 'lntb1500n1pdn4czkpp5ugdqer05qrrxuchrzkcue94th9w2xzasp9qm7d0yxcgp4uh4kn4qdpa2fjkzep6yprkcmmzv9kzqsmj09c8gmmrw4e8yetwvdujq5n9va6kcct5d9hkucqzysdlghdpua7uvjjkcfj49psxtlqzkp5pdncffdfk2cp3mp76thrl29qhqgzufm503pjj96586n5w6edgw3n66j4rxxs707y4zdjuhyt6qqe5weu4',
-                status: 'FAILED',
-                value: '1',
-                value_msat: '1000',
-                value_sat: '1',
-              }],
-              last_index_offset: '5',
-            });
-          },
-        },
-      },
-    },
-    description: 'Payments are returned with after condition',
-    expected: {payments: []},
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async () => {
-    if (!!error) {
-      await rejects(getAllPayments(args), error, 'Got expected error');
-    } else {
-      const {payments} = await getAllPayments(args);
-
-      deepEqual(payments, expected.payments, 'Got expected result');
-    }
-
-    return;
-  });
-});