ln-accounting 5.0.7 → 6.1.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Versions
 
+## Version 6.1.0
+
+- `parseAmount`: Add method to parse a human readable amount into tokens
+
+## Version 6.0.0
+
+### Breaking Changes
+
+- Node.js 14 or higher is now required
+
 ## Version 5.0.7
 
 - `getChainTransactions`: Add mempool space tx data lookup method

package/README.md

@@ -119,6 +119,25 @@ Get chain transactions, including sweep fees
       }]
     }
 
+## parseAmount
+
+Parse a described amount into tokens
+
+    {
+      amount: <Amount String>
+      [variables]: {
+        <Name String>: <Amount Number>
+      }
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      tokens: <Tokens Number>
+    }
+
 ## rateProviders
 
 Rate provider source options

package/fiat/get_coingecko_historic_rate.js

@@ -4,6 +4,7 @@ const {returnResult} = require('asyncjs-util');
 const asCoingeckoDate = yyyymmdd => yyyymmdd.split('-').reverse().join('-');
 const centsPerDollar = 100;
 const dateComponents = date => date.substring(0, 'yyyy-mm-dd'.length);
+const {keys} = Object;
 const remoteServiceTimeoutMs = 30 * 1000;
 const url = 'https://api.coingecko.com/api/v3/coins/bitcoin/history';
 
@@ -13,6 +14,7 @@ const url = 'https://api.coingecko.com/api/v3/coins/bitcoin/history';
     currency: <Currency Type String>
     date: <ISO 8601 Date String>
     fiat: <Fiat Type String>
+    rates: <Known Rates Object>
     request: <Request Function>
   }
 
@@ -21,7 +23,7 @@ const url = 'https://api.coingecko.com/api/v3/coins/bitcoin/history';
     cents: <Cents Per Token Number>
   }
 */
-module.exports = ({currency, date, fiat, request}, cbk) => {
+module.exports = ({currency, date, fiat, rates, request}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -38,6 +40,10 @@ module.exports = ({currency, date, fiat, request}, cbk) => {
           return cbk([400, 'UnsupportedFiatTypeForCoingeckoFiatRateLookup']);
         }
 
+        if (!rates) {
+          return cbk([400, 'ExpectedKnownRatesForCoingeckoFiatRateLookup']);
+        }
+
         if (!request) {
           return cbk([400, 'ExpectedRequestMethodForCoingeckoFiatRateLookup']);
         }
@@ -47,6 +53,16 @@ module.exports = ({currency, date, fiat, request}, cbk) => {
 
       // Get rate
       getRate: ['validate', ({}, cbk) => {
+        // Look for an existing rate lookup
+        const matching = keys(rates).find(key => {
+          return dateComponents(key) === dateComponents(date);
+        });
+
+        // Exit early when there is a cached result
+        if (!!rates[matching]) {
+          return cbk(null, {cents: rates[matching]});
+        }
+
         return request({
           url,
           json: true,

package/fiat/get_fiat_values.js

@@ -73,6 +73,7 @@ module.exports = ({currency, dates, fiat, provider, rate, request}, cbk) => {
               date,
               fiat,
               provider,
+              rates,
               request,
             },
             (err, rate) => {

package/fiat/get_historic_rate.js

@@ -19,6 +19,7 @@ const times = 10;
     date: <ISO 8601 Date String>
     fiat: <Fiat Type String>
     [provider]: <Historic Rate Source Type String>
+    rates: <Known Rates Object>
     request: <Request Function>
   }
 
@@ -27,7 +28,7 @@ const times = 10;
     cents: <Cents Per Token Number>
   }
 */
-module.exports = ({currency, date, fiat, provider, request}, cbk) => {
+module.exports = ({currency, date, fiat, provider, rates, request}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -44,6 +45,10 @@ module.exports = ({currency, date, fiat, provider, request}, cbk) => {
           return cbk([400, 'ExpectedFiatToGetHistoricRate']);
         }
 
+        if (!rates) {
+          return cbk([400, 'ExpectedRatesToGetHistoricRate']);
+        }
+
         if (!request) {
           return cbk([400, 'ExpectedRequestFunctionToGetHistoricRate']);
         }
@@ -66,7 +71,7 @@ module.exports = ({currency, date, fiat, provider, request}, cbk) => {
         }
 
         return asyncRetry({interval, times}, cbk => {
-          return source({currency, date, fiat, request}, cbk);
+          return source({currency, date, fiat, rates, request}, cbk);
         },
         cbk);
       }],

package/index.js

@@ -1,5 +1,11 @@
 const {getAccountingReport} = require('./report');
 const {getChainTransactions} = require('./records');
+const {parseAmount} = require('./report');
 const {rateProviders} = require('./fiat');
 
-module.exports = {getAccountingReport, getChainTransactions, rateProviders};
+module.exports = {
+  getAccountingReport,
+  getChainTransactions,
+  parseAmount,
+  rateProviders,
+};

package/package.json

@@ -7,19 +7,20 @@
     "url": "https://github.com/alexbosworth/ln-accounting/issues"
   },
   "dependencies": {
-    "async": "3.2.3",
-    "asyncjs-util": "1.2.9",
-    "bitcoinjs-lib": "6.0.1",
-    "goldengate": "11.2.2",
+    "async": "3.2.4",
+    "asyncjs-util": "1.2.10",
+    "bitcoinjs-lib": "6.0.2",
+    "goldengate": "11.4.0",
+    "hot-formula-parser": "4.0.0",
     "json2csv": "5.0.7",
-    "ln-service": "53.17.1"
+    "ln-service": "54.2.3"
   },
   "description": "lnd accounting reports",
   "devDependencies": {
     "@alexbosworth/tap": "15.0.11"
   },
   "engines": {
-    "node": ">=12.20"
+    "node": ">=14"
   },
   "keywords": [
     "accounting",
@@ -33,7 +34,7 @@
     "url": "https://github.com/alexbosworth/ln-accounting.git"
   },
   "scripts": {
-    "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 test/blockstream/*.js test/fiat/*.js test/harmony/*.js test/records/*.js"
+    "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 test/blockstream/*.js test/fiat/*.js test/harmony/*.js test/records/*.js test/report/*.js"
   },
-  "version": "5.0.7"
+  "version": "6.1.0"
 }

package/report/index.js

@@ -1,3 +1,4 @@
 const getAccountingReport = require('./get_accounting_report');
+const parseAmount = require('./parse_amount');
 
-module.exports = {getAccountingReport};
+module.exports = {getAccountingReport, parseAmount};

package/report/parse_amount.js

@@ -0,0 +1,76 @@
+const {Parser} = require('hot-formula-parser');
+
+const {ceil} = Math;
+const {isArray} = Array;
+const {keys} = Object;
+const {round} = Math;
+
+/** Parse a described amount into tokens
+
+  {
+    amount: <Amount String>
+    [variables]: {
+      <Name String>: <Amount Number>
+    }
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    tokens: <Tokens Number>
+  }
+*/
+module.exports = ({amount, variables}) => {
+  if (isArray(amount)) {
+    throw new Error('CannotParseMultipleAmounts');
+  }
+
+  const parser = new Parser();
+
+  keys(variables || {}).forEach(key => {
+    parser.setVariable(key.toLowerCase(), variables[key]);
+    parser.setVariable(key.toUpperCase(), 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);
+
+  const parsed = parser.parse(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)};
+};

package/test/fiat/test_get_coingecko_historic_rate.js

@@ -2,71 +2,72 @@ const {test} = require('@alexbosworth/tap');
 
 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: {},
+    args: makeArgs({currency: undefined}),
     description: 'A currency is required',
     error: [400, 'UnsupportedCurrencyForCoingeckoFiatRateLookup'],
   },
   {
-    args: {currency: 'BTC'},
+    args: makeArgs({date: undefined}),
     description: 'A date is required',
     error: [400, 'ExpectedDateForCoingeckoRateLookup'],
   },
   {
-    args: {currency: 'BTC', date: new Date().toISOString()},
-    description: 'A currency type is required',
+    args: makeArgs({fiat: undefined}),
+    description: 'A fiat type is required',
     error: [400, 'UnsupportedFiatTypeForCoingeckoFiatRateLookup'],
   },
   {
-    args: {currency: 'BTC', date: new Date().toISOString(), fiat: 'USD'},
+    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: {
-      date: new Date().toISOString(),
-      currency: 'BTC',
-      fiat: 'USD',
-      request: ({}, cbk) => cbk('err'),
-    },
+    args: makeArgs({request: ({}, cbk) => cbk('err')}),
     description: 'Errors returned from request',
     error: [503, 'UnexpectedErrGettingCoingeckoPastRate', {err: 'err'}],
   },
   {
-    args: {
-      date: new Date().toISOString(),
-      currency: 'BTC',
-      fiat: 'USD',
-      request: ({}, cbk) => cbk(),
-    },
+    args: makeArgs({request: ({}, cbk) => cbk()}),
     description: 'A body is expected in response',
     error: [503, 'UnexpectedResponseInCoingeckoPastRateResponse'],
   },
   {
-    args: {
-      date: new Date().toISOString(),
-      currency: 'BTC',
-      fiat: 'USD',
+    args: makeArgs({
       request: ({}, cbk) => cbk(null, null, {
         market_data: {current_price: {}},
       }),
-    },
+    }),
     description: 'A price is expected in response',
     error: [503, 'ExpectedCoingeckoCurrentPriceForFiat'],
   },
   {
-    args: {
-      date: new Date().toISOString(),
-      currency: 'BTC',
-      fiat: 'USD',
-      request: ({qs}, cbk) => api({qs}, cbk),
-    },
-    description: 'Get coindesk historic rate',
+    args: makeArgs({}),
+    description: 'Get coingecko historic rate',
     expected: {cents: 1234},
   },
 ];

package/test/fiat/test_get_historic_rate.js

@@ -8,45 +8,53 @@ const api = ({}, cbk) => {
   return cbk(null, null, {market_data: {current_price: {usd: 12.34}}});
 };
 
+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 tests = [
   {
-    args: {},
+    args: makeArgs({currency: undefined}),
     description: 'A currency code is required',
     error: [400, 'ExpectedCurrencyToGetHistoricRate'],
   },
   {
-    args: {currency: 'BTC'},
+    args: makeArgs({date: undefined}),
     description: 'A date is required',
     error: [400, 'ExpectedDateToGetHistoricRate'],
   },
   {
-    args: {date, currency: 'BTC'},
+    args: makeArgs({fiat: undefined}),
     description: 'A fiat type is required to get historic rate',
     error: [400, 'ExpectedFiatToGetHistoricRate'],
   },
   {
-    args: {date, currency: 'BTC', fiat: 'USD'},
+    args: makeArgs({rates: undefined}),
+    description: 'Past rates are required to get historic rate',
+    error: [400, 'ExpectedRatesToGetHistoricRate'],
+  },
+  {
+    args: makeArgs({request: undefined}),
     description: 'A request function is required to get historic rate',
     error: [400, 'ExpectedRequestFunctionToGetHistoricRate'],
   },
   {
-    args: {
-      date,
-      currency: 'BTC',
-      fiat: 'USD',
-      provider: 'provider',
-      request: () => {},
-    },
-    description: 'A request function is required to get historic rate',
+    args: makeArgs({provider: 'provider'}),
+    description: 'A known rate provider is required to get historic rate',
     error: [400, 'ExpectedKnownRateProviderToGetHistoricRate'],
   },
   {
-    args: {
-      date,
-      currency: 'BTC',
-      fiat: 'USD',
-      request: ({qs}, cbk) => api({qs}, cbk),
-    },
+    args: makeArgs({}),
     description: 'Get historic fiat rates',
     expected: {cents: 1234},
   },

package/test/records/test_get_all_invoices.js

@@ -46,6 +46,7 @@ const tests = [
                 r_preimage: Buffer.alloc(32),
                 settle_date: 1,
                 settled: true,
+                state: 'SETTLED',
                 value: '1',
                 value_msat: '1000',
               }],

package/test/records/test_get_all_payments.js

@@ -58,19 +58,34 @@ const tests = [
                   },
                   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',
+                    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,
                       },
-                      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',
@@ -108,16 +123,28 @@ const tests = [
           route: {
             fee: 1,
             fee_mtokens: '1000',
-            hops: [{
-              channel: '0x0x1',
-              channel_capacity: 1,
-              fee: 1,
-              fee_mtokens: '1000',
-              forward: 1,
-              forward_mtokens: '1000',
-              public_key: Buffer.alloc(33).toString('hex'),
-              timeout: 1,
-            }],
+            hops: [
+              {
+                channel: '0x0x1',
+                channel_capacity: 1,
+                fee: 1,
+                fee_mtokens: '1000',
+                forward: 1,
+                forward_mtokens: '1000',
+                public_key: Buffer.alloc(33).toString('hex'),
+                timeout: 1,
+              },
+              {
+                channel: '0x0x1',
+                channel_capacity: 1,
+                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,

package/test/report/test_parse_amount.js

@@ -0,0 +1,55 @@
+const {test} = require('@alexbosworth/tap');
+
+const {parseAmount} = require('./../../');
+
+const tests = [
+  {
+    args: {amount: 'amount'},
+    description: 'A value is required',
+    error: 'UnrecognizedVariableOrFunctionInSpecifiedAmount',
+  },
+  {
+    args: {amount: '1/0'},
+    description: 'Dividing by zero is not allowed',
+    error: 'CannotDivideByZeroInSpecifiedAmount',
+  },
+  {
+    args: {amount: '0.0.0'},
+    description: 'A generic invalid amount is rejected',
+    error: 'FailedToParseSpecifiedAmount',
+  },
+  {
+    args: {amount: 'OCT2DEC()'},
+    description: 'Invalid numbers are rejected',
+    error: 'InvalidNumberFoundInSpecifiedAmount',
+  },
+  {
+    args: {amount: '"string" + 1'},
+    description: 'Invalid formulas are rejected',
+    error: 'UnexpectedValueTypeInSpecifiedAmount',
+  },
+  {
+    args: {amount: '1.20969468*btc', variables: {variable: 'value'}},
+    description: 'A long precision BTC value is parsed',
+    expected: {tokens: 120969468},
+  },
+  {
+    args: {amount: '1.20969465*btc'},
+    description: 'A long precision BTC value that rounds down is parsed',
+    expected: {tokens: 120969465},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, ({end, equal, throws}) => {
+    if (!!error) {
+      throws(() => parseAmount(args), new Error(error), 'Got expected error');
+    } else {
+      const {tokens} = parseAmount(args);
+
+      equal(tokens, expected.tokens, 'Got expected output');
+    }
+
+    return end();
+  });
+});