ln-accounting 5.0.2 → 5.0.3

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # 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

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/package.json

@@ -12,7 +12,7 @@
     "bitcoinjs-lib": "5.2.0",
     "goldengate": "10.4.0",
     "json2csv": "5.0.6",
-    "ln-service": "52.3.0"
+    "ln-service": "52.4.0"
   },
   "description": "lnd accounting reports",
   "devDependencies": {
@@ -35,5 +35,5 @@
   "scripts": {
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 test/blockstream/*.js test/fiat/*.js test/harmony/*.js test/records/*.js"
   },
-  "version": "5.0.2"
+  "version": "5.0.3"
 }

package/records/get_chain_transactions.js

@@ -8,17 +8,17 @@ 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
 
@@ -116,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,
@@ -211,29 +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(),
-                description: 'Channel close',
-                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}) => {