edge-currency-plugins 3.16.0 → 3.17.0

package/lib/common/plugin/types.js

@@ -314,6 +314,17 @@ var _types3 = require('../utxobased/db/types');
 
 
 
+
+
+
+
+
+
+
+
+
+
+
 
 
 

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

@@ -16,6 +16,9 @@ var _Blockbook = require('../network/Blockbook');
 
 
 var _blockbookApi = require('../network/blockbookApi');
+
+
+
 var _BlockbookElectrum = require('../network/BlockbookElectrum');
 var _Deferred = require('../network/Deferred'); var _Deferred2 = _interopRequireDefault(_Deferred);
 
@@ -116,6 +119,7 @@ var _constants = require('./constants');
 
 
 
+
 
 
 /**
@@ -510,7 +514,7 @@ const withTimeout = async (
       }
 
       // Create a new blockbook instance based on the URI scheme
-      if (['electrumwss', 'electrumws'].includes(parsed.scheme)) {
+      if (_BlockbookElectrum.isElectrumUri.call(void 0, uri)) {
         // Electrum wrapper
         blockbook = _BlockbookElectrum.makeBlockbookElectrum.call(void 0, {
           asAddress: pluginInfo.engineInfo.asBlockbookAddress,
@@ -862,6 +866,18 @@ const withTimeout = async (
       return true
     },
 
+    serverCanGetAddressHistory(uri, address) {
+      // Electrum only reports how many transactions an address has, so the
+      // history goes to a connected Blockbook server whenever there is one.
+      // Without one, the counts still let the wallet finish syncing:
+      const hasBlockbook = Object.entries(serverStatesCache).some(
+        ([otherUri, state]) =>
+          !_BlockbookElectrum.isElectrumUri.call(void 0, otherUri) && state.blockbook.isConnected
+      )
+      if (_BlockbookElectrum.isElectrumUri.call(void 0, uri) && hasBlockbook) return false
+      return instance.serverCanGetAddress(uri, address)
+    },
+
     serverIsAwareOfAddress(uri, address) {
       const serverState = serverStatesCache[uri]
       if (serverState == null) return false

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

@@ -38,6 +38,7 @@ var _keymanager = require('../keymanager/keymanager');
 
 
 
+var _BlockbookElectrum = require('../network/BlockbookElectrum');
 
 var _awaitlock = require('./await-lock'); var _awaitlock2 = _interopRequireDefault(_awaitlock);
 var _constants = require('./constants');
@@ -126,6 +127,11 @@ var _utils3 = require('./utils');
     pendingTimeouts.clear()
   }
 
+  // Addresses whose history an Electrum server answered. Electrum only
+  // reports how many transactions an address has, so a Blockbook server
+  // queries these again once one is picking tasks:
+  const electrumHistoryAddresses = new Set()
+
   const clearTaskCache = () => {
     for (const key of Object.keys(taskCache.addressForTransactionsCache)) {
       _utils.removeItem.call(void 0, taskCache.addressForTransactionsCache, key)
@@ -148,6 +154,7 @@ var _utils3 = require('./utils');
     for (const key of Object.keys(taskCache.transactionUpdateCache)) {
       _utils.removeItem.call(void 0, taskCache.transactionUpdateCache, key)
     }
+    electrumHistoryAddresses.clear()
   }
 
   /**
@@ -224,6 +231,28 @@ var _utils3 = require('./utils');
     }
   }
 
+  /**
+   * Queues already-processed addresses to be queried again. Each query starts
+   * from the address's stored lastQueriedBlockHeight, and the address only
+   * counts as processed once the new queries complete. Returns how many
+   * addresses were re-queued.
+   */
+  const reopenAddresses = (addresses) => {
+    let reopened = 0
+    for (const address of addresses) {
+      const cacheItem = taskCache.addressSubscribeCache[address]
+      if (cacheItem == null || !cacheItem.processing) continue
+      cacheItem.processing = false
+      taskCache.addressForUtxosCache[address] = {
+        processing: false,
+        path: cacheItem.path
+      }
+      progressByScriptPubkey.delete(walletTools.addressToScriptPubkey(address))
+      reopened++
+    }
+    return reopened
+  }
+
   const lock = new (0, _awaitlock2.default)()
 
   const serverStates = _ServerStates.makeServerStates.call(void 0, {
@@ -243,6 +272,8 @@ var _utils3 = require('./utils');
     emitter,
     taskCache,
     pendingTimeouts,
+    electrumHistoryAddresses,
+    reopenAddresses,
     updateProgressRatio,
     updateSeenTxCheckpoint,
     io,
@@ -296,21 +327,9 @@ var _utils3 = require('./utils');
     // query starts from the address's stored lastQueriedBlockHeight, which is
     // never above the height of the server that answered it, so the range
     // the dropped server missed is fetched again.
-    let requeued = 0
-    for (const [address, cacheItem] of Object.entries(
-      taskCache.addressSubscribeCache
-    )) {
-      if (!cacheItem.processing) continue
-      cacheItem.processing = false
-      taskCache.addressForUtxosCache[address] = {
-        processing: false,
-        path: cacheItem.path
-      }
-      // The re-query has to complete again before the address counts as
-      // processed:
-      progressByScriptPubkey.delete(walletTools.addressToScriptPubkey(address))
-      requeued++
-    }
+    const requeued = reopenAddresses(
+      Object.keys(taskCache.addressSubscribeCache)
+    )
     log(`${uri} dropped, re-queued ${requeued} addresses`)
   })
 
@@ -774,6 +793,8 @@ const internalGetFreshAddress = async (
 
 
 
+
+
 
 
 
@@ -926,6 +947,15 @@ const needsTxSpecific = (common) => {
   const serverState = common.serverStates.getServerState(serverUri)
   if (serverState == null) return false
 
+  // Re-query the addresses whose history came from Electrum, now that a
+  // Blockbook server can answer with their transactions:
+  const { electrumHistoryAddresses } = common
+  if (!_BlockbookElectrum.isElectrumUri.call(void 0, serverUri) && electrumHistoryAddresses.size > 0) {
+    const reopened = common.reopenAddresses(electrumHistoryAddresses)
+    electrumHistoryAddresses.clear()
+    common.log(`${serverUri} re-queued ${reopened} addresses Electrum answered`)
+  }
+
   // subscribe all servers to new blocks
   if (serverState.blockSubscriptionStatus === 'unsubscribed') {
     common.serverStates.watchBlocks(serverUri)
@@ -1096,7 +1126,7 @@ const needsTxSpecific = (common) => {
   )) {
     if (
       !cacheItem.processing &&
-      common.serverStates.serverCanGetAddress(serverUri, address)
+      common.serverStates.serverCanGetAddressHistory(serverUri, address)
     ) {
       cacheItem.processing = true
 
@@ -1289,9 +1319,10 @@ async function* processAddressForTransactions(
   // answering server has indexed, so a lagging server cannot move
   // lastQueriedBlockHeight past blocks it never saw. A height of 0 means this
   // server has not reported one yet, so nothing it answers can be trusted to
-  // move the cursor; the next query covers the range again.
+  // move the cursor; the next query covers the range again. Electrum answers
+  // carry no transactions, so they never move it either:
   const queriedHeight =
-    serverState.blockHeight > 0
+    serverState.blockHeight > 0 && !_BlockbookElectrum.isElectrumUri.call(void 0, serverUri)
       ? Math.min(blockHeight, serverState.blockHeight)
       : addressData.lastQueriedBlockHeight
 
@@ -1386,6 +1417,10 @@ async function* processAddressForTransactions(
     // Save/update the fully-processed address
     await common.dataLayer.saveAddress(addressData)
 
+    // Electrum saved no transactions, so a Blockbook server queries this
+    // address again once one is picking tasks:
+    if (_BlockbookElectrum.isElectrumUri.call(void 0, serverUri)) common.electrumHistoryAddresses.add(address)
+
     // Extend the lookahead before counting progress, so any addresses it adds
     // are in the total before this address's flag can bring the ratio to 1:
     await setLookAhead(common)

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

@@ -12,6 +12,8 @@ var _digibyte = require('./digibyte'); _createNamedExportFrom(_digibyte, 'digiby
 var _dogecoin = require('./dogecoin'); _createNamedExportFrom(_dogecoin, 'dogecoin', 'info');
 var _eboost = require('./eboost'); _createNamedExportFrom(_eboost, 'eboost', 'info');
 var _ecash = require('./ecash'); _createNamedExportFrom(_ecash, 'ecash', 'info');
+var _ecashbitcoin = require('./ecashbitcoin'); _createNamedExportFrom(_ecashbitcoin, 'ecashbitcoin', 'info');
+var _ecashbitcoinbetanet = require('./ecashbitcoinbetanet'); _createNamedExportFrom(_ecashbitcoinbetanet, 'ecashbitcoinbetanet', 'info');
 var _feathercoin = require('./feathercoin'); _createNamedExportFrom(_feathercoin, 'feathercoin', 'info');
 var _groestlcoin = require('./groestlcoin'); _createNamedExportFrom(_groestlcoin, 'groestlcoin', 'info');
 var _litecoin = require('./litecoin'); _createNamedExportFrom(_litecoin, 'litecoin', 'info');
@@ -45,6 +47,8 @@ var _zcoin = require('./zcoin'); _createNamedExportFrom(_zcoin, 'zcoin', 'info')
 
 
 
+
+
 
 
 
@@ -63,6 +67,8 @@ var _zcoin = require('./zcoin'); _createNamedExportFrom(_zcoin, 'zcoin', 'info')
   _dogecoin.info,
   _eboost.info,
   _ecash.info,
+  _ecashbitcoin.info,
+  _ecashbitcoinbetanet.info,
   _feathercoin.info,
   _groestlcoin.info,
   _litecoin.info,

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

@@ -62,7 +62,7 @@ const engineInfo = {
     }
   ],
   formats: ['bip49', 'bip84', 'bip44', 'bip32'],
-  forks: ['bitcoincash', 'bitcoingold'],
+  forks: ['bitcoincash', 'bitcoingold', 'ecashbitcoin', 'ecashbitcoinbetanet'],
   gapLimit: 25,
   feeUpdateInterval: 60000,
   mempoolSpaceFeeInfoServer: 'https://mempool.space/api/v1/fees/precise',

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

@@ -0,0 +1,90 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _maximumFeeRateCalculator = require('../../plugin/util/maximumFeeRateCalculator');
+
+
+
+
+var _commonInfo = require('./commonInfo');
+
+const currencyInfo = {
+  assetDisplayName: 'eCash',
+  canReplaceByFee: true,
+  chainDisplayName: 'eCash',
+  currencyCode: 'ECX',
+  customFeeTemplate: _commonInfo.utxoCustomFeeTemplate,
+  memoOptions: _commonInfo.utxoMemoOptions,
+  pluginId: 'ecashbitcoin',
+  walletType: 'wallet:ecashbitcoin',
+
+  // Explorers:
+  blockExplorer: 'https://explorer.ecash.ninja/block/%s',
+  addressExplorer: 'https://explorer.ecash.ninja/address/%s',
+  transactionExplorer: 'https://explorer.ecash.ninja/tx/%s',
+
+  denominations: [
+    { name: 'ECX', multiplier: '100000000' },
+    { name: 'sats', multiplier: '1', symbol: 's' }
+  ],
+
+  // Deprecated:
+  ..._commonInfo.legacyMemoInfo,
+  defaultSettings: {
+    customFeeSettings: ['satPerByte'],
+    blockbookServers: ['wss://blockbook.ecash.ninja/websocket'],
+    enableCustomServers: false
+  },
+  displayName: 'eCash',
+  metaTokens: []
+}
+
+const engineInfo = {
+  formats: ['bip49', 'bip84', 'bip44', 'bip32'],
+  // Matches Bitcoin, so wallets split from Bitcoin find every pre-fork address:
+  gapLimit: 25,
+  feeUpdateInterval: 60000,
+  mempoolSpaceFeeInfoServer: 'https://explorer.ecash.ninja/api/v1/fees/precise',
+  defaultFeeInfo: {
+    lowFeeFudgeFactor: undefined,
+    standardFeeLowFudgeFactor: undefined,
+    standardFeeHighFudgeFactor: undefined,
+    highFeeFudgeFactor: undefined,
+
+    highFee: '10',
+    lowFee: '1',
+    standardFeeLow: '2',
+    standardFeeHigh: '5',
+    standardFeeLowAmount: '173200',
+    standardFeeHighAmount: '8670000',
+    maximumFeeRate: _maximumFeeRateCalculator.maximumFeeRateCalculator.call(void 0, currencyInfo, 100)
+  }
+}
+
+ const coinInfo = {
+  name: 'ecashbitcoin',
+  segwit: true,
+  coinType: 0,
+  // LOCKTIME_THRESHOLD - 2, final only on eCash mainnet:
+  lockTime: 499999998,
+
+  prefixes: {
+    messagePrefix: ['\x18Bitcoin Signed Message:\n'],
+    wif: [0x80],
+    legacyXPriv: [0x0488ade4],
+    legacyXPub: [0x0488b21e],
+    wrappedSegwitXPriv: [0x049d7878],
+    wrappedSegwitXPub: [0x049d7cb2],
+    segwitXPriv: [0x04b2430c],
+    segwitXPub: [0x04b24746],
+    pubkeyHash: [0x00],
+    scriptHash: [0x05],
+    bech32: ['bc']
+  }
+}; exports.coinInfo = coinInfo
+
+ const info = {
+  currencyInfo,
+  engineInfo,
+  coinInfo: exports.coinInfo
+}; exports.info = info

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

@@ -0,0 +1,91 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _maximumFeeRateCalculator = require('../../plugin/util/maximumFeeRateCalculator');
+
+
+
+
+var _commonInfo = require('./commonInfo');
+
+const currencyInfo = {
+  assetDisplayName: 'eCash Betanet',
+  canReplaceByFee: true,
+  chainDisplayName: 'eCash Betanet',
+  currencyCode: 'BETAECX',
+  customFeeTemplate: _commonInfo.utxoCustomFeeTemplate,
+  memoOptions: _commonInfo.utxoMemoOptions,
+  pluginId: 'ecashbitcoinbetanet',
+  walletType: 'wallet:ecashbitcoinbetanet',
+
+  // Explorers:
+  blockExplorer: 'https://explorer.beta.ecash.ninja/block/%s',
+  addressExplorer: 'https://explorer.beta.ecash.ninja/address/%s',
+  transactionExplorer: 'https://explorer.beta.ecash.ninja/tx/%s',
+
+  denominations: [
+    { name: 'BETAECX', multiplier: '100000000' },
+    { name: 'sats', multiplier: '1', symbol: 's' }
+  ],
+
+  // Deprecated:
+  ..._commonInfo.legacyMemoInfo,
+  defaultSettings: {
+    customFeeSettings: ['satPerByte'],
+    blockbookServers: ['wss://blockbook.beta.ecash.ninja/websocket'],
+    enableCustomServers: false
+  },
+  displayName: 'eCash Betanet',
+  metaTokens: []
+}
+
+const engineInfo = {
+  formats: ['bip49', 'bip84', 'bip44', 'bip32'],
+  // Matches Bitcoin, so wallets split from Bitcoin find every pre-fork address:
+  gapLimit: 25,
+  feeUpdateInterval: 60000,
+  mempoolSpaceFeeInfoServer:
+    'https://explorer.beta.ecash.ninja/api/v1/fees/precise',
+  defaultFeeInfo: {
+    lowFeeFudgeFactor: undefined,
+    standardFeeLowFudgeFactor: undefined,
+    standardFeeHighFudgeFactor: undefined,
+    highFeeFudgeFactor: undefined,
+
+    highFee: '10',
+    lowFee: '1',
+    standardFeeLow: '2',
+    standardFeeHigh: '5',
+    standardFeeLowAmount: '173200',
+    standardFeeHighAmount: '8670000',
+    maximumFeeRate: _maximumFeeRateCalculator.maximumFeeRateCalculator.call(void 0, currencyInfo, 100)
+  }
+}
+
+ const coinInfo = {
+  name: 'ecashbitcoinbetanet',
+  segwit: true,
+  coinType: 0,
+  // LOCKTIME_THRESHOLD - 1, final only on eCash betanet:
+  lockTime: 499999999,
+
+  prefixes: {
+    messagePrefix: ['\x18Bitcoin Signed Message:\n'],
+    wif: [0x80],
+    legacyXPriv: [0x0488ade4],
+    legacyXPub: [0x0488b21e],
+    wrappedSegwitXPriv: [0x049d7878],
+    wrappedSegwitXPub: [0x049d7cb2],
+    segwitXPriv: [0x04b2430c],
+    segwitXPub: [0x04b24746],
+    pubkeyHash: [0x00],
+    scriptHash: [0x05],
+    bech32: ['bc']
+  }
+}; exports.coinInfo = coinInfo
+
+ const info = {
+  currencyInfo,
+  engineInfo,
+  coinInfo: exports.coinInfo
+}; exports.info = info

package/lib/common/utxobased/keymanager/keymanager.js

@@ -1083,14 +1083,18 @@ function signBip322Witness(
 
  function makeTx(args) {
   const { log, outputSort, memos, memoIndex } = args
+  const coin = _coinmapper.getCoinFromString.call(void 0, args.coin)
+
   let sequence = 0xffffffff
   if (args.enableRbf) {
     sequence -= 2
+  } else if (coin.lockTime != null) {
+    // Nodes ignore nLockTime unless an input sequence is non-final:
+    sequence -= 1
   }
 
   // get coin specific replay protection sighhash bits
   let sighashType = _altcoinjs.Transaction.SIGHASH_ALL
-  const coin = _coinmapper.getCoinFromString.call(void 0, args.coin)
   if (coin.sighash != null) {
     sighashType = coin.sighash
   }
@@ -1246,6 +1250,7 @@ function signBip322Witness(
   }
 
   const psbt = new (0, _altcoinjs.Psbt)()
+  if (coin.lockTime != null) psbt.setLocktime(coin.lockTime)
   try {
     psbt.addInputs(sortedInputs)
     psbt.addOutputs(sortedOutputs)

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

@@ -107,6 +107,8 @@ var _Socket = require('./Socket');
 
 
 
+
+
 
 
 
@@ -232,7 +234,7 @@ var _Socket = require('./Socket');
         )
       }
       socket.subscribe({
-        ..._blockbookApi.subscribeNewBlockMessage.call(void 0, ),
+        ...(_nullishCoalesce(config.subscribeNewBlockMessage, () => ( (0, _blockbookApi.subscribeNewBlockMessage))))(),
         cb: socketCb,
         deferred: deferredBlockSub,
         subscribed: false