ln-accounting 10.0.7 → 10.0.9

package/CHANGELOG.md

@@ -1,6 +1,9 @@
 # Versions
 
-## Version 10.0.7
+## Version 10.0.9
+
+- `getAccountingReport`: Fix channel funding and close transactions being
+    reported as chain sends and receives
 
 ### Breaking Changes
 

package/esplora/get_esplora_vout.js

@@ -1,7 +1,6 @@
 const asyncAuto = require('async/auto');
 const {returnResult} = require('asyncjs-util');
 
-const dateFromEpoch = epoch => new Date(epoch * 1e3).toISOString();
 const {isArray} = Array;
 const url = (api, id) => `${api}tx/${id}`;
 

package/package.json

@@ -1,27 +1,41 @@
 {
   "allowScripts": {
-    "protobufjs@7.6.6": true
+    "protobufjs@7.6.6": true,
+    "cpu-features@0.0.10": true,
+    "ssh2@1.17.0": true
   },
   "author": {
     "name": "Alex Bosworth",
-    "url": "https://twitter.com/alexbosworth"
+    "url": "https://x.com/alexbosworth"
   },
   "bugs": {
     "url": "https://github.com/alexbosworth/ln-accounting/issues"
   },
   "dependencies": {
-    "@alexbosworth/blockchain": "4.8.0",
-    "@alexbosworth/formulas": "1.4.0",
+    "@alexbosworth/blockchain": "4.11.0",
+    "@alexbosworth/formulas": "1.5.0",
     "@json2csv/plainjs": "7.0.8",
     "async": "3.2.6",
     "asyncjs-util": "1.2.12",
-    "goldengate": "16.0.7",
-    "ln-service": "59.5.0"
+    "goldengate": "16.0.9",
+    "ln-service": "60.1.6"
   },
   "description": "lnd accounting reports",
+  "devDependencies": {
+    "ln-docker-daemons": "8.1.2"
+  },
   "engines": {
     "node": ">=22"
   },
+  "files": [
+    "CHANGELOG.md",
+    "esplora",
+    "fiat",
+    "harmony",
+    "index.js",
+    "records",
+    "report"
+  ],
   "keywords": [
     "accounting",
     "lightning-network",
@@ -34,7 +48,8 @@
     "url": "git+https://github.com/alexbosworth/ln-accounting.git"
   },
   "scripts": {
-    "test": "node --experimental-test-coverage --test"
+    "integration-tests": "node --test 'test/integration/*.js'",
+    "test": "node --experimental-test-coverage --test-coverage-exclude='test/**' --test-coverage-branches=100 --test-coverage-functions=100 --test-coverage-lines=100 --test 'test/!(integration)/**/*.js'"
   },
-  "version": "10.0.7"
+  "version": "10.0.9"
 }

package/report/get_accounting_report.js

@@ -301,7 +301,10 @@ module.exports = (args, cbk) => {
         const closeIds = channels.map(n => n.close_transaction_id);
         const transactionIds = channels.map(n => n.transaction_id);
 
-        const ids = [].concat(closeIds).concat(transactionIds).map(n => !!n);
+        const ids = []
+          .concat(closeIds)
+          .concat(transactionIds)
+          .filter(n => !!n);
 
         return cbk(null, ids);
       }],

package/.gitattributes

@@ -1 +0,0 @@
-package-lock.json binary

package/.tm_properties

@@ -1 +0,0 @@
-exclude = '{$exclude,node_modules,*~}'

package/.travis.yml

@@ -1,15 +0,0 @@
-language: node_js
-
-node_js:
-  - 12
-  - 10
-
-os:
-  - linux
-
-cache:
-  directories:
-    - $HOME/.npm
-
-notifications:
-  email: false

package/blockstream/get_blockstream_tx.js

@@ -1,94 +0,0 @@
-const asyncAuto = require('async/auto');
-const {returnResult} = require('asyncjs-util');
-
-const dateFromEpoch = epoch => new Date(epoch * 1e3).toISOString();
-const net = network => network === 'btctestnet' ? 'testnet/' : '';
-const {isArray} = Array;
-const supportedNetworks = ['btc', 'btctestnet'];
-const url = (net, id) => `https://blockstream.info/${net}api/tx/${id}`;
-
-/** Get transaction details from Blockstream
-
-  {
-    id: <Transaction Id Hex String>
-    [network]: <Network Name String>
-    request: <Request Function>
-  }
-
-  @returns via cbk or Promise
-  {
-    [confirmation_height]: <Confirmed In Block At Height Number>
-    [created_at]: <Transaction Confirmation Date ISO 8601 Date String>
-    [block_id]: <Confirmed In Block With Hash Hex String>
-    fee: <Transaction Fee Tokens Number>
-    output_addresses: [<Output Address String>]
-  }
-*/
-module.exports = ({id, network, request, vout}, cbk) => {
-  return new Promise((resolve, reject) => {
-    return asyncAuto({
-      // Check argument
-      validate: cbk => {
-        if (!id) {
-          return cbk([400, 'ExpectedTransactionIdToGetBlockstreamTxFee']);
-        }
-
-        if (!!network && !supportedNetworks.includes(network)) {
-          return cbk([400, 'UnsupportedNetworkToGetBlockstreamTxFee']);
-        }
-
-        if (!request) {
-          return cbk([400, 'ExpectedRequestFunctionToGetBlockstreamTxFee']);
-        }
-
-        return cbk();
-      },
-
-      // Get tx details
-      getDetails: ['validate', ({}, cbk) => {
-        return request({
-          json: true,
-          url: url(net(network), id),
-        },
-        (err, r, body) => {
-          if (!!err) {
-            return cbk([503, 'UnexpectedErrorGettingBlockstreamTxFee', {err}]);
-          }
-
-          if (!body) {
-            return cbk([503, 'ExpectedTxLookupResultForBlockstreamTxFee']);
-          }
-
-          if (body.fee === undefined) {
-            return cbk([503, 'ExpectedTransactionFeeInResultFromBlockstream']);
-          }
-
-          if (!body.status) {
-            return cbk([503, 'ExpectedStatusOfBlockstreamTransaction']);
-          }
-
-          if (!isArray(body.vout)) {
-            return cbk([503, 'ExpectedOutputsInBlockstreamTransaction']);
-          }
-
-          // Exit early when transaction is not confirmed
-          if (!body.status.confirmed) {
-            return cbk(null, {
-              fee: body.fee,
-              output_addresses: body.vout.map(n => n.scriptpubkey_address),
-            });
-          }
-
-          return cbk(null, {
-            block_id: body.status.block_hash,
-            confirmation_height: body.status.block_height,
-            created_at: dateFromEpoch(body.status.block_time),
-            fee: body.fee,
-            output_addresses: body.vout.map(n => n.scriptpubkey_address),
-          });
-        });
-      }],
-    },
-    returnResult({reject, resolve, of: 'getDetails'}, cbk));
-  });
-};

package/blockstream/get_blockstream_vout.js

@@ -1,80 +0,0 @@
-const asyncAuto = require('async/auto');
-const {returnResult} = require('asyncjs-util');
-
-const net = network => network === 'btctestnet' ? 'testnet/' : '';
-const {isArray} = Array;
-const supportedNetworks = ['btc', 'btctestnet'];
-const url = (net, id) => `https://blockstream.info/${net}api/tx/${id}`;
-
-/** Get tx vout details from Blockstream
-
-  {
-    id: <Transaction Id Hex String>
-    [network]: <Network Name String>
-    request: <Request Function>
-    vout: <Transaction Output Index Number>
-  }
-
-  @returns via cbk or Promise
-  {
-    tokens: <Transaction Output Tokens Number>
-  }
-*/
-module.exports = ({id, network, request, vout}, cbk) => {
-  return new Promise((resolve, reject) => {
-    return asyncAuto({
-      // Check argument
-      validate: cbk => {
-        if (!id) {
-          return cbk([400, 'ExpectedTransactionIdToGetBlockstreamVout']);
-        }
-
-        if (!!network && !supportedNetworks.includes(network)) {
-          return cbk([400, 'UnsupportedNetworkToGetBlockstreamVout']);
-        }
-
-        if (!request) {
-          return cbk([400, 'ExpectedRequestFunctionToGetBlockstreamVout']);
-        }
-
-        if (vout === undefined) {
-          return cbk([400, 'ExpectedTransactionOutputIndexToGetVoutDetails']);
-        }
-
-        return cbk();
-      },
-
-      // Get tx details
-      getDetails: ['validate', ({}, cbk) => {
-        return request({
-          json: true,
-          url: url(net(network), id),
-        },
-        (err, r, body) => {
-          if (!!err) {
-            return cbk([503, 'UnexpectedErrorGettingBlockstreamTx', {err}]);
-          }
-
-          if (!body) {
-            return cbk([503, 'ExpectedTxLookupResultForBlockstreamTx']);
-          }
-
-          if (!isArray(body.vout)) {
-            return cbk([503, 'ExpectedOutputsArrayForBlockstreamTx']);
-          }
-
-          if (!body.vout[vout]) {
-            return cbk([503, 'ExpectedOutputInBlockstreamTxDetails']);
-          }
-
-          if (!body.vout[vout].value) {
-            return cbk([503, 'ExpectedOutputValueInBlockstreamTxDetails']);
-          }
-
-          return cbk(null, {tokens: body.vout[vout].value});
-        });
-      }],
-    },
-    returnResult({reject, resolve, of: 'getDetails'}, cbk));
-  });
-};

package/blockstream/index.js

@@ -1,4 +0,0 @@
-const getBlockstreamTx = require('./get_blockstream_tx');
-const getBlockstreamVout = require('./get_blockstream_vout');
-
-module.exports = {getBlockstreamTx, getBlockstreamVout};

package/test/blockstream/test_get_blockstream_tx.js

@@ -1,111 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const {rejects} = require('node:assert').strict;
-const test = require('node:test');
-
-const method = require('./../../blockstream/get_blockstream_tx');
-
-const makeArgs = overrides => {
-  const args = {
-    id: Buffer.alloc(32).toString('hex'),
-    network: 'btc',
-    request: ({}, cbk) => cbk(null, null, {
-      fee: 1,
-      status: {
-        block_hash: Buffer.alloc(32).toString('hex'),
-        block_height: 1,
-        block_time: 1,
-        confirmed: true,
-      },
-      vout: [{scriptpubkey_address: 'bc1zw508d6qejxtdg4y5r3zarvaryvg6kdaj'}],
-    }),
-  };
-
-  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
-
-  return args;
-};
-
-const tests = [
-  {
-    args: makeArgs({id: undefined}),
-    description: 'An id is required',
-    error: [400, 'ExpectedTransactionIdToGetBlockstreamTxFee'],
-  },
-  {
-    args: makeArgs({network: 'network'}),
-    description: 'A known network is required',
-    error: [400, 'UnsupportedNetworkToGetBlockstreamTxFee'],
-  },
-  {
-    args: makeArgs({request: undefined}),
-    description: 'A request method is required',
-    error: [400, 'ExpectedRequestFunctionToGetBlockstreamTxFee'],
-  },
-  {
-    args: makeArgs({request: ({}, cbk) => cbk('err')}),
-    description: 'Request errors are passed back',
-    error: [503, 'UnexpectedErrorGettingBlockstreamTxFee', {err: 'err'}],
-  },
-  {
-    args: makeArgs({request: ({}, cbk) => cbk()}),
-    description: 'A response body is expected',
-    error: [503, 'ExpectedTxLookupResultForBlockstreamTxFee'],
-  },
-  {
-    args: makeArgs({request: ({}, cbk) => cbk(null, null, {})}),
-    description: 'A transaction fee is required',
-    error: [503, 'ExpectedTransactionFeeInResultFromBlockstream'],
-  },
-  {
-    args: makeArgs({request: ({}, cbk) => cbk(null, null, {fee: 1})}),
-    description: 'Transaction status is required',
-    error: [503, 'ExpectedStatusOfBlockstreamTransaction'],
-  },
-  {
-    args: makeArgs({
-      request: ({}, cbk) => cbk(null, null, {fee: 1, status: {}}),
-    }),
-    description: 'A vout array is required',
-    error: [503, 'ExpectedOutputsInBlockstreamTransaction'],
-  },
-  {
-    args: makeArgs({
-      network: 'btctestnet',
-      request: ({}, cbk) => cbk(null, null, {
-        fee: 1,
-        status: {},
-        vout: [{scriptpubkey_address: 'bc1zw508d6qejxtdg4y5r3zarvaryvg6kdaj'}],
-      }),
-    }),
-    description: 'An unconfirmed tx is returned',
-    expected: {
-      fee: 1,
-      output_addresses: ['bc1zw508d6qejxtdg4y5r3zarvaryvg6kdaj'],
-    },
-  },
-  {
-    args: makeArgs({}),
-    description: 'Blockstream tx info is returned',
-    expected: {
-      confirmation_height: 1,
-      created_at: '1970-01-01T00:00:01.000Z',
-      block_id: Buffer.alloc(32).toString('hex'),
-      fee: 1,
-      output_addresses: ['bc1zw508d6qejxtdg4y5r3zarvaryvg6kdaj']
-    },
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async () => {
-    if (!!error) {
-      await rejects(method(args), error, 'Got expected error');
-    } else {
-      const res = await method(args);
-
-      deepEqual(res, expected, 'Got expected result');
-    }
-
-    return;
-  });
-});

package/test/fiat/test_get_coincap_historic_rate.js

@@ -1,86 +0,0 @@
-const {equal} = require('node:assert').strict;
-const {rejects} = require('node:assert').strict;
-const test = require('node:test');
-
-const method = require('./../../fiat/get_coincap_historic_rate');
-
-const date = new Date().toISOString();
-
-const api = ({}, cbk) => cbk(null, null, {data: [{date, priceUsd: 12.3401}]});
-
-const tests = [
-  {
-    args: {},
-    description: 'A currency code is required',
-    error: [400, 'UnsupportedCurrencyForCoincapFiatRateLookup'],
-  },
-  {
-    args: {currency: 'BTC'},
-    description: 'A date is required',
-    error: [400, 'ExpectedDateForHistoricCoincapRateLookup'],
-  },
-  {
-    args: {date, currency: 'BTC'},
-    description: 'A fiat code is required',
-    error: [400, 'UnsupportedFiatTypeForCoincapFiatRateLookup'],
-  },
-  {
-    args: {date, currency: 'BTC', fiat: 'USD'},
-    description: 'A request function is required',
-    error: [400, 'ExpectedRequestMethodForCoincapFiatRateLookup'],
-  },
-  {
-    args: {date, currency: 'BTC', fiat: 'USD', request: ({}, cbk) => cbk('e')},
-    description: 'A request error is returned',
-    error: [503, 'UnexpectedErrorGettingCoincapRate', {err: 'e'}],
-  },
-  {
-    args: {date, currency: 'BTC', fiat: 'USD', request: ({}, cbk) => cbk()},
-    description: 'A body is expected',
-    error: [503, 'UnexpectedResponseGettingCoincapRate'],
-  },
-  {
-    args: {
-      date,
-      currency: 'BTC',
-      fiat: 'USD',
-      request: ({}, cbk) => cbk(null, null, {data: [{}]}),
-    },
-    description: 'Price details are expected',
-    error: [503, 'ExpectedDateForPriceQuoteInCoincapResponse'],
-  },
-  {
-    args: {
-      date,
-      currency: 'BTC',
-      fiat: 'USD',
-      request: ({}, cbk) => cbk(null, null, {data: [{date}]}),
-    },
-    description: 'Fiat price is expected in response',
-    error: [503, 'ExpectedFiatPriceInCoincapResponse'],
-  },
-  {
-    args: {
-      date,
-      currency: 'BTC',
-      fiat: 'USD',
-      request: ({}, cbk) => api({}, cbk),
-    },
-    description: 'Get coincap historic rate',
-    expected: {cents: 1234},
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async () => {
-    if (!!error) {
-      await rejects(method(args), error, 'Got expected error');
-    } else {
-      const {cents} = await method(args);
-
-      equal(cents, expected.cents, 'Cents returned');
-    }
-
-    return;
-  });
-});

package/test/fiat/test_get_coindesk_historic_rate.js

@@ -1,80 +0,0 @@
-const {equal} = require('node:assert').strict;
-const {rejects} = require('node:assert').strict;
-const test = require('node:test');
-
-const method = require('./../../fiat/get_coindesk_historic_rate');
-
-const api = ({qs}, cbk) => {
-  const bpi = {};
-
-  bpi[qs.start] = 12.34;
-
-  return cbk(null, null, {bpi});
-};
-
-const tests = [
-  {
-    args: {},
-    description: 'A currency is required',
-    error: [400, 'UnsupportedCurrencyForCoindeskFiatRateLookup'],
-  },
-  {
-    args: {currency: 'BTC'},
-    description: 'A date is required',
-    error: [400, 'ExpectedDateForCoindeskRateLookup'],
-  },
-  {
-    args: {currency: 'BTC', date: new Date().toISOString()},
-    description: 'A currency type is required',
-    error: [400, 'UnsupportedFiatTypeForCoindeskFiatRateLookup'],
-  },
-  {
-    args: {currency: 'BTC', date: new Date().toISOString(), fiat: 'USD'},
-    description: 'A request method is required',
-    error: [400, 'ExpectedRequestMethodForCoindeskFiatRateLookup'],
-  },
-  {
-    args: {
-      date: new Date().toISOString(),
-      currency: 'BTC',
-      fiat: 'USD',
-      request: ({}, cbk) => cbk('err'),
-    },
-    description: 'Errors returned from coindesk request',
-    error: [503, 'UnexpectedErrorGettingHistoricRate', {err: 'err'}],
-  },
-  {
-    args: {
-      date: new Date().toISOString(),
-      currency: 'BTC',
-      fiat: 'USD',
-      request: ({}, cbk) => cbk(),
-    },
-    description: 'A body is expected in coindesk response',
-    error: [503, 'UnexpectedResponseInHistoricRateResponse'],
-  },
-  {
-    args: {
-      date: new Date().toISOString(),
-      currency: 'BTC',
-      fiat: 'USD',
-      request: ({qs}, cbk) => api({qs}, cbk),
-    },
-    description: 'Get coindesk historic rate',
-    expected: {cents: 1234},
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async () => {
-    if (!!error) {
-      await rejects(method(args), error, 'Got expected error');
-    } else {
-      const {cents} = await method(args);
-
-      equal(cents, expected.cents, 'Cents returned');
-    }
-
-    return;
-  });
-});

package/test/fiat/test_get_coingecko_historic_rate.js

@@ -1,89 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const {rejects} = require('node:assert').strict;
-const test = require('node:test');
-
-const method = require('./../../fiat/get_coingecko_historic_rate');
-
-const makeArgs = overrides => {
-  const args = {
-    date: new Date().toISOString(),
-    currency: 'BTC',
-    fiat: 'USD',
-    rates: {},
-    request: ({qs}, cbk) => api({qs}, cbk),
-  };
-
-  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
-
-  return args;
-};
-
-const api = ({qs}, cbk) => {
-  return cbk(null, null, {market_data: {current_price: {usd: 12.34}}});
-};
-
-const tests = [
-  {
-    args: makeArgs({currency: undefined}),
-    description: 'A currency is required',
-    error: [400, 'UnsupportedCurrencyForCoingeckoFiatRateLookup'],
-  },
-  {
-    args: makeArgs({date: undefined}),
-    description: 'A date is required',
-    error: [400, 'ExpectedDateForCoingeckoRateLookup'],
-  },
-  {
-    args: makeArgs({fiat: undefined}),
-    description: 'A fiat type is required',
-    error: [400, 'UnsupportedFiatTypeForCoingeckoFiatRateLookup'],
-  },
-  {
-    args: makeArgs({rates: undefined}),
-    description: 'A rates object is required',
-    error: [400, 'ExpectedKnownRatesForCoingeckoFiatRateLookup'],
-  },
-  {
-    args: makeArgs({request: undefined}),
-    description: 'A request method is required',
-    error: [400, 'ExpectedRequestMethodForCoingeckoFiatRateLookup'],
-  },
-  {
-    args: makeArgs({request: ({}, cbk) => cbk('err')}),
-    description: 'Errors returned from request',
-    error: [503, 'UnexpectedErrGettingCoingeckoPastRate', {err: 'err'}],
-  },
-  {
-    args: makeArgs({request: ({}, cbk) => cbk()}),
-    description: 'A body is expected in response',
-    error: [503, 'UnexpectedResponseInCoingeckoPastRateResponse'],
-  },
-  {
-    args: makeArgs({
-      request: ({}, cbk) => cbk(null, null, {
-        market_data: {current_price: {}},
-      }),
-    }),
-    description: 'A price is expected in response',
-    error: [503, 'ExpectedCoingeckoCurrentPriceForFiat'],
-  },
-  {
-    args: makeArgs({}),
-    description: 'Get coingecko historic rate',
-    expected: {cents: 1234},
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async () => {
-    if (!!error) {
-      await rejects(method(args), error, 'Got expected error');
-    } else {
-      const res = await method(args);
-
-      deepEqual(res, expected, 'Got expected return value');
-    }
-
-    return;
-  });
-});