edge-currency-plugins 3.15.0 → 3.17.0

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()
   }
 
   /**
@@ -156,9 +163,25 @@ var _utils3 = require('./utils');
    * 2. Address UTXO processing
    **/
   const processesPerAddress = 2
-  let processedCount = 0
+  // Which of the two processes have completed, per address (by scriptPubkey).
+  // Flags rather than a running count, so an address re-queued after a server
+  // drop is not counted twice and the ratio cannot pass 1 with work pending.
+  const progressByScriptPubkey = new Map
+
+
+()
   let processedPercent = 0 // last sync ratio emitted
-  const updateProgressRatio = async () => {
+  const updateProgressRatio = async (
+    scriptPubkey,
+    process
+  ) => {
+    const progress = _nullishCoalesce(progressByScriptPubkey.get(scriptPubkey), () => ( {
+      txs: false,
+      utxos: false
+    }))
+    progress[process] = true
+    progressByScriptPubkey.set(scriptPubkey, progress)
+
     // Avoid re-sending sync ratios / sending ratios larger than 1
     if (processedPercent >= 1) return
 
@@ -167,8 +190,11 @@ var _utils3 = require('./utils');
     const expectedProcessCount =
       Object.keys(taskCache.addressSubscribeCache).length * processesPerAddress
 
-    // Increment the processed count
-    processedCount = processedCount + 1
+    let processedCount = 0
+    for (const { txs, utxos } of progressByScriptPubkey.values()) {
+      if (txs) processedCount++
+      if (utxos) processedCount++
+    }
 
     // If we have no addresses, we should not have not yet began processing.
     if (expectedProcessCount === 0) throw new Error('No addresses to process')
@@ -205,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, {
@@ -224,6 +272,8 @@ var _utils3 = require('./utils');
     emitter,
     taskCache,
     pendingTimeouts,
+    electrumHistoryAddresses,
+    reopenAddresses,
     updateProgressRatio,
     updateSeenTxCheckpoint,
     io,
@@ -244,8 +294,14 @@ var _utils3 = require('./utils');
     if (running) return
     running = true
 
-    await initializeAddressSubscriptions()
-    await setLookAhead(common)
+    try {
+      await initializeAddressSubscriptions()
+      await setLookAhead(common)
+    } catch (error) {
+      // Let the next call try again instead of skipping the initialization:
+      running = false
+      throw error
+    }
   }
 
   emitter.on(
@@ -265,6 +321,18 @@ var _utils3 = require('./utils');
     }
   )
 
+  emitter.on(_EngineEmitter.EngineEvent.SERVER_DROPPED, (uri) => {
+    // Everything this server told us about may stop short of the chain tip.
+    // Re-open every address so the surviving connection re-queries it. Each
+    // 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.
+    const requeued = reopenAddresses(
+      Object.keys(taskCache.addressSubscribeCache)
+    )
+    log(`${uri} dropped, re-queued ${requeued} addresses`)
+  })
+
   emitter.on(
     _EngineEmitter.EngineEvent.NEW_ADDRESS_TRANSACTION,
     async (_uri, response) => {
@@ -290,6 +358,30 @@ var _utils3 = require('./utils');
     }
   )
 
+  // The DataLayer can count an address that it can no longer read, such as
+  // when a write to disk was cut short. Every address derives from the wallet
+  // keys and its path, so rebuild the missing row instead of failing the
+  // engine. The rebuilt row has no sync state, so the address syncs again.
+  const repairAddress = async (path) => {
+    const { format, changeIndex, addressIndex } = path
+    const pathName = `${format}/${changeIndex}/${addressIndex}`
+    log.warn(`Repairing missing data-layer address with '${pathName}' path`)
+
+    const { scriptPubkey, redeemScript } = walletTools.getScriptPubkey(path)
+    await dataLayer.saveAddress(
+      _types5.makeAddressData.call(void 0, { scriptPubkey, redeemScript, path })
+    )
+
+    // Read the row back, since the save keeps any state that survived:
+    const addressData = await dataLayer.fetchAddress(path)
+    if (addressData == null) {
+      throw new Error(
+        `Missing data-layer address with '${pathName}' path during initialization`
+      )
+    }
+    return addressData
+  }
+
   // Initialize the addressSubscribeCache with the existing addresses already
   // processed by the DataLayer. This happens only once before any call to
   // setLookAhead.
@@ -318,16 +410,13 @@ var _utils3 = require('./utils');
           addressIndex < branchAddressCount;
           addressIndex++
         ) {
-          const addressData = await dataLayer.fetchAddress({
+          const path = {
             format,
             changeIndex: branch,
             addressIndex
-          })
-          if (addressData == null) {
-            throw new Error(
-              `Missing data-layer address with '${format}/${branch}/${addressIndex}' path during initialization`
-            )
           }
+          const addressData =
+            await _asyncNullishCoalesce((await dataLayer.fetchAddress(path)), async () => ( (await repairAddress(path))))
           const { address } = walletTools.scriptPubkeyToAddress({
             changePath,
             scriptPubkey: addressData.scriptPubkey
@@ -360,7 +449,7 @@ var _utils3 = require('./utils');
   return {
     processedPercent,
     async start() {
-      processedCount = 0
+      progressByScriptPubkey.clear()
       processedPercent = 0
 
       await run()
@@ -692,6 +781,14 @@ const internalGetFreshAddress = async (
 
 
 
+
+
+
+
+
+
+
+
 
 
 
@@ -850,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)
@@ -1020,7 +1126,7 @@ const needsTxSpecific = (common) => {
   )) {
     if (
       !cacheItem.processing &&
-      common.serverStates.serverCanGetAddress(serverUri, address)
+      common.serverStates.serverCanGetAddressHistory(serverUri, address)
     ) {
       cacheItem.processing = true
 
@@ -1208,6 +1314,18 @@ async function* processAddressForTransactions(
     throw new Error(`could not find address with script pubkey ${scriptPubkey}`)
   }
 
+  // The address was queued with the height of whichever server subscribed
+  // it, but any server can answer the query. Never record more than the
+  // 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. Electrum answers
+  // carry no transactions, so they never move it either:
+  const queriedHeight =
+    serverState.blockHeight > 0 && !_BlockbookElectrum.isElectrumUri.call(void 0, serverUri)
+      ? Math.min(blockHeight, serverState.blockHeight)
+      : addressData.lastQueriedBlockHeight
+
   try {
     const addressResponse = yield* common.serverStates.addressQueryTask(
       serverUri,
@@ -1287,23 +1405,29 @@ async function* processAddressForTransactions(
       addressForTransactionsCache[address] = {
         ...cacheItem,
         processing: false,
-        page: page + 1
+        page: page + 1,
+        blockHeight: queriedHeight
       }
       return true
     }
 
     // Update the lastQueriedBlockHeight for the address
-    addressData.lastQueriedBlockHeight = blockHeight
+    addressData.lastQueriedBlockHeight = queriedHeight
 
     // Save/update the fully-processed address
     await common.dataLayer.saveAddress(addressData)
 
-    // Update the progress now that the transactions for an address have processed
-    await common.updateProgressRatio()
+    // 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)
 
-    // Call setLookAhead to update the lookahead
+    // 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)
 
+    // Update the progress now that the transactions for an address have processed
+    await common.updateProgressRatio(scriptPubkey, 'txs')
+
     // Add the address to the server cache
     serverState.addresses.add(address)
 
@@ -1573,13 +1697,14 @@ const processDataLayerUtxos = async (
     })
   }
 
-  // Update the progress now that the UTXOs for an address have been processed
-  await common.updateProgressRatio()
-
+  // Extend the lookahead first, as in processAddressForTransactions:
   await setLookAhead(common).catch(err => {
     common.log.error(err)
     throw err
   })
+
+  // Update the progress now that the UTXOs for an address have been processed
+  await common.updateProgressRatio(scriptPubkey, 'utxos')
 }
 
 /**

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

@@ -101,6 +101,11 @@ var _Socket = require('./Socket');
 
 
 
+
+
+
+
+
 
 
 
@@ -229,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
@@ -277,7 +282,9 @@ var _Socket = require('./Socket');
     taskGeneratorFn,
     log,
     emitter: socketEmitter,
-    walletId
+    walletId,
+    keepAliveMs: config.keepAliveMs,
+    wakeUpMs: config.wakeUpMs
   })
 
   async function ping() {