edge-currency-plugins 1.2.1 → 1.2.3

package/lib/common/plugin/makeMetadata.js

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var _biggystring = require('biggystring'); var bs = _interopRequireWildcard(_biggystring);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var _biggystring = require('biggystring');
 
 
 var _memlet = require('memlet');
@@ -6,6 +6,7 @@ var _memlet = require('memlet');
 var _awaitlock = require('../utxobased/engine/await-lock'); var _awaitlock2 = _interopRequireDefault(_awaitlock);
 var _makeEngineEmitter = require('./makeEngineEmitter');
 var _types3 = require('./types');
+var _utils = require('./utils');
 
 const metadataPath = `metadata.json`
 
@@ -19,6 +20,7 @@ const metadataPath = `metadata.json`
 
 
 
+
  const makeMetadata = async (
   config
 ) => {
@@ -27,11 +29,8 @@ const metadataPath = `metadata.json`
   const lock = new (0, _awaitlock2.default)()
 
   const instance = {
-    get balance() {
-      return cache.balance
-    },
-    get lastSeenBlockHeight() {
-      return cache.lastSeenBlockHeight
+    get state() {
+      return cache
     },
     clear: async () => {
       await memlet.delete(metadataPath)
@@ -40,18 +39,37 @@ const metadataPath = `metadata.json`
     }
   }
 
+  const updateWalletBalance = async (currencyCode) => {
+    const cumulativeBalance = Object.values(cache.addressBalances).reduce(
+      (sum, addressBalance) => _biggystring.add.call(void 0, sum, addressBalance),
+      '0'
+    )
+    cache.balance = cumulativeBalance
+    await setMetadata(cache)
+    emitter.emit(
+      _makeEngineEmitter.EngineEvent.WALLET_BALANCE_CHANGED,
+      currencyCode,
+      cumulativeBalance
+    )
+  }
+
   emitter.on(
     _makeEngineEmitter.EngineEvent.ADDRESS_BALANCE_CHANGED,
-    async (currencyCode, balanceDiff) => {
+    async (
+      currencyCode,
+      addressBalanceChanges
+    ) => {
       await lock.acquireAsync()
       try {
-        cache.balance = bs.add(cache.balance, balanceDiff)
-        emitter.emit(
-          _makeEngineEmitter.EngineEvent.WALLET_BALANCE_CHANGED,
-          currencyCode,
-          cache.balance
-        )
-        await setMetadata(cache)
+        addressBalanceChanges.forEach(({ scriptPubkey, balance }) => {
+          if (balance === '0') {
+            _utils.removeItem.call(void 0, cache.addressBalances, scriptPubkey)
+          } else {
+            cache.addressBalances[scriptPubkey] = balance
+          }
+        })
+
+        await updateWalletBalance(currencyCode)
       } catch (err) {
         log.error(err)
       } finally {
@@ -83,6 +101,7 @@ const metadataPath = `metadata.json`
   const resetMetadata = async () => {
     const data = {
       balance: '0',
+      addressBalances: {},
       lastSeenBlockHeight: 0
     }
     await memlet.setJson(metadataPath, data)

package/lib/common/plugin/types.js

@@ -125,6 +125,11 @@ var _cleaners = require('cleaners');
 
 
 
+
+
+
+
+
 
 
 
@@ -162,5 +167,7 @@ var _cleaners = require('cleaners');
 
  const asLocalWalletMetadata = _cleaners.asObject.call(void 0, {
   balance: _cleaners.asString,
+  // scriptPubkey -> balance
+  addressBalances: _cleaners.asObject.call(void 0, _cleaners.asString),
   lastSeenBlockHeight: _cleaners.asNumber
 }); exports.asLocalWalletMetadata = asLocalWalletMetadata

package/lib/common/utxobased/db/Models/ProcessorTransaction.js

@@ -117,6 +117,7 @@ var _keymanager = require('../../keymanager/keymanager');
     currencyCode: currencyInfo.currencyCode,
     txid: tx.txid,
     blockHeight: tx.blockHeight,
+    confirmations: tx.confirmations,
     date: tx.date,
     nativeAmount: tx.ourAmount,
     networkFee: tx.fees,

package/lib/common/utxobased/db/types.js

@@ -63,5 +63,6 @@
 
 
 
+
 
 

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

@@ -124,7 +124,7 @@ var _utils = require('./utils');
       emitter.emit(
         _makeEngineEmitter.EngineEvent.WALLET_BALANCE_CHANGED,
         currencyInfo.currencyCode,
-        metadata.balance
+        metadata.state.balance
       )
 
       pluginState.addEngine(engineState)
@@ -139,11 +139,11 @@ var _utils = require('./utils');
     },
 
     getBalance(_opts) {
-      return metadata.balance
+      return metadata.state.balance
     },
 
     getBlockHeight() {
-      return metadata.lastSeenBlockHeight
+      return metadata.state.lastSeenBlockHeight
     },
 
     async addCustomToken(_token) {
@@ -196,6 +196,7 @@ var _utils = require('./utils');
             primaryFormat,
             walletFormats
           },
+          metadataState: metadata.state,
           processorState: await processor.dumpData(),
           pluginState: pluginState.dumpData()
         }
@@ -644,7 +645,7 @@ var _utils = require('./utils');
               throw new Error('Private key has no funds')
             }
             const destAddress = await this.getFreshAddress({})
-            const nativeAmount = tmpMetadata.balance
+            const nativeAmount = tmpMetadata.state.balance
             const options = { utxos: tmpUtxos, subtractFee: true }
             spendInfo.spendTargets = [
               { publicAddress: destAddress.publicAddress, nativeAmount }

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

@@ -41,6 +41,7 @@ var _keymanager = require('../keymanager/keymanager');
 
 
 
+
 var _BlockBookAPI = require('../network/BlockBookAPI');
 var _Deferred = require('../network/Deferred'); var _Deferred2 = _interopRequireDefault(_Deferred);
 
@@ -108,7 +109,8 @@ var _utils3 = require('./utils');
     addressUtxoCache: {},
     rawUtxoCache: {},
     processorUtxoCache: {},
-    updateTransactionCache: {}
+    updateTransactionCache: {},
+    updateTransactionSpecificCache: {}
   }
 
   const clearTaskCache = () => {
@@ -131,6 +133,9 @@ var _utils3 = require('./utils');
     for (const key of Object.keys(taskCache.updateTransactionCache)) {
       _utils.removeItem.call(void 0, taskCache.updateTransactionCache, key)
     }
+    for (const key of Object.keys(taskCache.updateTransactionSpecificCache)) {
+      _utils.removeItem.call(void 0, taskCache.updateTransactionSpecificCache, key)
+    }
   }
 
   /**
@@ -253,6 +258,11 @@ var _utils3 = require('./utils');
   // processed by the processor. This happens only once before any call to
   // setLookAhead.
   const initializeAddressSubscriptions = async () => {
+    const addressBalanceChanges
+
+
+ = []
+
     for (const format of walletFormats) {
       const branches = _utils3.getFormatSupportedBranches.call(void 0, format)
       for (const branch of branches) {
@@ -284,6 +294,10 @@ var _utils3 = require('./utils');
             format
           })
           addressesToSubscribe.add(address)
+          addressBalanceChanges.push({
+            scriptPubkey: processorAddress.scriptPubkey,
+            balance: processorAddress.balance
+          })
         }
         addToAddressSubscribeCache(commonArgs.taskCache, addressesToSubscribe, {
           format,
@@ -291,6 +305,15 @@ var _utils3 = require('./utils');
         })
       }
     }
+
+    // Only emit address balance events after processing all initial addresses
+    // because we want to only propagate the wallet balance change event after
+    // initialization is complete.
+    emitter.emit(
+      _makeEngineEmitter.EngineEvent.ADDRESS_BALANCE_CHANGED,
+      pluginInfo.currencyInfo.currencyCode,
+      addressBalanceChanges
+    )
   }
 
   return {
@@ -525,6 +548,10 @@ var _utils3 = require('./utils');
 
 
 
+
+
+
+
 
 
 
@@ -669,7 +696,7 @@ const addToAddressTransactionCache = async (
   args
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) => {
-  const { taskCache, uri, serverStates } = args
+  const { pluginInfo, taskCache, uri, serverStates } = args
 
   const {
     addressSubscribeCache,
@@ -677,9 +704,17 @@ const addToAddressTransactionCache = async (
     rawUtxoCache,
     processorUtxoCache,
     addressTransactionCache,
-    updateTransactionCache
+    updateTransactionCache,
+    updateTransactionSpecificCache
   } = taskCache
 
+  /**
+   * Some currencies require an additional blockbook payload 'getTransactionSpecific' in order
+   * to provide all relevant transaction data. Since this is currency-specific, we can limit
+   * the useage to currencies that require it.
+   **/
+  const needsTxSpecific = pluginInfo.engineInfo.txSpecificHandling != null
+
   const serverState = serverStates.getServerState(uri)
   if (serverState == null) return
 
@@ -799,6 +834,37 @@ const addToAddressTransactionCache = async (
     }
   }
 
+  // filled when transactions potentially changed (e.g. through new block notification)
+  if (Object.keys(updateTransactionSpecificCache).length > 0) {
+    let hasProcessedAtLeastOnce = false
+    for (const [txId, state] of Object.entries(
+      updateTransactionSpecificCache
+    )) {
+      if (!state.processing && serverStates.serverCanGetTx(uri, txId)) {
+        hasProcessedAtLeastOnce = true
+        state.processing = true
+        _utils.removeItem.call(void 0, updateTransactionSpecificCache, txId)
+        const updateTransactionSpecificTask = updateTransactionsSpecific({
+          ...args,
+          txId
+        })
+        // once resolved, add the txid to the server cache
+        updateTransactionSpecificTask.deferred.promise
+          .then(() => {
+            serverState.txids.add(txId)
+          })
+          .catch(err => {
+            updateTransactionSpecificCache[txId] = state
+            console.error(err)
+            args.log('error in updateTransactionSpecificCache:', err)
+          })
+        return updateTransactionSpecificTask
+      }
+    }
+    // This condition prevents infinite loops
+    if (hasProcessedAtLeastOnce) return true
+  }
+
   // filled when transactions potentially changed (e.g. through new block notification)
   if (Object.keys(updateTransactionCache).length > 0) {
     let hasProcessedAtLeastOnce = false
@@ -807,7 +873,11 @@ const addToAddressTransactionCache = async (
         hasProcessedAtLeastOnce = true
         state.processing = true
         _utils.removeItem.call(void 0, updateTransactionCache, txId)
-        const updateTransactionTask = updateTransactions({ ...args, txId })
+        const updateTransactionTask = updateTransactions({
+          ...args,
+          txId,
+          needsTxSpecific
+        })
         // once resolved, add the txid to the server cache
         updateTransactionTask.deferred.promise
           .then(() => {
@@ -836,7 +906,8 @@ const addToAddressTransactionCache = async (
       const wsTask = await processAddressTransactions({
         ...args,
         addressTransactionState: state,
-        address
+        address,
+        needsTxSpecific
       })
       wsTask.deferred.promise
         .then(() => {
@@ -856,11 +927,65 @@ const addToAddressTransactionCache = async (
 
 
 
-const updateTransactions = (
+const updateTransactionsSpecific = (
   args
 ) => {
   const { emitter, walletTools, txId, pluginInfo, processor, taskCache } = args
   const deferred = new _Deferred2.default()
+  deferred.promise
+    .then(async (txResponse) => {
+      // Grab tx to update it
+      const txs = await processor.fetchTransactions({ txId })
+      let tx = txs[0]
+      if (tx == null) return
+
+      if (pluginInfo.engineInfo.txSpecificHandling != null) {
+        // Do coin-specific things to it
+        tx = pluginInfo.engineInfo.txSpecificHandling(tx, txResponse)
+      }
+
+      // Process and save new tx
+      const processedTx = await processor.saveTransaction({
+        tx
+      })
+
+      await exports.transactionChanged.call(void 0, {
+        emitter,
+        walletTools,
+        processor,
+        pluginInfo,
+        tx: processedTx
+      })
+    })
+    .catch(err => {
+      console.error(err)
+      args.log('error in updateTransactionsSpecific:', err)
+      taskCache.updateTransactionSpecificCache[txId] = { processing: false }
+    })
+  return {
+    ..._BlockBookAPI.transactionMessageSpecific.call(void 0, txId),
+    deferred
+  }
+}
+
+
+
+
+
+
+const updateTransactions = (
+  args
+) => {
+  const {
+    emitter,
+    walletTools,
+    txId,
+    needsTxSpecific,
+    pluginInfo,
+    processor,
+    taskCache
+  } = args
+  const deferred = new _Deferred2.default()
   deferred.promise
     .then(async (txResponse) => {
       // check if raw tx is still not confirmed, if so, don't change anything
@@ -885,6 +1010,7 @@ const updateTransactions = (
       const processedTx = await processor.saveTransaction({
         tx
       })
+
       await exports.transactionChanged.call(void 0, {
         emitter,
         walletTools,
@@ -892,6 +1018,13 @@ const updateTransactions = (
         pluginInfo,
         tx: processedTx
       })
+
+      if (needsTxSpecific) {
+        // Add task to grab transactionSpecific payload
+        taskCache.updateTransactionSpecificCache[txId] = {
+          processing: false
+        }
+      }
     })
     .catch(err => {
       console.error(err)
@@ -1002,6 +1135,7 @@ const internalGetFreshAddress = async (
 
 
 
+
 const processAddressTransactions = async (
   args
 ) => {
@@ -1009,6 +1143,7 @@ const processAddressTransactions = async (
     address,
     addressTransactionState,
     emitter,
+    needsTxSpecific,
     pluginInfo,
     processor,
     walletTools,
@@ -1055,6 +1190,13 @@ const processAddressTransactions = async (
           pluginInfo,
           tx: processedTx
         })
+
+        if (needsTxSpecific) {
+          // Add task to grab transactionSpecific payload
+          taskCache.updateTransactionSpecificCache[tx.txid] = {
+            processing: false
+          }
+        }
       }
 
       // Halt on finishing the processing of address transaction until
@@ -1292,13 +1434,17 @@ const processProcessorUtxos = async (
   //
 
   // Address balance and emit address balance change event
-  const diff = _biggystring.sub.call(void 0, newBalance, oldBalance)
-  if (diff !== '0') {
-    log('balance changed:', { scriptPubkey, diff })
+  if (newBalance !== oldBalance) {
+    log('address balance changed:', { scriptPubkey, oldBalance, newBalance })
     emitter.emit(
       _makeEngineEmitter.EngineEvent.ADDRESS_BALANCE_CHANGED,
       currencyInfo.currencyCode,
-      diff
+      [
+        {
+          scriptPubkey,
+          balance: newBalance
+        }
+      ]
     )
 
     // Update balances for address that have this scriptPubkey

package/lib/common/utxobased/info/dash.js

@@ -1,4 +1,6 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _cleaners = require('cleaners');
+
+
 
 
 
@@ -52,6 +54,21 @@ const engineInfo = {
     standardFeeHigh: '200',
     standardFeeLowAmount: '20000000',
     standardFeeHighAmount: '981000000'
+  },
+  txSpecificHandling: (
+    tx,
+    txSpecific
+  ) => {
+    const asDashTransactionSpecific = _cleaners.asObject.call(void 0, {
+      instantlock: _cleaners.asOptional.call(void 0, _cleaners.asBoolean)
+    })
+    const cleanedTxSpecific = _cleaners.asMaybe.call(void 0, asDashTransactionSpecific)(txSpecific)
+
+    if (_optionalChain([cleanedTxSpecific, 'optionalAccess', _ => _.instantlock]) === true) {
+      tx.confirmations = 'confirmed'
+    }
+
+    return tx
   }
 }
 

package/lib/common/utxobased/network/BlockBookAPI.js

@@ -8,6 +8,7 @@
 
 
 
+
 var _cleaners = require('cleaners');
 
 
@@ -211,6 +212,17 @@ var _cleaners = require('cleaners');
 
  const asTransactionResponse = exports.asBlockbookTransaction; exports.asTransactionResponse = asTransactionResponse
 
+/**
+ * Get Transaction Specific
+ */
+ const transactionMessageSpecific = (
+  hash
+) => ({
+  method: 'getTransactionSpecific',
+  params: { txid: hash },
+  cleaner: exports.asBlockbookResponse.call(void 0, _cleaners.asUnknown)
+}); exports.transactionMessageSpecific = transactionMessageSpecific
+
 /**
  * Send Transaction
  */

package/lib/src/common/plugin/makeEngineEmitter.d.ts

@@ -3,8 +3,14 @@ import { EdgeCurrencyEngineCallbacks, EdgeTransaction, EdgeTxidMap } from 'edge-
 import { EventEmitter } from 'events';
 import { SubscribeAddressResponse } from '../utxobased/network/BlockBookAPI';
 export declare interface EngineEmitter {
-    emit: ((event: EngineEvent.TRANSACTIONS_CHANGED, transactions: EdgeTransaction[]) => boolean) & ((event: EngineEvent.ADDRESS_BALANCE_CHANGED, currencyCode: string, nativeDiff: string) => boolean) & ((event: EngineEvent.WALLET_BALANCE_CHANGED, currencyCode: string, nativeBalance: string) => boolean) & ((event: EngineEvent.BLOCK_HEIGHT_CHANGED, uri: string, blockHeight: number) => boolean) & ((event: EngineEvent.NEW_ADDRESS_TRANSACTION, uri: string, newTx: SubscribeAddressResponse) => boolean) & ((event: EngineEvent.ADDRESSES_CHECKED, progressRatio: number) => boolean) & ((event: EngineEvent.TXIDS_CHANGED, txids: EdgeTxidMap) => boolean);
-    on: ((event: EngineEvent.TRANSACTIONS_CHANGED, listener: (transactions: EdgeTransaction[]) => Promise<void> | void) => this) & ((event: EngineEvent.ADDRESS_BALANCE_CHANGED, listener: (currencyCode: string, nativeDiff: string) => Promise<void> | void) => this) & ((event: EngineEvent.WALLET_BALANCE_CHANGED, listener: (currencyCode: string, nativeBalance: string) => Promise<void> | void) => this) & ((event: EngineEvent.BLOCK_HEIGHT_CHANGED, listener: (uri: string, blockHeight: number) => Promise<void> | void) => this) & ((event: EngineEvent.NEW_ADDRESS_TRANSACTION, listener: (uri: string, newTx: SubscribeAddressResponse) => Promise<void> | void) => this) & ((event: EngineEvent.ADDRESSES_CHECKED, listener: (progressRatio: number) => Promise<void> | void) => this) & ((event: EngineEvent.TXIDS_CHANGED, listener: (txids: EdgeTxidMap) => Promise<void> | void) => this);
+    emit: ((event: EngineEvent.TRANSACTIONS_CHANGED, transactions: EdgeTransaction[]) => boolean) & ((event: EngineEvent.ADDRESS_BALANCE_CHANGED, currencyCode: string, addressBalanceChanges: Array<{
+        scriptPubkey: string;
+        balance: string;
+    }>) => boolean) & ((event: EngineEvent.WALLET_BALANCE_CHANGED, currencyCode: string, nativeBalance: string) => boolean) & ((event: EngineEvent.BLOCK_HEIGHT_CHANGED, uri: string, blockHeight: number) => boolean) & ((event: EngineEvent.NEW_ADDRESS_TRANSACTION, uri: string, newTx: SubscribeAddressResponse) => boolean) & ((event: EngineEvent.ADDRESSES_CHECKED, progressRatio: number) => boolean) & ((event: EngineEvent.TXIDS_CHANGED, txids: EdgeTxidMap) => boolean);
+    on: ((event: EngineEvent.TRANSACTIONS_CHANGED, listener: (transactions: EdgeTransaction[]) => Promise<void> | void) => this) & ((event: EngineEvent.ADDRESS_BALANCE_CHANGED, listener: (currencyCode: string, addressBalanceChanges: Array<{
+        scriptPubkey: string;
+        balance: string;
+    }>) => Promise<void> | void) => this) & ((event: EngineEvent.WALLET_BALANCE_CHANGED, listener: (currencyCode: string, nativeBalance: string) => Promise<void> | void) => this) & ((event: EngineEvent.BLOCK_HEIGHT_CHANGED, listener: (uri: string, blockHeight: number) => Promise<void> | void) => this) & ((event: EngineEvent.NEW_ADDRESS_TRANSACTION, listener: (uri: string, newTx: SubscribeAddressResponse) => Promise<void> | void) => this) & ((event: EngineEvent.ADDRESSES_CHECKED, listener: (progressRatio: number) => Promise<void> | void) => this) & ((event: EngineEvent.TXIDS_CHANGED, listener: (txids: EdgeTxidMap) => Promise<void> | void) => this);
 }
 export declare class EngineEmitter extends EventEmitter {
 }

package/lib/src/common/plugin/makeMetadata.d.ts

@@ -7,7 +7,8 @@ interface MetadataConfig {
     emitter: EngineEmitter;
     log: EdgeLog;
 }
-export interface Metadata extends LocalWalletMetadata {
+export interface Metadata {
+    state: LocalWalletMetadata;
     clear: () => Promise<void>;
 }
 export declare const makeMetadata: (config: MetadataConfig) => Promise<Metadata>;

package/lib/src/common/plugin/types.d.ts

@@ -3,7 +3,7 @@ import { bip32 } from 'altcoin-js';
 import { Cleaner } from 'cleaners';
 import { Disklet } from 'disklet';
 import { EdgeCurrencyEngineOptions, EdgeCurrencyInfo, EdgeCurrencyTools, EdgeIo, EdgeParsedUri, EdgeWalletInfo } from 'edge-core-js/types';
-import { IUTXO } from '../utxobased/db/types';
+import { IProcessorTransaction, IUTXO } from '../utxobased/db/types';
 import { ScriptTemplates } from '../utxobased/info/scriptTemplates/types';
 import { UtxoPicker } from '../utxobased/keymanager/utxopicker';
 import { EngineEmitter } from './makeEngineEmitter';
@@ -41,6 +41,7 @@ export interface EngineInfo {
     simpleFeeSettings: SimpleFeeSettings;
     scriptTemplates?: ScriptTemplates;
     asBlockbookAddress?: Cleaner<string>;
+    txSpecificHandling?: (tx: IProcessorTransaction, specialTx: unknown) => IProcessorTransaction;
 }
 /**
  * Coin Info
@@ -129,6 +130,9 @@ export interface EngineOptions extends EdgeCurrencyEngineOptions {
 export declare type LocalWalletMetadata = ReturnType<typeof asLocalWalletMetadata>;
 export declare const asLocalWalletMetadata: import("cleaners").ObjectCleaner<{
     balance: string;
+    addressBalances: {
+        [keys: string]: string;
+    };
     lastSeenBlockHeight: number;
 }>;
 export {};

package/lib/src/common/utxobased/db/types.d.ts

@@ -28,6 +28,7 @@ export interface IProcessorTransaction {
     txid: string;
     hex: string;
     blockHeight: number;
+    confirmations?: 'confirmed' | 'unconfirmed' | 'dropped' | number;
     date: number;
     fees: string;
     inputs: ITransactionInput[];

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

@@ -52,12 +52,18 @@ interface TaskCache {
     readonly processorUtxoCache: ProcessorUtxoCache;
     readonly addressTransactionCache: AddressTransactionCache;
     readonly updateTransactionCache: UpdateTransactionCache;
+    readonly updateTransactionSpecificCache: UpdateTransactionSpecificCache;
 }
 interface UpdateTransactionCache {
     [key: string]: {
         processing: boolean;
     };
 }
+interface UpdateTransactionSpecificCache {
+    [key: string]: {
+        processing: boolean;
+    };
+}
 interface AddressSubscribeCache {
     [key: string]: {
         processing: boolean;

package/lib/src/common/utxobased/network/BlockBookAPI.d.ts

@@ -96,6 +96,10 @@ export declare const asAddressUtxosResponse: (asAddress?: Cleaner<string>) => Cl
 export declare const transactionMessage: (hash: string, asAddress?: Cleaner<string>) => BlockbookTask<TransactionResponse>;
 export declare type TransactionResponse = BlockbookTransaction;
 export declare const asTransactionResponse: (asAddress?: Cleaner<string>) => Cleaner<BlockbookTransaction>;
+/**
+ * Get Transaction Specific
+ */
+export declare const transactionMessageSpecific: (hash: string) => BlockbookTask<unknown>;
 /**
  * Send Transaction
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edge-currency-plugins",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Edge currency plugins to fetch and process wallet accounts, balances and transactions.",
   "repository": "https://github.com/EdgeApp/edge-currency-plugins",
   "license": "MIT",