edge-currency-plugins 3.4.4 → 3.5.0

package/lib/common/plugin/CurrencyPlugin.js

@@ -1,4 +1,5 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _cleaners = require('cleaners');
+
 
 
 
@@ -17,7 +18,7 @@ var _UtxoEngine = require('../utxobased/engine/UtxoEngine');
 var _CurrencyTools = require('./CurrencyTools');
 var _EngineEmitter = require('./EngineEmitter');
 var _PluginState = require('./PluginState');
-
+var _types5 = require('./types');
 
 let hasMemletBeenSet = false
 
@@ -29,13 +30,15 @@ let hasMemletBeenSet = false
   const { initOptions, io, log, nativeIo, pluginDisklet } = pluginOptions
   const currencyTools = _CurrencyTools.makeCurrencyTools.call(void 0, io, pluginInfo)
   const { defaultSettings, pluginId, currencyCode } = currencyInfo
+
   const pluginState = _PluginState.makePluginState.call(void 0, {
-    io,
+    defaultSettings: _types3.asUtxoUserSettings.call(void 0, defaultSettings),
     currencyCode,
-    pluginId,
-    pluginDisklet,
+    infoPayload: _cleaners.asMaybe.call(void 0, (0, _types5.asInfoPayload))(pluginOptions.infoPayload),
+    io,
     log,
-    defaultSettings: _types3.asUtxoUserSettings.call(void 0, defaultSettings)
+    pluginId,
+    pluginDisklet
   })
 
   if (!hasMemletBeenSet) {
@@ -49,7 +52,7 @@ let hasMemletBeenSet = false
     }
   }
 
-  return {
+  const instance = {
     currencyInfo,
 
     async makeCurrencyEngine(
@@ -64,10 +67,9 @@ let hasMemletBeenSet = false
         currencyTools,
         initOptions: _types3.asUtxoInitOptions.call(void 0, initOptions),
         io,
-        options: {
-          ...pluginOptions,
-          ...engineOptions,
-          emitter
+        emitter,
+        engineOptions: {
+          ...engineOptions
         },
         pluginState
       }
@@ -81,6 +83,16 @@ let hasMemletBeenSet = false
         throw e
       })
       return currencyTools
+    },
+
+    async updateInfoPayload(infoPayload) {
+      try {
+        pluginState.infoPayload = _types5.asInfoPayload.call(void 0, infoPayload)
+      } catch (_) {
+        log.warn('invalid infoPayload', infoPayload)
+      }
     }
   }
+
+  return instance
 } exports.makeCurrencyPlugin = makeCurrencyPlugin;

package/lib/common/plugin/EngineEmitter.js

@@ -3,6 +3,7 @@
 
 
 
+
 var _events = require('events');
 
 
@@ -54,6 +55,24 @@ var _events = require('events');
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -76,6 +95,9 @@ var _events = require('events');
  class EngineEmitter extends _events.EventEmitter {} exports.EngineEmitter = EngineEmitter;
 
 var EngineEvent; (function (EngineEvent) {
+  const SEEN_TX_CHECKPOINT = 'seen:tx:checkpoint'; EngineEvent["SEEN_TX_CHECKPOINT"] = SEEN_TX_CHECKPOINT;
+  const TRANSACTIONS = 'transactions'; EngineEvent["TRANSACTIONS"] = TRANSACTIONS;
+  /** @deprecated Use TRANSACTIONS */
   const TRANSACTIONS_CHANGED = 'transactions:changed'; EngineEvent["TRANSACTIONS_CHANGED"] = TRANSACTIONS_CHANGED;
   const WALLET_BALANCE_CHANGED = 'wallet:balance:changed'; EngineEvent["WALLET_BALANCE_CHANGED"] = WALLET_BALANCE_CHANGED;
   const ADDRESS_BALANCE_CHANGED = 'address:balance:changed'; EngineEvent["ADDRESS_BALANCE_CHANGED"] = ADDRESS_BALANCE_CHANGED;
@@ -93,16 +115,18 @@ var EngineEvent; (function (EngineEvent) {
 ) => {
   const emitter = new EngineEmitter()
 
-  emitter.on(EngineEvent.TRANSACTIONS_CHANGED, callbacks.onTransactionsChanged)
-  emitter.on(EngineEvent.WALLET_BALANCE_CHANGED, callbacks.onBalanceChanged)
+  emitter.on(EngineEvent.ADDRESSES_CHECKED, callbacks.onAddressesChecked)
   emitter.on(
     EngineEvent.BLOCK_HEIGHT_CHANGED,
     (_uri, height) => {
       callbacks.onBlockHeightChanged(height)
     }
   )
-  emitter.on(EngineEvent.ADDRESSES_CHECKED, callbacks.onAddressesChecked)
+  emitter.on(EngineEvent.SEEN_TX_CHECKPOINT, callbacks.onSeenTxCheckpoint)
+  emitter.on(EngineEvent.TRANSACTIONS, callbacks.onTransactions)
+  emitter.on(EngineEvent.TRANSACTIONS_CHANGED, callbacks.onTransactionsChanged)
   emitter.on(EngineEvent.TXIDS_CHANGED, callbacks.onTxidsChanged)
+  emitter.on(EngineEvent.WALLET_BALANCE_CHANGED, callbacks.onBalanceChanged)
 
   return emitter
 }; exports.makeEngineEmitter = makeEngineEmitter

package/lib/common/plugin/PluginState.js

@@ -1,7 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// Typescript translation from original code in edge-currency-bitcoin
-
-var _cleaners = require('cleaners');
-
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
 var _memlet = require('memlet');
 
@@ -14,15 +11,11 @@ var _memlet = require('memlet');
 
 var _ServerScores = require('./ServerScores');
 
-// Info server endpoint to getting ServerListInfo data
-const serverListInfoUrl = 'https://info1.edge.app/v1/blockbook/'
+
 // The filename for ServerInfoCache data (see ServerScores.ts)
 // Perhaps this should be in ServerScores.ts file, but that'll take some refactoring
 const SERVER_CACHE_FILE = 'serverCache.json'
 
-// ServerListInfo data structure from info server and saved to disk
-const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call(void 0, _cleaners.asArray.call(void 0, _cleaners.asString), _cleaners.asNull))
-
 /** A JSON object (as opposed to an array or primitive). */
 
 
@@ -53,19 +46,15 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
 
 
 
+
+
+
 
 
 
 
  function makePluginState(settings) {
-  const {
-    io,
-    defaultSettings,
-    currencyCode,
-    pluginId,
-    pluginDisklet,
-    log
-  } = settings
+  const { defaultSettings, log, pluginDisklet, pluginId } = settings
 
   let engines = []
   const memlet = _memlet.makeMemlet.call(void 0, pluginDisklet)
@@ -118,27 +107,21 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
     onDirtyServer
   })
 
-  const fetchServers = async () => {
-    log(`${pluginId} - GET ${serverListInfoUrl}`)
-
-    try {
-      const response = await io.fetch(serverListInfoUrl)
-      if (!response.ok) {
-        throw new Error(`Failed with status ${response.status}`)
-      }
-      const responseBody = await response.json()
-      const serverListInfo = asServerListInfo(responseBody)
-
-      return _nullishCoalesce(serverListInfo[currencyCode], () => ( []))
-    } catch (error) {
-      log.warn(
-        `${pluginId} - GET ${serverListInfoUrl} failed: ${error.toString()}`
-      )
+  const getInfoPayloadServers = async () => {
+    if (instance.infoPayload == null) {
+      log.warn(`info server list list empty`)
       return []
     }
+
+    const servers = Object.keys(instance.infoPayload.blockbookServers)
+    log.warn(`info server list`, servers)
+
+    return servers
   }
 
   const instance = {
+    infoPayload: settings.infoPayload,
+
     /**
      * Begins notifying the engine of state changes. Used at connection time.
      */
@@ -210,11 +193,11 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
           // Use the default servers from info file as final fallback
           defaultSettings.blockbookServers))
       } else {
-        const fetchedServers = await fetchServers()
+        const infoPayloadServers = await getInfoPayloadServers()
         newServers =
-          fetchedServers.length > 0
-            ? // Use the servers from the network query
-              fetchedServers
+          infoPayloadServers.length > 0
+            ? // Use the servers from the info-server
+              infoPayloadServers
             : // Use the default servers from info file as final fallback
               defaultSettings.blockbookServers
       }

package/lib/common/plugin/types.js

@@ -364,12 +364,14 @@ var _types3 = require('../utxobased/db/types');
 
 
 
-
-
-
  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
+
+ const asInfoPayload = _cleaners.asObject.call(void 0, {
+  blockbookServers: _cleaners.asObject.call(void 0, _cleaners.asBoolean)
+}); exports.asInfoPayload = asInfoPayload
+

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

@@ -101,6 +101,12 @@ var _bnjs = require('bn.js'); var _bnjs2 = _interopRequireDefault(_bnjs);
     memos: [],
     nativeAmount: tx.ourAmount,
     networkFee: tx.fees,
+    networkFees: [
+      {
+        tokenId: null,
+        nativeAmount: tx.fees
+      }
+    ],
     ourReceiveAddresses,
     signedTx: tx.hex,
     tokenId: null,

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

@@ -61,9 +61,6 @@ var _getOwnUtxosFromTx = require('./util/getOwnUtxosFromTx');
 
 
 var _utils3 = require('./utils');
-
-
-
 var _UtxoEngineProcessor = require('./UtxoEngineProcessor');
 var _UtxoWalletTools = require('./UtxoWalletTools');
 
@@ -73,19 +70,14 @@ var _UtxoWalletTools = require('./UtxoWalletTools');
   const {
     pluginInfo,
     pluginDisklet,
-    // Rename to make it explicit that this is sensitive memory
-    options,
+    emitter,
+    engineOptions,
     io,
     pluginState
   } = config
-  const {
-    walletLocalDisklet,
-    walletLocalEncryptedDisklet,
-    emitter,
-    log
-  } = options
+  const { walletLocalDisklet, walletLocalEncryptedDisklet, log } = engineOptions
   const { currencyInfo, engineInfo, coinInfo } = pluginInfo
-  const userSettings = _types7.asUtxoUserSettings.call(void 0, options.userSettings)
+  const userSettings = _types7.asUtxoUserSettings.call(void 0, engineOptions.userSettings)
 
   // We should move the active server list to the engine state,
   // since multiple accounts can be logged in at once,
@@ -120,7 +112,7 @@ var _UtxoWalletTools = require('./UtxoWalletTools');
     disklet: pluginDisklet,
     pluginInfo,
     io,
-    log: config.options.log
+    log: config.engineOptions.log
   })
 
   const metadata = await _Metadata.makeMetadata.call(void 0, {
@@ -136,12 +128,36 @@ var _UtxoWalletTools = require('./UtxoWalletTools');
   // private keys.
   let nonceDataLayer
 
+  /**
+   * This is a stateful function, which means it is both a setter and a getter.
+   * The state is the cached seenTxCheckpoint for the engine during runtime.
+   * It is initialized with the seenTxCheckpoint state from the core via
+   * `EdgeCurrencyEngineOptions`.
+   * It is updated by the engine's processor as the wallet syncs.
+   * Once the wallet fully syncs, the seenTxCheckpoint value is emitted to the
+   * `onSeenTxCheckpoint` callback so the core can persist this state to disk.
+   */
+  const seenTxCheckpoint = ((state) => (
+    value
+  ) => {
+    if (value != null) state = value
+    return state
+  })()
+
+  // Initialize the seenTxCheckpoint with the value from the core.
+  seenTxCheckpoint(config.engineOptions.seenTxCheckpoint)
+
+  emitter.on(_EngineEmitter.EngineEvent.SEEN_TX_CHECKPOINT, checkpoint => {
+    seenTxCheckpoint(checkpoint)
+  })
+
   const engineProcessor = _UtxoEngineProcessor.makeUtxoEngineProcessor.call(void 0, {
     ...config,
-    walletTools,
-    walletInfo,
     dataLayer,
-    pluginState
+    pluginState,
+    seenTxCheckpoint,
+    walletTools,
+    walletInfo
   })
 
   const engine = {
@@ -700,6 +716,12 @@ var _UtxoWalletTools = require('./UtxoWalletTools');
         memos,
         nativeAmount,
         networkFee,
+        networkFees: [
+          {
+            tokenId: null,
+            nativeAmount: networkFee
+          }
+        ],
         otherParams,
         ourReceiveAddresses,
         signedTx: '',
@@ -738,26 +760,23 @@ var _UtxoWalletTools = require('./UtxoWalletTools');
         })
         if (rbfTx != null) {
           rbfTx.blockHeight = -1
-          await _UtxoEngineProcessor.transactionChanged.call(void 0, {
-            walletId: walletInfo.id,
-            tx: rbfTx,
+          await dataLayer.saveTransaction({
+            tx: rbfTx
+          })
+          const rbfEdgeTx = await _TransactionData.toEdgeTransaction.call(void 0, {
+            dataLayer,
             pluginInfo,
-            emitter,
-            walletTools,
-            dataLayer
+            tx: rbfTx,
+            walletId: walletInfo.id,
+            walletTools
           })
+          emitter.emit(_EngineEmitter.EngineEvent.TRANSACTIONS, [
+            { isNew: false, transaction: rbfEdgeTx }
+          ])
         }
       }
 
       const tx = _TransactionData.fromEdgeTransaction.call(void 0, edgeTx)
-      await _UtxoEngineProcessor.transactionChanged.call(void 0, {
-        walletId: walletInfo.id,
-        tx,
-        pluginInfo,
-        emitter,
-        walletTools,
-        dataLayer
-      })
       await dataLayer.saveTransaction({
         tx,
         scriptPubkeys: _optionalChain([edgeTx, 'access', _11 => _11.otherParams, 'optionalAccess', _12 => _12.ourScriptPubkeys])
@@ -983,11 +1002,12 @@ var _UtxoWalletTools = require('./UtxoWalletTools');
 
       const tmpEngineProcessor = _UtxoEngineProcessor.makeUtxoEngineProcessor.call(void 0, {
         ...config,
-        options: {
-          ...config.options,
+        dataLayer: tmpDataLayer,
+        emitter: tmpEmitter,
+        engineOptions: {
+          ...config.engineOptions,
           walletLocalDisklet: tmpDisklet,
-          walletLocalEncryptedDisklet: tmpEncryptedDisklet,
-          emitter: tmpEmitter
+          walletLocalEncryptedDisklet: tmpEncryptedDisklet
         },
         pluginInfo: {
           ...pluginInfo,
@@ -997,7 +1017,7 @@ var _UtxoWalletTools = require('./UtxoWalletTools');
             gapLimit: 0
           }
         },
-        dataLayer: tmpDataLayer,
+        seenTxCheckpoint: () => '0',
         walletTools: tmpWalletTools,
         walletInfo: tmpWalletInfo
       })

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

@@ -83,22 +83,25 @@ var _utils3 = require('./utils');
 
 
 
+
 
 
  function makeUtxoEngineProcessor(
   config
 ) {
   const {
+    dataLayer,
     initOptions,
     io,
-    options,
+    emitter,
+    engineOptions,
     pluginState,
     pluginInfo,
-    dataLayer,
+    seenTxCheckpoint,
     walletInfo,
     walletTools
   } = config
-  const { emitter, log } = options
+  const { log } = engineOptions
 
   const { walletFormats } = walletInfo.keys
 
@@ -169,6 +172,27 @@ var _utils3 = require('./utils');
     }
   }
 
+  const updateSeenTxCheckpoint = () => {
+    // Only update the seenTxCheckpoint if the wallet is fully synced.
+    // This ensure that initial syncs without a defined seenTxCheckpoint,
+    // will not incorrectly update the seenTxCheckpoint in the middle of an
+    // initial sync.
+    if (processedPercent < 1) return
+
+    const seenTxCheckpoint = common.seenTxCheckpoint()
+    const seenTxBlockHeight =
+      seenTxCheckpoint != null ? parseInt(seenTxCheckpoint) : undefined
+
+    // Update the seenTxCheckpoint
+    if (
+      seenTxBlockHeight == null ||
+      common.maxSeenTxBlockHeight > seenTxBlockHeight
+    ) {
+      const newSeenTxCheckpoint = common.maxSeenTxBlockHeight.toString()
+      common.emitter.emit(_EngineEmitter.EngineEvent.SEEN_TX_CHECKPOINT, newSeenTxCheckpoint)
+    }
+  }
+
   const lock = new (0, _awaitlock2.default)()
 
   const serverStates = _ServerStates.makeServerStates.call(void 0, {
@@ -188,8 +212,11 @@ var _utils3 = require('./utils');
     emitter,
     taskCache,
     updateProgressRatio,
+    updateSeenTxCheckpoint,
     io,
     log,
+    maxSeenTxBlockHeight: 0,
+    seenTxCheckpoint,
     serverStates,
     walletFormats,
     lock
@@ -211,12 +238,16 @@ var _utils3 = require('./utils');
   emitter.on(
     _EngineEmitter.EngineEvent.BLOCK_HEIGHT_CHANGED,
     async (_uri, _blockHeight) => {
+      // Add all unconfirmed transactions to the cache to check if these
+      // transactions have been confirmed:
       const txs = await dataLayer.fetchTransactions({
         blockHeight: 0
       })
       for (const tx of txs) {
         if (tx == null) continue
-        taskCache.transactionUpdateCache[tx.txid] = { processing: false }
+        taskCache.transactionUpdateCache[tx.txid] = {
+          processing: false
+        }
       }
     }
   )
@@ -649,6 +680,9 @@ const internalGetFreshAddress = async (
 
 
 
+
+
+
 
 
 
@@ -764,26 +798,6 @@ const addToAddressForTransactionsCache = async (
   }
 }
 
- const transactionChanged = async (args
-
-
-
-
-
-
-) => {
-  const { dataLayer, emitter, pluginInfo, tx, walletTools, walletId } = args
-  emitter.emit(_EngineEmitter.EngineEvent.TRANSACTIONS_CHANGED, [
-    await _TransactionData.toEdgeTransaction.call(void 0, {
-      walletId,
-      tx,
-      walletTools,
-      dataLayer,
-      pluginInfo
-    })
-  ])
-}; exports.transactionChanged = transactionChanged
-
 /**
  * Some currencies require an additional blockbook payload 'getTransactionSpecific' in order
  * to provide all relevant transaction data. Since this is currency-specific, we can limit
@@ -975,7 +989,7 @@ const needsTxSpecific = (common) => {
         hasProcessedAtLeastOnce = true
         cacheItem.processing = true
         _utils.removeItem.call(void 0, transactionUpdateCache, txId)
-        yield* processTransactionUpdate(common, {
+        yield* processCheckTransactionConfirmation(common, {
           serverState,
           serverUri,
           txId
@@ -1046,14 +1060,16 @@ async function* processTransactionsSpecificUpdate(
       tx
     })
 
-    await exports.transactionChanged.call(void 0, {
-      walletId: common.walletInfo.id,
-      emitter: common.emitter,
-      walletTools: common.walletTools,
+    const edgeTx = await _TransactionData.toEdgeTransaction.call(void 0, {
       dataLayer: common.dataLayer,
       pluginInfo: common.pluginInfo,
-      tx: processedTx
+      tx: processedTx,
+      walletId: common.walletInfo.id,
+      walletTools: common.walletTools
     })
+    common.emitter.emit(_EngineEmitter.EngineEvent.TRANSACTIONS, [
+      { isNew: false, transaction: edgeTx }
+    ])
 
     // Add the txid to the server cache
     serverState.txids.add(txId)
@@ -1070,10 +1086,12 @@ async function* processTransactionsSpecificUpdate(
 }
 
 /**
- * Processes a transaction update from the TransactionUpdateCache by querying
+ * Processes an item from transactionUpdateCache by querying
  * the network for the transaction data and processing it into the DataLayer.
+ * It updates the transaction and all of the transaction's UTXO with the
+ * blockHeight received from the network.
  */
-async function* processTransactionUpdate(
+async function* processCheckTransactionConfirmation(
   common,
   args
 
@@ -1111,14 +1129,16 @@ async function* processTransactionUpdate(
       tx
     })
 
-    await exports.transactionChanged.call(void 0, {
-      walletId: common.walletInfo.id,
-      emitter: common.emitter,
-      walletTools: common.walletTools,
+    const edgeTx = await _TransactionData.toEdgeTransaction.call(void 0, {
       dataLayer: common.dataLayer,
       pluginInfo: common.pluginInfo,
-      tx: processedTx
+      tx: processedTx,
+      walletId: common.walletInfo.id,
+      walletTools: common.walletTools
     })
+    common.emitter.emit(_EngineEmitter.EngineEvent.TRANSACTIONS, [
+      { isNew: false, transaction: edgeTx }
+    ])
 
     if (needsTxSpecific(common)) {
       // Add task to grab transactionSpecific payload
@@ -1134,7 +1154,9 @@ async function* processTransactionUpdate(
   } catch (err) {
     console.error(err)
     common.log('error while processing transaction update:', err)
-    common.taskCache.transactionUpdateCache[txId] = { processing: false }
+    common.taskCache.transactionUpdateCache[txId] = {
+      processing: false
+    }
     return false
   }
 }
@@ -1185,22 +1207,45 @@ async function* processAddressForTransactions(
       addressData.used = true
     }
 
+    const seenTxCheckpoint = common.seenTxCheckpoint()
+    const seenTxBlockHeight =
+      seenTxCheckpoint != null ? parseInt(seenTxCheckpoint) : undefined
+
     // Process and save the address's transactions
     for (const txResponse of transactions) {
+      const [existingTx] = await common.dataLayer.fetchTransactions({
+        txId: txResponse.txid
+      })
+
       const tx = processTransactionResponse(common, { txResponse })
       const processedTx = await common.dataLayer.saveTransaction({
         tx,
         scriptPubkeys: [scriptPubkey]
       })
-      await exports.transactionChanged.call(void 0, {
-        walletId: common.walletInfo.id,
-        emitter: common.emitter,
-        walletTools: common.walletTools,
+      const edgeTx = await _TransactionData.toEdgeTransaction.call(void 0, {
         dataLayer: common.dataLayer,
         pluginInfo: common.pluginInfo,
-        tx: processedTx
+        tx: processedTx,
+        walletId: common.walletInfo.id,
+        walletTools: common.walletTools
       })
 
+      // Keep track of transactions which are determined to be unseen:
+      const isNew =
+        seenTxBlockHeight != null &&
+        // Unseen in the DataLayer
+        existingTx == null &&
+        // The tx unconfirmed or confirmed after/at the last seenTxCheckpoint
+        (tx.blockHeight === 0 || tx.blockHeight > seenTxBlockHeight)
+
+      common.emitter.emit(_EngineEmitter.EngineEvent.TRANSACTIONS, [
+        { isNew, transaction: edgeTx }
+      ])
+
+      if (edgeTx.blockHeight > common.maxSeenTxBlockHeight) {
+        common.maxSeenTxBlockHeight = edgeTx.blockHeight
+      }
+
       if (needsTxSpecific(common)) {
         // Add task to grab transactionSpecific payload
         common.taskCache.transactionSpecificUpdateCache[tx.txid] = {
@@ -1209,6 +1254,9 @@ async function* processAddressForTransactions(
       }
     }
 
+    // Make sure to update the seenTxCheckpoint after processing the transactions
+    common.updateSeenTxCheckpoint()
+
     // Halt on finishing the processing of address transaction until
     // we have progressed through all of the blockbook pages
     if (page < totalPages) {