edge-currency-plugins 3.8.6 → 3.8.8

package/lib/common/utxobased/engine/UtxoEngineProcessor.js

@@ -115,6 +115,17 @@ var _utils3 = require('./utils');
     transactionUpdateCache: {}
   }
 
+  // Track pending timeouts so they can be cleared on stop
+  const pendingTimeouts = new Set()
+
+  // Clear all pending timeouts
+  const clearPendingTimeouts = () => {
+    for (const timeoutId of pendingTimeouts) {
+      clearTimeout(timeoutId)
+    }
+    pendingTimeouts.clear()
+  }
+
   const clearTaskCache = () => {
     for (const key of Object.keys(taskCache.addressForTransactionsCache)) {
       _utils.removeItem.call(void 0, taskCache.addressForTransactionsCache, key)
@@ -212,6 +223,7 @@ var _utils3 = require('./utils');
     dataLayer,
     emitter,
     taskCache,
+    pendingTimeouts,
     updateProgressRatio,
     updateSeenTxCheckpoint,
     io,
@@ -358,6 +370,7 @@ var _utils3 = require('./utils');
     async stop() {
       serverStates.stop()
       clearTaskCache()
+      clearPendingTimeouts()
       running = false
     },
 
@@ -685,6 +698,7 @@ const internalGetFreshAddress = async (
 
 
 
+
 
 
 const setLookAhead = async (common) => {
@@ -1154,9 +1168,18 @@ async function* processCheckTransactionConfirmation(
   } catch (err) {
     console.error(err)
     common.log('error while processing transaction update:', err)
-    common.taskCache.transactionUpdateCache[txId] = {
-      processing: false
-    }
+    // Delay putting the transaction back into the cache to avoid thrashing
+    // on dropped transactions. 10 seconds is a reasonable compromise between
+    // thrashing and not waiting too long.
+    addPendingTimeout(
+      common,
+      () => {
+        common.taskCache.transactionUpdateCache[txId] = {
+          processing: false
+        }
+      },
+      10000
+    )
     return false
   }
 }
@@ -1331,30 +1354,44 @@ const processTransactionResponse = (
       return {
         amount: outputTotalValue,
         n: 0,
-        outputIndex: 4294967295,
+        // UINT32_MAX value, as a coinbase has no previous outpoint
+        outputIndex: 0xffffffff,
         scriptPubkey: '', // Maybe there's a bogus scriptPubkey we can use here?
         sequence: vin.sequence,
         txId: '0000000000000000000000000000000000000000000000000000000000000000'
       }
     }
 
-    if (vin.txid == null) {
-      throw new Error(`Unexpected null txid when processing transaction inputs`)
-    }
-
-    const scriptPubkey =
+    let scriptPubkey = 'unknown'
+    try {
       // Note: Blockbook has empirically not sent a hex value as the
       // scriptPubkey for vins. If we discover this to be changed for some
       // cases, we may want to use the `hex` field as an optimization.
-      _cleaners.asMaybe.call(void 0, 
-        raw => _utils3.validScriptPubkeyFromAddress.call(void 0, raw),
-        'unknown'
-      )({
+      scriptPubkey = _utils3.validScriptPubkeyFromAddress.call(void 0, {
         address: vin.addresses[0],
         coin: common.pluginInfo.coinInfo.name
       })
+    } catch (error) {
+      common.log.warn(
+        `failed to get scriptPubkey from address ${vin.addresses[0]}: `,
+        error
+      )
+    }
+
+    // Some inputs may not have a txid in addition to coinbase inputs, such as
+    // private transaction inputs from privacy chains (e.g. SparkSpend inputs in FIRO).
+    // Warning: Because the engine doesn't support private transactions, or any
+    // transaction outputs that wouldn't have a txid as their input in the spend transaction,
+    // we can safely assume an all-zero txid for these inputs.
+    // If we're to ever support private transaction spends, then this wouldn't
+    // be safe to assume as "our own input" because it wouldn't remove the UTXO
+    // from the DataLayer properly.
+    const txId =
+      _nullishCoalesce(vin.txid, () => (
+      '0000000000000000000000000000000000000000000000000000000000000000'))
+
     return {
-      txId: vin.txid,
+      txId,
       outputIndex: vin.vout,
       n: vin.n,
       scriptPubkey,
@@ -1681,3 +1718,22 @@ const addToDataLayerUtxoCache = (
   dataLayerUtxoCache[scriptPubkey] = dataLayerUtxos
   dataLayerUtxos.full = dataLayerUtxos.utxos.length >= requiredCount
 }
+
+/**
+ * This adds a pending timeout to the common.pendingTimeouts set.
+ * It will call the callback after the timeout.
+ *
+ * This utility is a safe way to add pending timeouts for the processor because
+ * it will clear the timeout when the processor stops.
+ */
+const addPendingTimeout = (
+  common,
+  callback,
+  timeout
+) => {
+  const timeoutId = setTimeout(() => {
+    common.pendingTimeouts.delete(timeoutId)
+    callback()
+  }, timeout)
+  common.pendingTimeouts.add(timeoutId)
+}

package/lib/src/common/utxobased/engine/UtxoEngineProcessor.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { EdgeFreshAddress, EdgeIo, EdgeLog, EdgeTransaction } from 'edge-core-js/types';
 import { EngineEmitter } from '../../plugin/EngineEmitter';
 import { ChangePath, CurrencyFormat, EngineConfig, PluginInfo } from '../../plugin/types';
@@ -40,6 +41,7 @@ interface CommonParams {
     dataLayer: DataLayer;
     emitter: EngineEmitter;
     taskCache: TaskCache;
+    pendingTimeouts: Set<NodeJS.Timeout>;
     updateProgressRatio: () => void;
     updateSeenTxCheckpoint: () => void;
     io: EdgeIo;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edge-currency-plugins",
-  "version": "3.8.6",
+  "version": "3.8.8",
   "description": "Edge currency plugins to fetch and process wallet accounts, balances and transactions.",
   "homepage": "https://edge.app/",
   "repository": "https://github.com/EdgeApp/edge-currency-plugins",