ln-accounting 4.3.1 → 5.0.3

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Versions
 
+## Version 5.0.3
+
+- `getChainTransactions`: Add mempool space tx data lookup method
+
+## Version 5.0.2
+
+- `getChainTransactions`: Optimize lookup speed when an after date is specified
+
+## Version 5.0.1
+
+- `getAccountingReport`: Adjust sweeps to be net zero for transacted amount, plus fees
+
+## Version 5.0.0
+
+- `getAccountingReport`: Add support for coingecko historic rate lookup, use as default
+
+### Breaking Changes
+
+- Node.js version 12 or higher is now required
+
 ## Version 4.3.1
 
 - `getAccountingReport`: Fix reporting for AMP push invoices

package/README.md

@@ -18,11 +18,11 @@ Note: Chain fees does not include chain fees paid to close channels
       [before]: <Records Created Before ISO 8601 Date>
       [category]: <Category Filter String>
       currency: <Base Currency Type String>
-      fiat: <Fiat Currency Type String>
+      [fiat]: <Fiat Currency Type String>
       lnd: <Authenticated LND gRPC API Object>
       [network]: <Network Name String>
       [rate]: <Exchange Function> ({currency, date, fiat}, cbk) => (err, {cents})
-      rate_provider: <Fiat Rate Provider String> coincap || coindesk
+      [rate_provider]: <Fiat Rate Provider String> coindesk || coingecko
       request: <Request Function>
     }
 

package/esplora/get_esplora_tx.js

@@ -0,0 +1,88 @@
+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}`;
+
+/** Get transaction details from Esplora-compatible API
+
+  {
+    api: <Esplora API Base String>
+    id: <Transaction Id Hex 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 = ({api, id, request}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check argument
+      validate: cbk => {
+        if (!api) {
+          return cbk([400, 'ExpectedBaseEsploraApiToGetEsploraTx']);
+        }
+
+        if (!id) {
+          return cbk([400, 'ExpectedTransactionIdToGetEsploraTx']);
+        }
+
+        if (!request) {
+          return cbk([400, 'ExpectedRequestFunctionToGetEsploraTx']);
+        }
+
+        return cbk();
+      },
+
+      // Get tx details
+      getDetails: ['validate', ({}, cbk) => {
+        return request({json: true, url: url(api, id)}, (err, r, body) => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorGettingEsploraTx', {err}]);
+          }
+
+          if (!body) {
+            return cbk([503, 'ExpectedTxLookupResultForEsploraTx']);
+          }
+
+          if (body.fee === undefined) {
+            return cbk([503, 'ExpectedTransactionFeeInResultFromEsplora']);
+          }
+
+          if (!body.status) {
+            return cbk([503, 'ExpectedStatusOfEsploraTransaction']);
+          }
+
+          if (!isArray(body.vout)) {
+            return cbk([503, 'ExpectedOutputsInEsploraTransaction']);
+          }
+
+          // 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/esplora/get_esplora_vout.js

@@ -0,0 +1,74 @@
+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}`;
+
+/** Get transaction details from Esplora-compatible API
+
+  {
+    api: <Esplora API Base String>
+    id: <Transaction Id Hex String>
+    request: <Request Function>
+  }
+
+  @returns via cbk or Promise
+  {
+    tokens: <Transaction Output Tokens Number>
+  }
+*/
+module.exports = ({api, id, request, vout}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check argument
+      validate: cbk => {
+        if (!api) {
+          return cbk([400, 'ExpectedApiPathToGetEsploraVout']);
+        }
+
+        if (!id) {
+          return cbk([400, 'ExpectedTransactionIdToGetEsploraVout']);
+        }
+
+        if (!request) {
+          return cbk([400, 'ExpectedRequestFunctionToGetEsploraVout']);
+        }
+
+        if (vout === undefined) {
+          return cbk([400, 'ExpectedTransactionOutputIndexToGetEsploraVout']);
+        }
+
+        return cbk();
+      },
+
+      // Get tx details
+      getDetails: ['validate', ({}, cbk) => {
+        return request({json: true, url: url(api, id)}, (err, r, body) => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorGettingExploraTx', {err}]);
+          }
+
+          if (!body) {
+            return cbk([503, 'ExpectedTxLookupResultForEsploraTx']);
+          }
+
+          if (!isArray(body.vout)) {
+            return cbk([503, 'ExpectedOutputsArrayForExploraTx']);
+          }
+
+          if (!body.vout[vout]) {
+            return cbk([503, 'ExpectedOutputInEsploraTxDetails']);
+          }
+
+          if (!body.vout[vout].value) {
+            return cbk([503, 'ExpectedOutputValueInEsploraTxDetails']);
+          }
+
+          return cbk(null, {tokens: body.vout[vout].value});
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'getDetails'}, cbk));
+  });
+};

package/esplora/get_proxy_tx.js

@@ -0,0 +1,74 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const getEsploraTx = require('./get_esplora_tx');
+
+const apiBlockstreamBtc = 'https://blockstream.info/api/';
+const apiBlockstreamBtcTestnet = 'https://blockstream.info/testnet/api/';
+const apiMempoolSpaceBtc = 'https://mempool.space/api/';
+const btcTestnet = 'btctestnet';
+const random = arr => arr[Math.floor(Math.random() * arr.length)];
+
+/** Get a transaction as a proxy for a local transaction
+
+  {
+    id: <Transaction Id Hex String>
+    [network]: <Network Name String>
+    request: <Request Function>
+  }
+
+  @returns via cbk or Promise
+  {
+    [block_id]: <Block Hash Hex String>
+    [confirmation_height]: <Transaction Confirmed At Height Number>
+    created_at: <Transaction Created At ISO 8601 Date String>>
+    fee: <Transaction Fee Tokens Number>
+    id: <Transaction Id Hex String>
+    is_confirmed: <Transaction Confirmed Bool>
+    output_addresses: [<Transaction Output Address String>]
+  }
+*/
+module.exports = ({id, network, request}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!id) {
+          return cbk([400, 'ExpectedPaymentIdToGetProxyTransaction']);
+        }
+
+        if (!request) {
+          return cbk([400, 'ExpectedRequestFunctionToGetProxyTransaction']);
+        }
+
+        return cbk();
+      },
+
+      // Determine the API to use
+      api: ['validate', ({}, cbk) => {
+        if (network === btcTestnet) {
+          return cbk(null, apiBlockstreamBtcTestnet);
+        }
+
+        return cbk(null, random([apiBlockstreamBtc, apiMempoolSpaceBtc]));
+      }],
+
+      // Get transaction
+      getTx: ['api', ({api}, cbk) => getEsploraTx({api, id, request}, cbk)],
+
+      // Transaction details
+      tx: ['getTx', ({api, getTx}, cbk) => {
+        return cbk(null, {
+          id,
+          block_id: getTx.block_id,
+          confirmation_height: getTx.confirmation_height,
+          created_at: getTx.created_at || new Date().toISOString(),
+          fee: getTx.fee,
+          is_confirmed: !!getTx.block_id,
+          output_addresses: getTx.output_addresses,
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'tx'}, cbk));
+  });
+};

package/esplora/get_proxy_vout.js

@@ -0,0 +1,62 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const getEsploraVout = require('./get_esplora_vout');
+
+const apiBlockstreamBtc = 'https://blockstream.info/api/';
+const apiBlockstreamBtcTestnet = 'https://blockstream.info/testnet/api/';
+const apiMempoolSpaceBtc = 'https://mempool.space/api/';
+const btcTestnet = 'btctestnet';
+const random = arr => arr[Math.floor(Math.random() * arr.length)];
+
+/** Get a vout from an esplora endpoint
+
+  {
+    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 arguments
+      validate: cbk => {
+        if (!id) {
+          return cbk([400, 'ExpectedPaymentIdToGetProxyVout']);
+        }
+
+        if (!request) {
+          return cbk([400, 'ExpectedRequestFunctionToGetProxyVout']);
+        }
+
+        if (vout === undefined) {
+          return cbk([400, 'ExpectedTransactionOutputIndexToGetProxyVout']);
+        }
+
+        return cbk();
+      },
+
+      // Determine the API to use
+      api: ['validate', ({}, cbk) => {
+        if (network === btcTestnet) {
+          return cbk(null, apiBlockstreamBtcTestnet);
+        }
+
+        return cbk(null, random([apiBlockstreamBtc, apiMempoolSpaceBtc]));
+      }],
+
+      // Get transaction vout
+      getVout: ['api', ({api}, cbk) => {
+        return getEsploraVout({api, id, request, vout}, cbk);
+      }],
+    },
+    returnResult({reject, resolve, of: 'getVout'}, cbk));
+  });
+};

package/esplora/index.js

@@ -0,0 +1,4 @@
+const getProxyTx = require('./get_proxy_tx');
+const getProxyVout = require('./get_proxy_vout');
+
+module.exports = {getProxyTx, getProxyVout};

package/fiat/constants.json

@@ -1,3 +1,3 @@
 {
-  "rateProviders": ["coincap", "coindesk"]
+  "rateProviders": ["coincap", "coindesk", "coingecko"]
 }

package/fiat/get_coingecko_historic_rate.js

@@ -0,0 +1,80 @@
+const asyncAuto = require('async/auto');
+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 remoteServiceTimeoutMs = 30 * 1000;
+const url = 'https://api.coingecko.com/api/v3/coins/bitcoin/history';
+
+/** Get the number of cents for a big unit token from coingecko
+
+  {
+    currency: <Currency Type String>
+    date: <ISO 8601 Date String>
+    fiat: <Fiat Type String>
+    request: <Request Function>
+  }
+
+  @returns via cbk or Promise
+  {
+    cents: <Cents Per Token Number>
+  }
+*/
+module.exports = ({currency, date, fiat, request}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (currency !== 'BTC') {
+          return cbk([400, 'UnsupportedCurrencyForCoingeckoFiatRateLookup']);
+        }
+
+        if (!date) {
+          return cbk([400, 'ExpectedDateForCoingeckoRateLookup']);
+        }
+
+        if (fiat !== 'USD') {
+          return cbk([400, 'UnsupportedFiatTypeForCoingeckoFiatRateLookup']);
+        }
+
+        if (!request) {
+          return cbk([400, 'ExpectedRequestMethodForCoingeckoFiatRateLookup']);
+        }
+
+        return cbk();
+      },
+
+      // Get rate
+      getRate: ['validate', ({}, cbk) => {
+        return request({
+          url,
+          json: true,
+          qs: {
+            date: asCoingeckoDate(dateComponents(date)),
+            localization: false,
+          },
+          timeout: remoteServiceTimeoutMs,
+        },
+        (err, r, body) => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrGettingCoingeckoPastRate', {err}]);
+          }
+
+          if (!body || !body.market_data || !body.market_data.current_price) {
+            return cbk([503, 'UnexpectedResponseInCoingeckoPastRateResponse']);
+          }
+
+          if (!body.market_data.current_price.usd) {
+            return cbk([503, 'ExpectedCoingeckoCurrentPriceForFiat']);
+          }
+
+          const cents = body.market_data.current_price.usd * centsPerDollar;
+
+          return cbk(null, {cents});
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'getRate'}, cbk));
+  });
+};

package/fiat/get_historic_rate.js

@@ -4,8 +4,9 @@ const {returnResult} = require('asyncjs-util');
 
 const getCoincapHistoricRate = require('./get_coincap_historic_rate');
 const getCoindeskHistoricRate = require('./get_coindesk_historic_rate');
+const getCoingeckoHistoricRate = require('./get_coingecko_historic_rate');
 
-const defaultRateProvider = 'coincap';
+const defaultRateProvider = 'coingecko';
 const interval = retryCount => Math.random() * 5000 * Math.pow(2, retryCount);
 const times = 10;
 
@@ -55,6 +56,7 @@ module.exports = ({currency, date, fiat, provider, request}, cbk) => {
         const providers = {
           coincap: getCoincapHistoricRate,
           coindesk: getCoindeskHistoricRate,
+          coingecko: getCoingeckoHistoricRate,
         };
 
         const source = providers[provider || defaultRateProvider];

package/package.json

@@ -7,19 +7,19 @@
     "url": "https://github.com/alexbosworth/ln-accounting/issues"
   },
   "dependencies": {
-    "async": "3.2.0",
+    "async": "3.2.1",
     "asyncjs-util": "1.2.6",
     "bitcoinjs-lib": "5.2.0",
-    "goldengate": "10.1.0",
+    "goldengate": "10.4.0",
     "json2csv": "5.0.6",
-    "ln-service": "51.8.5"
+    "ln-service": "52.4.0"
   },
   "description": "lnd accounting reports",
   "devDependencies": {
-    "tap": "15.0.9"
+    "@alexbosworth/tap": "15.0.10"
   },
   "engines": {
-    "node": ">=10.10.0"
+    "node": ">=12"
   },
   "keywords": [
     "accounting",
@@ -33,7 +33,7 @@
     "url": "https://github.com/alexbosworth/ln-accounting.git"
   },
   "scripts": {
-    "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 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"
   },
-  "version": "4.3.1"
+  "version": "5.0.3"
 }

package/records/get_chain_transactions.js

@@ -3,25 +3,29 @@ const asyncMapSeries = require('async/mapSeries');
 const asyncRetry = require('async/retry');
 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 {getBlockstreamTx} = require('./../blockstream');
-const {getBlockstreamVout} = require('./../blockstream');
+const {getProxyTx} = require('./../esplora');
+const {getProxyVout} = require('./../esplora');
 
+const dateAsMs = date => new Date(date).getTime();
 const {fromHex} = Transaction;
-const interval = retryCount => 100 * Math.pow(2, retryCount);
+const interval = 200;
 const {isArray} = Array;
+const msAsBlocks = ms => Math.ceil(ms / 1000 / 60 / 2.5);
+const {now} = Date;
 const sumOf = arr => arr.reduce((sum, n) => sum + n, Number());
-const times = 10;
+const times = 15;
 
 /** Get chain transactions, including sweep fees
 
   {
     [after]: <Records Created After ISO 8601 Date>
     [before]: <Records Created Before ISO 8601 Date>
-    lnd: <Authenticated LND Object>
+    lnd: <Authenticated LND API Object>
     [network]: <Network Name String>
     request: <Request Function>
   }
@@ -63,11 +67,27 @@ module.exports = ({after, before, lnd, network, request}, cbk) => {
       // Get the closed channels
       getClosed: ['validate', ({}, cbk) => getClosedChannels({lnd}, cbk)],
 
+      // Get the chain height
+      getHeight: ['validate', ({}, cbk) => getHeight({lnd}, cbk)],
+
       // Get the sweep transactions
       getSweeps: ['validate', ({}, cbk) => getSweepTransactions({lnd}, cbk)],
 
       // Get the regular set of chain transactions
-      getTx: ['validate', ({}, cbk) => getChainTransactions({lnd}, cbk)],
+      getTx: ['getHeight', ({getHeight}, cbk) => {
+        // Exit early when there is no after constraint
+        if (!after) {
+          return getChainTransactions({lnd}, cbk);
+        }
+
+        const height = getHeight.current_block_height;
+
+        return getChainTransactions({
+          lnd,
+          after: height - msAsBlocks(now() - dateAsMs(after)),
+        },
+        cbk);
+      }],
 
       // Time-relevant sweep transactions
       sweepTransactions: ['getSweeps', ({getSweeps}, cbk) => {
@@ -96,7 +116,7 @@ module.exports = ({after, before, lnd, network, request}, cbk) => {
             }
 
             return asyncRetry({interval, times}, cbk => {
-              return getBlockstreamVout({
+              return getProxyVout({
                 network,
                 request,
                 id: spend.transaction_id,
@@ -131,12 +151,13 @@ module.exports = ({after, before, lnd, network, request}, cbk) => {
               confirmation_count: tx.confirmation_count,
               confirmation_height: tx.confirmation_height,
               created_at: tx.created_at,
+              description: 'Sweep',
               fee: tx.fee || (sumOf(spends.map(n => n.tokens)) - totalOut),
               id: tx.id,
               is_confirmed: tx.is_confirmed,
               is_outgoing: true,
               output_addresses: tx.output_addresses,
-              tokens: tx.tokens,
+              tokens: tx.fee || (sumOf(spends.map(n => n.tokens)) - totalOut),
               transaction: tx.transaction,
             });
           });
@@ -145,14 +166,32 @@ module.exports = ({after, before, lnd, network, request}, cbk) => {
       }],
 
       // Calculate closing fees for channels that were locally initiated
-      getClosingFees: ['getClosed', 'getTx', ({getClosed, getTx}, cbk) => {
+      getClosingFees: [
+        'getClosed',
+        'getHeight',
+        'getTx',
+        ({getClosed, getHeight, getTx}, cbk) =>
+      {
+        const height = getHeight.current_block_height;
+
         const channels = getClosed.channels
           .filter(n => !!n.close_transaction_id)
-          .filter(n => n.is_partner_initiated === false);
+          .filter(n => n.is_partner_initiated === false)
+          .filter(channel => {
+            // Exit early when not checking channel close height vs after
+            if (!after || !channel.close_confirm_height) {
+              return true;
+            }
+
+            const afterHeight = height - msAsBlocks(now() - dateAsMs(after));
+
+            // Do not consider channels that closed before the after constraint
+            return channel.close_confirm_height > afterHeight;
+          });
 
         return asyncMapSeries(channels, (channel, cbk) => {
           const tx = getTx.transactions.find(tx => {
-            return tx.id === channel.close_transaction_id
+            return tx.id === channel.close_transaction_id;
           });
 
           const hasMissingLocalData = (() => {
@@ -172,28 +211,32 @@ module.exports = ({after, before, lnd, network, request}, cbk) => {
 
           // Exit early when the close transaction is missing
           if (hasMissingLocalData) {
-            return getBlockstreamTx({
-              network,
-              request,
-              id: channel.close_transaction_id,
-            },
-            (err, res) => {
-              if (!!err) {
-                return cbk(err);
-              }
-
-              return cbk(null, {
-                block_id: res.block_id,
-                confirmation_height: res.confirmation_height,
-                created_at: res.created_at || new Date().toISOString(),
-                fee: res.fee,
+            return asyncRetry({interval, times}, cbk => {
+              return getProxyTx({
+                network,
+                request,
                 id: channel.close_transaction_id,
-                is_confirmed: !!res.block_id,
-                is_outgoing: true,
-                output_addresses: res.output_addresses,
-                tokens: res.fee,
+              },
+              (err, res) => {
+                if (!!err) {
+                  return cbk(err);
+                }
+
+                return cbk(null, {
+                  block_id: res.block_id,
+                  confirmation_height: res.confirmation_height,
+                  created_at: res.created_at,
+                  description: 'Channel close',
+                  fee: res.fee,
+                  id: res.id,
+                  is_confirmed: res.is_confirmed,
+                  is_outgoing: true,
+                  output_addresses: res.output_addresses,
+                  tokens: res.fee,
+                });
               });
-            });
+            },
+            cbk);
           }
 
           const inputs = fromHex(tx.transaction).ins.map(({hash, index}) => {
@@ -216,13 +259,13 @@ module.exports = ({after, before, lnd, network, request}, cbk) => {
             confirmation_count: tx.confirmation_count,
             confirmation_height: tx.confirmation_height,
             created_at: tx.created_at,
-            description: tx.description,
+            description: `Channel close: ${tx.description}`,
             fee: inputsValue - sumOf(outputsValue),
             id: tx.id,
             is_confirmed: tx.is_confirmed,
             is_outgoing: true,
             output_addresses: tx.output_addresses,
-            tokens: tx.tokens,
+            tokens: inputsValue - sumOf(outputsValue),
             transaction: tx.transaction,
           });
         },
@@ -231,16 +274,17 @@ module.exports = ({after, before, lnd, network, request}, cbk) => {
 
       // Consolidate transactions, including missing fees
       transactions: [
+        'getClosed',
         'getClosingFees',
         'getSweepFees',
         'getTx',
-        ({getClosingFees, getSweepFees, getTx}, cbk) =>
+        ({getClosed, getClosingFees, getSweepFees, getTx}, cbk) =>
       {
-        const closes = getClosingFees.map(({id}) => id);
+        const closeIds = getClosed.channels.map(n => n.close_transaction_id);
         const sweeps = getSweepFees.map(({id}) => id);
 
         const normalTx = getTx.transactions.filter(({id}) => {
-          return !closes.includes(id) && !sweeps.includes(id);
+          return !closeIds.includes(id) && !sweeps.includes(id);
         });
 
         const transactions = []

package/report/get_accounting_report.js

@@ -42,7 +42,7 @@ const times = 10;
     lnd: <LND gRPC Object>
     [network]: <Network Name String>
     [rate]: <Exchange Function> ({currency, date, fiat}, cbk) => (err, {cents})
-    [rate_provider]: <Fiat Rate Provider String> // coincap || coindesk
+    [rate_provider]: <Fiat Rate Provider String> // coindesk || coingecko
     request: <Request Function>
   }
 

package/test/blockstream/test_get_blockstream_tx.js

@@ -0,0 +1,109 @@
+const {test} = require('@alexbosworth/tap');
+
+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 ({end, rejects, strictSame}) => {
+    if (!!error) {
+      await rejects(method(args), error, 'Got expected error');
+    } else {
+      const res = await method(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/fiat/test_get_coincap_historic_rate.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const getCoincapHistoricRate = require('./../../fiat/get_coincap_historic_rate');
 

package/test/fiat/test_get_coindesk_historic_rate.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const getCoindeskHistoricRate = require('./../../fiat/get_coindesk_historic_rate');
 

package/test/fiat/test_get_coingecko_historic_rate.js

@@ -0,0 +1,86 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../fiat/get_coingecko_historic_rate');
+
+const api = ({qs}, cbk) => {
+  return cbk(null, null, {market_data: {current_price: {usd: 12.34}}});
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'A currency is required',
+    error: [400, 'UnsupportedCurrencyForCoingeckoFiatRateLookup'],
+  },
+  {
+    args: {currency: 'BTC'},
+    description: 'A date is required',
+    error: [400, 'ExpectedDateForCoingeckoRateLookup'],
+  },
+  {
+    args: {currency: 'BTC', date: new Date().toISOString()},
+    description: 'A currency type is required',
+    error: [400, 'UnsupportedFiatTypeForCoingeckoFiatRateLookup'],
+  },
+  {
+    args: {currency: 'BTC', date: new Date().toISOString(), fiat: 'USD'},
+    description: 'A request method is required',
+    error: [400, 'ExpectedRequestMethodForCoingeckoFiatRateLookup'],
+  },
+  {
+    args: {
+      date: new Date().toISOString(),
+      currency: 'BTC',
+      fiat: 'USD',
+      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(),
+    },
+    description: 'A body is expected in response',
+    error: [503, 'UnexpectedResponseInCoingeckoPastRateResponse'],
+  },
+  {
+    args: {
+      date: new Date().toISOString(),
+      currency: 'BTC',
+      fiat: 'USD',
+      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',
+    expected: {cents: 1234},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, rejects, strictSame}) => {
+    if (!!error) {
+      await rejects(method(args), error, 'Got expected error');
+    } else {
+      const res = await method(args);
+
+      strictSame(res, expected, 'Got expected return value');
+    }
+
+    return end();
+  });
+});

package/test/fiat/test_get_fiat_values.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const {getFiatValues} = require('./../../fiat/');
 

package/test/fiat/test_get_historic_rate.js

@@ -1,10 +1,12 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const getHistoricRate = require('./../../fiat/get_historic_rate');
 
 const date = new Date().toISOString();
 
-const api = ({}, cbk) => cbk(null, null, {data: [{date, priceUsd: 12.3401}]});
+const api = ({}, cbk) => {
+  return cbk(null, null, {market_data: {current_price: {usd: 12.34}}});
+};
 
 const tests = [
   {

package/test/harmony/test_categorize_records.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const {categorizeRecords} = require('./../../harmony');
 

package/test/harmony/test_chain_fees_as_records.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const {chainFeesAsRecords} = require('./../../harmony');
 

package/test/harmony/test_chain_receives_as_records.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const {chainReceivesAsRecords} = require('./../../harmony');
 

package/test/harmony/test_chain_sends_as_records.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const {chainSendsAsRecords} = require('./../../harmony');
 

package/test/harmony/test_formatted_notes.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const formattedNotes = require('./../../harmony/formatted_notes');
 

package/test/harmony/test_forwards_as_records.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const {forwardsAsRecords} = require('./../../harmony');
 

package/test/harmony/test_harmonize.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const {harmonize} = require('./../../harmony');
 

package/test/harmony/test_invoices_as_records.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const {invoicesAsRecords} = require('./../../harmony');
 

package/test/harmony/test_notes_for_chain_transaction.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const notesForChainTx = require('./../../harmony/notes_for_chain_transaction');
 

package/test/harmony/test_payments_as_records.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const {paymentsAsRecords} = require('./../../harmony');
 

package/test/harmony/test_records_with_fiat.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const {recordsWithFiat} = require('./../../harmony');
 

package/test/records/test_get_all_invoices.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const {getAllInvoices} = require('./../../records');
 

package/test/records/test_get_all_payments.js

@@ -1,4 +1,4 @@
-const {test} = require('tap');
+const {test} = require('@alexbosworth/tap');
 
 const {getAllPayments} = require('./../../records');
 
@@ -99,6 +99,7 @@ const tests = [
     expected: {
       payments: [{
         attempts: [{
+          confirmed_at: '1970-01-01T00:00:00.001Z',
           is_confirmed: false,
           is_failed: true,
           is_pending: false,
@@ -122,6 +123,7 @@ const tests = [
             total_mtokens: '1000',
           },
         }],
+        confirmed_at: undefined,
         created_at: '1970-01-01T00:00:01.000Z',
         destination: Buffer.alloc(33).toString('hex'),
         fee: 1,