edge-currency-plugins 1.2.0 → 1.2.2

package/lib/common/plugin/types.js

@@ -125,6 +125,11 @@ var _cleaners = require('cleaners');
 
 
 
+
+
+
+
+
 
 
 

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

@@ -32,6 +32,11 @@ var _ProcessorTransaction = require('../db/Models/ProcessorTransaction');
 
 
 var _cleaners3 = require('../keymanager/cleaners');
+
+
+
+
+
 var _keymanager = require('../keymanager/keymanager');
 var _makeUtxoEngineState = require('./makeUtxoEngineState');
 var _makeUtxoWalletTools = require('./makeUtxoWalletTools');
@@ -514,10 +519,12 @@ var _utils = require('./utils');
 
       // Use the privateKeys (WIFs) from spendInfo, otherwise get them from the
       // PBST inputs.
-      const privateKeys = await (async () => {
+      const privateKeyEncodings = await (async (
+
+) => {
         if (edgeSpendInfo.privateKeys != null) {
           return edgeSpendInfo.privateKeys.map(wif =>
-            walletTools.getPrivateKeyFromWif(wif)
+            walletTools.getPrivateKeyEncodingFromWif(wif)
           )
         } else {
           return await Promise.all(
@@ -533,10 +540,14 @@ var _utils = require('./utils');
               if (_optionalChain([address, 'optionalAccess', _15 => _15.path]) == null)
                 throw new Error('Invalid script pubkey')
 
-              return walletTools.getPrivateKey({
+              const privateKey = walletTools.getPrivateKey({
                 path: address.path,
                 xprivKeys
               })
+              return {
+                hex: privateKey,
+                compressed: true // We shouldn't ever be storing/deriving uncompressed keys
+              }
             })
           )
         }
@@ -544,7 +555,7 @@ var _utils = require('./utils');
       const signedTx = await _keymanager.signTx.call(void 0, {
         psbtBase64: psbt.base64,
         coin: coinInfo.name,
-        privateKeys
+        privateKeyEncodings: privateKeyEncodings
       })
       transaction.txid = signedTx.id
       transaction.signedTx = signedTx.hex

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)
+    }
   }
 
   /**
@@ -525,6 +530,10 @@ var _utils3 = require('./utils');
 
 
 
+
+
+
+
 
 
 
@@ -669,7 +678,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 +686,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 +816,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 +855,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 +888,8 @@ const addToAddressTransactionCache = async (
       const wsTask = await processAddressTransactions({
         ...args,
         addressTransactionState: state,
-        address
+        address,
+        needsTxSpecific
       })
       wsTask.deferred.promise
         .then(() => {
@@ -856,11 +909,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 +992,7 @@ const updateTransactions = (
       const processedTx = await processor.saveTransaction({
         tx
       })
+
       await exports.transactionChanged.call(void 0, {
         emitter,
         walletTools,
@@ -892,6 +1000,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 +1117,7 @@ const internalGetFreshAddress = async (
 
 
 
+
 const processAddressTransactions = async (
   args
 ) => {
@@ -1009,6 +1125,7 @@ const processAddressTransactions = async (
     address,
     addressTransactionState,
     emitter,
+    needsTxSpecific,
     pluginInfo,
     processor,
     walletTools,
@@ -1055,6 +1172,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

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

@@ -11,6 +11,8 @@
 
 
 
+
+
 var _keymanager = require('../keymanager/keymanager');
 
 
@@ -125,12 +127,24 @@ var _utils = require('./utils');
     ) {
       const purposeType = _utils.currencyFormatToPurposeType.call(void 0, format)
       const scriptType = _utils.getScriptTypeFromPurposeType.call(void 0, purposeType)
-      const pubkey = _keymanager.privateKeyToPubkey.call(void 0, 
-        _keymanager.wifToPrivateKey.call(void 0, {
-          wifKey,
-          coin
-        })
-      )
+      const privateKeyEncoding = _keymanager.wifToPrivateKeyEncoding.call(void 0, {
+        wifKey,
+        coin
+      })
+
+      // Restrict only compressed keys for segwit pubkeys as per BIP143
+      // (see https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki#restrictions-on-public-key-type)
+      if (
+        [
+          _keymanager.BIP43PurposeTypeEnum.Segwit,
+          _keymanager.BIP43PurposeTypeEnum.WrappedSegwit
+        ].includes(purposeType) &&
+        !privateKeyEncoding.compressed
+      ) {
+        privateKeyEncoding.compressed = true
+      }
+
+      const pubkey = _keymanager.privateKeyEncodingToPubkey.call(void 0, privateKeyEncoding)
       return _keymanager.pubkeyToScriptPubkey.call(void 0, {
         pubkey: pubkey,
         scriptType
@@ -179,8 +193,8 @@ var _utils = require('./utils');
       })
     },
 
-    getPrivateKeyFromWif(wifKey) {
-      return _keymanager.wifToPrivateKey.call(void 0, {
+    getPrivateKeyEncodingFromWif(wifKey) {
+      return _keymanager.wifToPrivateKeyEncoding.call(void 0, {
         wifKey,
         coin
       })

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

@@ -221,7 +221,7 @@ var _keymanager = require('../keymanager/keymanager');
 
   // Check if the pathname type is a wif
   try {
-    _keymanager.wifToPrivateKey.call(void 0, {
+    _keymanager.wifToPrivateKeyEncoding.call(void 0, {
       wifKey: args.pathname,
       coin: args.coin
     })

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/keymanager/keymanager.js

@@ -230,6 +230,11 @@ var VerifyAddressEnum; (function (VerifyAddressEnum) {
 
 
 
+
+
+
+
+
 
 
 
@@ -785,7 +790,7 @@ const xprivToPrivateKeyInternal = (
   }).toWIF(coinClass.wifEncodeFunc)
 } exports.privateKeyToWIF = privateKeyToWIF;
 
-const wifToPrivateKeyInternal = (
+const wifToPrivateKeyEncodingInternal = (
   prefixIndex,
   args
 ) => {
@@ -795,29 +800,39 @@ const wifToPrivateKeyInternal = (
     forWIF: true,
     prefixIndex
   })
-  return _optionalChain([bitcoin, 'access', _10 => _10.ECPair, 'access', _11 => _11.fromWIF, 'call', _12 => _12(
+  const ecPair = bitcoin.ECPair.fromWIF(
     args.wifKey,
     network,
     coin.bs58DecodeFunc
-  ), 'access', _13 => _13.privateKey, 'optionalAccess', _14 => _14.toString, 'call', _15 => _15('hex')])
+  )
+  if (ecPair.privateKey == null) return
+  return {
+    hex: ecPair.privateKey.toString('hex'),
+    compressed: ecPair.compressed
+  }
 }
- const wifToPrivateKey = (args) => {
-  const privateKey = filterCoinPrefixes(
+ const wifToPrivateKeyEncoding = (
+  args
+) => {
+  const privateKeyEncoding = filterCoinPrefixes(
     args.coin,
-    prefixIndex => wifToPrivateKeyInternal(prefixIndex, args),
+    prefixIndex => wifToPrivateKeyEncodingInternal(prefixIndex, args),
     ['Invalid network version']
   )
-  if (privateKey == null) {
+  if (privateKeyEncoding == null) {
     throw new Error('Failed to convert WIF key to private key')
   }
-  return privateKey
-}; exports.wifToPrivateKey = wifToPrivateKey
+  return privateKeyEncoding
+}; exports.wifToPrivateKeyEncoding = wifToPrivateKeyEncoding
 
- function privateKeyToPubkey(privateKey) {
-  return bitcoin.ECPair.fromPrivateKey(
-    Buffer.from(privateKey, 'hex')
-  ).publicKey.toString('hex')
-} exports.privateKeyToPubkey = privateKeyToPubkey;
+ function privateKeyEncodingToPubkey(
+  privateKeyEncoding
+) {
+  const { hex, compressed } = privateKeyEncoding
+  return bitcoin.ECPair.fromPrivateKey(Buffer.from(hex, 'hex'), {
+    compressed
+  }).publicKey.toString('hex')
+} exports.privateKeyEncodingToPubkey = privateKeyEncodingToPubkey;
 
  function signMessageBase64(message, privateKey) {
   const keyPair = bitcoin.ECPair.fromPrivateKey(Buffer.from(privateKey, 'hex'))
@@ -977,7 +992,7 @@ const wifToPrivateKeyInternal = (
     psbt.addInputs(sortedInputs)
     psbt.addOutputs(sortedOutputs)
   } catch (error) {
-    _optionalChain([log, 'optionalAccess', _16 => _16.error, 'call', _17 => _17(`Failed makeTx: ${String(error)}`)])
+    _optionalChain([log, 'optionalAccess', _10 => _10.error, 'call', _11 => _11(`Failed makeTx: ${String(error)}`)])
     throw error
   }
 
@@ -987,7 +1002,7 @@ const wifToPrivateKeyInternal = (
     changeUsed: result.changeUsed,
     fee: result.fee,
     psbtBase64: psbt.toBase64(),
-    hex: _optionalChain([psbt, 'access', _18 => _18.data, 'optionalAccess', _19 => _19.globalMap, 'optionalAccess', _20 => _20.unsignedTx, 'optionalAccess', _21 => _21.toBuffer, 'call', _22 => _22(), 'optionalAccess', _23 => _23.toString, 'call', _24 => _24('hex')])
+    hex: _optionalChain([psbt, 'access', _12 => _12.data, 'optionalAccess', _13 => _13.globalMap, 'optionalAccess', _14 => _14.unsignedTx, 'optionalAccess', _15 => _15.toBuffer, 'call', _16 => _16(), 'optionalAccess', _17 => _17.toString, 'call', _18 => _18('hex')])
   }
 } exports.makeTx = makeTx;
 
@@ -996,13 +1011,13 @@ const wifToPrivateKeyInternal = (
   const coin = _coinmapper.getCoinFromString.call(void 0, args.coin)
 
   for (let i = 0; i < psbt.inputCount; i++) {
-    const privateKey = Buffer.from(
-      _nullishCoalesce(args.privateKeys[i], () => ( args.privateKeys[args.privateKeys.length - 1])),
-      'hex'
-    )
+    const privateKeyEncoding =
+      _nullishCoalesce(args.privateKeyEncodings[i], () => (
+      args.privateKeyEncodings[args.privateKeyEncodings.length - 1]))
+    const { hex, compressed } = privateKeyEncoding
     psbt.signInput(
       i,
-      bitcoin.ECPair.fromPrivateKey(privateKey),
+      bitcoin.ECPair.fromPrivateKey(Buffer.from(hex, 'hex'), { compressed }),
       bitcoin.Psbt.DEFAULT_SIGHASHES,
       coin.sighashFunction
     )

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/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

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/engine/makeUtxoWalletTools.d.ts

@@ -1,6 +1,7 @@
 import { AddressPath, CurrencyFormat } from '../../plugin/types';
 import { ScriptTemplate } from '../info/scriptTemplates/types';
 import { PublicKey } from '../keymanager/cleaners';
+import { PrivateKeyEncoding } from '../keymanager/keymanager';
 import { CurrencyFormatKeys } from './utils';
 export interface WalletToolsConfig {
     publicKey: PublicKey;
@@ -14,7 +15,7 @@ export interface UTXOPluginWalletTools {
     addressToScriptPubkey: (address: string) => string;
     scriptPubkeyToAddress: (args: ScriptPubkeyToAddressArgs) => AddressReturn;
     getPrivateKey: (args: GetPrivateKeyArgs) => string;
-    getPrivateKeyFromWif: (wif: string) => string;
+    getPrivateKeyEncodingFromWif: (wif: string) => PrivateKeyEncoding;
     getScriptAddress: (args: GetScriptAddressArgs) => GetScriptAddressReturn;
     signMessageBase64: (args: SignMessageArgs) => string;
 }

package/lib/src/common/utxobased/keymanager/keymanager.d.ts

@@ -101,10 +101,14 @@ export interface ScriptPubkeyToP2SHReturn {
     redeemScript: string;
     address?: string;
 }
-export interface WIFToPrivateKeyArgs {
+export interface WIFToPrivateKeyEncodingArgs {
     wifKey: string;
     coin: string;
 }
+export interface PrivateKeyEncoding {
+    hex: string;
+    compressed: boolean;
+}
 export interface PrivateKeyToWIFArgs {
     privateKey: string;
     coin: string;
@@ -145,7 +149,7 @@ interface MakeTxReturn extends Required<utxopicker.UtxoPickerResult> {
     psbtBase64: string;
 }
 export interface SignTxArgs {
-    privateKeys: string[];
+    privateKeyEncodings: PrivateKeyEncoding[];
     psbtBase64: string;
     coin: string;
 }
@@ -195,8 +199,8 @@ export declare function pubkeyToScriptPubkey(args: PubkeyToScriptPubkeyArgs): Pu
 export declare const toNewFormat: (address: string, coinName: string) => string;
 export declare const xprivToPrivateKey: (args: XPrivToPrivateKeyArgs) => string;
 export declare function privateKeyToWIF(args: PrivateKeyToWIFArgs): string;
-export declare const wifToPrivateKey: (args: WIFToPrivateKeyArgs) => string;
-export declare function privateKeyToPubkey(privateKey: string): string;
+export declare const wifToPrivateKeyEncoding: (args: WIFToPrivateKeyEncodingArgs) => PrivateKeyEncoding;
+export declare function privateKeyEncodingToPubkey(privateKeyEncoding: PrivateKeyEncoding): string;
 export declare function signMessageBase64(message: string, privateKey: string): string;
 export declare function makeTx(args: MakeTxArgs): MakeTxReturn;
 export declare function signTx(args: SignTxArgs): Promise<SignTxReturn>;

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.0",
+  "version": "1.2.2",
   "description": "Edge currency plugins to fetch and process wallet accounts, balances and transactions.",
   "repository": "https://github.com/EdgeApp/edge-currency-plugins",
   "license": "MIT",