ln-accounting 10.0.6 → 10.0.8

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## Version 10.0.6
+## Version 10.0.8
 
 ### Breaking Changes
 

package/package.json

@@ -4,19 +4,19 @@
   },
   "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.10.0",
+    "@alexbosworth/formulas": "1.5.0",
     "@json2csv/plainjs": "7.0.8",
     "async": "3.2.6",
     "asyncjs-util": "1.2.12",
-    "bitcoinjs-lib": "6.1.7",
-    "goldengate": "16.0.7",
-    "hot-formula-parser": "4.0.0",
-    "ln-service": "59.4.1"
+    "goldengate": "16.0.8",
+    "ln-service": "60.1.2"
   },
   "description": "lnd accounting reports",
   "engines": {
@@ -36,5 +36,5 @@
   "scripts": {
     "test": "node --experimental-test-coverage --test"
   },
-  "version": "10.0.6"
+  "version": "10.0.8"
 }

package/records/get_chain_transactions.js

@@ -1,18 +1,17 @@
 const asyncAuto = require('async/auto');
 const asyncMapSeries = require('async/mapSeries');
 const asyncRetry = require('async/retry');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {getChainTransactions} = require('ln-service');
 const {getClosedChannels} = require('ln-service');
 const {getHeight} = require('ln-service');
 const {getSweepTransactions} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
-const {Transaction} = require('bitcoinjs-lib');
 
 const {getProxyTx} = require('./../esplora');
 const {getProxyVout} = require('./../esplora');
 
 const dateAsMs = date => new Date(date).getTime();
-const {fromHex} = Transaction;
 const interval = 200;
 const {isArray} = Array;
 const msAsBlocks = ms => Math.ceil(ms / 1000 / 60 / 2.5);
@@ -141,9 +140,11 @@ module.exports = ({after, before, lnd, network, request}, cbk) => {
               return cbk(err);
             }
 
-            const {outs} = fromHex(tx.transaction);
+            const {outputs} = componentsOfTransaction({
+              transaction: tx.transaction,
+            });
 
-            const totalOut = outs.reduce((sum, n) => sum + n.value, Number());
+            const totalOut = sumOf(outputs.map(n => n.tokens));
 
             return cbk(null, {
               spends,
@@ -194,17 +195,17 @@ module.exports = ({after, before, lnd, network, request}, cbk) => {
             return tx.id === channel.close_transaction_id;
           });
 
+          const components = !tx ? null : componentsOfTransaction({
+            transaction: tx.transaction,
+          });
+
           const hasMissingLocalData = (() => {
-            if (!tx) {
+            if (!components) {
               return true;
             }
 
-            const inputs = fromHex(tx.transaction).ins;
-
             // Confirm that the inputs to the tx are local
-            return !!inputs.find(({hash, index}) => {
-              const id = hash.slice().reverse().toString('hex');
-
+            return !!components.inputs.find(({id}) => {
               return !getTx.transactions.find(n => n.id === id);
             });
           })();
@@ -239,20 +240,22 @@ module.exports = ({after, before, lnd, network, request}, cbk) => {
             cbk);
           }
 
-          const inputs = fromHex(tx.transaction).ins.map(({hash, index}) => {
-            const id = hash.slice().reverse().toString('hex');
-
+          const inputs = components.inputs.map(({id, vout}) => {
             const matching = getTx.transactions.find(n => n.id === id);
 
+            const {outputs} = componentsOfTransaction({
+              transaction: matching.transaction,
+            });
+
             return {
-              tokens: fromHex(matching.transaction).outs[index].value,
+              tokens: outputs[vout].tokens,
               transaction_id: id,
-              transaction_vout: index,
+              transaction_vout: vout,
             };
           });
 
           const inputsValue = sumOf(inputs.map(n => n.tokens));
-          const outputsValue = fromHex(tx.transaction).outs.map(n => n.value);
+          const outputsValue = components.outputs.map(n => n.tokens);
 
           return cbk(null, {
             block_id: tx.block_id,

package/report/parse_amount.js

@@ -1,6 +1,5 @@
-const {Parser} = require('hot-formula-parser');
+const {evaluateFormula} = require('@alexbosworth/formulas');
 
-const {ceil} = Math;
 const {isArray} = Array;
 const {keys} = Object;
 const {round} = Math;
@@ -27,50 +26,20 @@ module.exports = ({amount, variables}) => {
     throw new Error('CannotParseMultipleAmounts');
   }
 
-  const parser = new Parser();
+  const constants = {};
 
   keys(variables || {}).forEach(key => {
-    parser.setVariable(key.toLowerCase(), variables[key]);
-    parser.setVariable(key.toUpperCase(), variables[key]);
+    constants[key.toLowerCase()] = variables[key];
 
     return;
   });
 
-  parser.setVariable('BTC', 1e8);
-  parser.setVariable('btc', 1e8);
-  parser.setVariable('m', 1e6);
-  parser.setVariable('M', 1e6);
-  parser.setVariable('mm', 1e6);
-  parser.setVariable('MM', 1e6);
-  parser.setVariable('k', 1e3);
-  parser.setVariable('K', 1e3);
+  constants.btc = 1e8;
+  constants.m = 1e6;
+  constants.mm = 1e6;
+  constants.k = 1e3;
 
-  const parsed = parser.parse(amount);
+  const {result} = evaluateFormula({constants, formula: amount});
 
-  switch (parsed.error) {
-  case '#DIV/0!':
-    throw new Error('CannotDivideByZeroInSpecifiedAmount');
-
-  case '#ERROR!':
-    throw new Error('FailedToParseSpecifiedAmount');
-
-  case '#N/A':
-  case '#NAME?':
-    throw new Error('UnrecognizedVariableOrFunctionInSpecifiedAmount');
-
-  case '#NUM!':
-    throw new Error('InvalidNumberFoundInSpecifiedAmount');
-
-  case '#VALUE!':
-    throw new Error('UnexpectedValueTypeInSpecifiedAmount');
-
-  default:
-    break;
-  }
-
-  if (!!parsed.error) {
-    throw new Error(parsed.error);
-  }
-
-  return {tokens: round(parsed.result)};
+  return {tokens: round(result)};
 };

package/test/fiat/test_get_coingecko_historic_rate.js

@@ -1,4 +1,5 @@
 const {deepEqual} = require('node:assert').strict;
+const {fail} = require('node:assert').strict;
 const {rejects} = require('node:assert').strict;
 const test = require('node:test');
 
@@ -28,6 +29,11 @@ const tests = [
     description: 'A currency is required',
     error: [400, 'UnsupportedCurrencyForCoingeckoFiatRateLookup'],
   },
+  {
+    args: makeArgs({currency: 'ETH'}),
+    description: 'Only BTC is supported as a currency',
+    error: [400, 'UnsupportedCurrencyForCoingeckoFiatRateLookup'],
+  },
   {
     args: makeArgs({date: undefined}),
     description: 'A date is required',
@@ -38,6 +44,11 @@ const tests = [
     description: 'A fiat type is required',
     error: [400, 'UnsupportedFiatTypeForCoingeckoFiatRateLookup'],
   },
+  {
+    args: makeArgs({fiat: 'EUR'}),
+    description: 'Only USD is supported as a fiat type',
+    error: [400, 'UnsupportedFiatTypeForCoingeckoFiatRateLookup'],
+  },
   {
     args: makeArgs({rates: undefined}),
     description: 'A rates object is required',
@@ -58,6 +69,16 @@ const tests = [
     description: 'A body is expected in response',
     error: [503, 'UnexpectedResponseInCoingeckoPastRateResponse'],
   },
+  {
+    args: makeArgs({request: ({}, cbk) => cbk(null, null, {})}),
+    description: 'Market data is expected in response',
+    error: [503, 'UnexpectedResponseInCoingeckoPastRateResponse'],
+  },
+  {
+    args: makeArgs({request: ({}, cbk) => cbk(null, null, {market_data: {}})}),
+    description: 'A current price is expected in market data',
+    error: [503, 'UnexpectedResponseInCoingeckoPastRateResponse'],
+  },
   {
     args: makeArgs({
       request: ({}, cbk) => cbk(null, null, {
@@ -72,6 +93,48 @@ const tests = [
     description: 'Get coingecko historic rate',
     expected: {cents: 1234},
   },
+  {
+    args: makeArgs({
+      date: '2020-01-02T03:04:05.000Z',
+      rates: {'2020-01-02T12:00:00.000Z': 5678},
+      request: ({}, cbk) => fail('Expected cached rate to be used'),
+    }),
+    description: 'A known rate for the same day is used instead of a request',
+    expected: {cents: 5678},
+  },
+  {
+    args: makeArgs({
+      date: '2020-01-02T03:04:05.000Z',
+      rates: {'2020-01-01T03:04:05.000Z': 5678},
+    }),
+    description: 'A known rate for a different day is not used',
+    expected: {cents: 1234},
+  },
+  {
+    args: makeArgs({
+      date: '2020-01-02T03:04:05.000Z',
+      rates: {'2020-01-02T03:04:05.000Z': 0},
+    }),
+    description: 'A falsy known rate falls back to a request',
+    expected: {cents: 1234},
+  },
+  {
+    args: makeArgs({
+      date: '2020-01-02T03:04:05.000Z',
+      request: (args, cbk) => {
+        deepEqual(args, {
+          json: true,
+          qs: {date: '02-01-2020', localization: false},
+          timeout: 30000,
+          url: 'https://api.coingecko.com/api/v3/coins/bitcoin/history',
+        });
+
+        return api(args, cbk);
+      },
+    }),
+    description: 'Request is made with the expected arguments',
+    expected: {cents: 1234},
+  },
 ];
 
 tests.forEach(({args, description, error, expected}) => {

package/test/report/test_parse_amount.js

@@ -8,27 +8,27 @@ const tests = [
   {
     args: {amount: 'amount'},
     description: 'A value is required',
-    error: 'UnrecognizedVariableOrFunctionInSpecifiedAmount',
+    error: 'ExpectedAllKnownConstantsInFormulaToEvaluate',
   },
   {
     args: {amount: '1/0'},
     description: 'Dividing by zero is not allowed',
-    error: 'CannotDivideByZeroInSpecifiedAmount',
+    error: 'ExpectedNonZeroDivisorForFormulaEvaluation',
   },
   {
     args: {amount: '0.0.0'},
     description: 'A generic invalid amount is rejected',
-    error: 'FailedToParseSpecifiedAmount',
+    error: 'UnexpectedInvalidDecimalNumberValue',
   },
   {
     args: {amount: 'OCT2DEC()'},
-    description: 'Invalid numbers are rejected',
-    error: 'InvalidNumberFoundInSpecifiedAmount',
+    description: 'Invalid functions are rejected',
+    error: 'UnexpectedFunctionForFormulaEvaluation',
   },
   {
     args: {amount: '"string" + 1'},
     description: 'Invalid formulas are rejected',
-    error: 'UnexpectedValueTypeInSpecifiedAmount',
+    error: 'ExpectedBoolOrFiniteNumberForNumberConversion',
   },
   {
     args: {amount: '1.20969468*btc', variables: {variable: 'value'}},