i1722-avoid-wallet-rescan-after-init

src/main/scala/org/ergoplatform/nodeView/wallet/ErgoWalletActor.scala

@@ -80,7 +80,7 @@ class ErgoWalletActor(settings: ErgoSettings,
     }
   }
 
-  private def emptyWallet: Receive = {
+  private def expectWalletReading: Receive = {
     case ReadWallet(state) =>
       val ws = settings.walletSettings
       // Try to read wallet from json file or test mnemonic provided in a config file
@@ -97,7 +97,7 @@ class ErgoWalletActor(settings: ErgoSettings,
       ergoWalletService.initWallet(state, settings, walletPass, mnemonicPassOpt) match {
         case Success((mnemonic, newState)) =>
           log.info("Wallet is initialized")
-          context.become(loadedWallet(newState))
+          context.become(loadedWallet(newState.copy(walletPhase = WalletPhase.Created)))
           self ! UnlockWallet(walletPass)
           sender() ! Success(mnemonic)
         case Failure(t) =>
@@ -112,7 +112,7 @@ class ErgoWalletActor(settings: ErgoSettings,
       ergoWalletService.restoreWallet(state, settings, mnemonic, mnemonicPassOpt, walletPass, usePre1627KeyDerivation) match {
         case Success(newState) =>
           log.info("Wallet is restored")
-          context.become(loadedWallet(newState))
+          context.become(loadedWallet(newState.copy(walletPhase = WalletPhase.Restored)))
           self ! UnlockWallet(walletPass)
           sender() ! Success(())
         case Failure(t) =>
@@ -267,7 +267,9 @@ class ErgoWalletActor(settings: ErgoSettings,
     case ScanOnChain(newBlock) =>
       if (state.secretIsSet(settings.walletSettings.testMnemonic)) { // scan blocks only if wallet is initialized
         val nextBlockHeight = state.expectedNextBlockHeight(newBlock.height, settings.nodeSettings.isFullBlocksPruned)
-        if (nextBlockHeight == newBlock.height) {
+        // we want to scan a block either when it is its turn or when wallet is freshly created (no need to load the past)
+        val walletFreshlyCreated = state.walletPhase == WalletPhase.Created && state.getWalletHeight == 0
+        if (nextBlockHeight == newBlock.height || walletFreshlyCreated) {
           log.info(s"Wallet is going to scan a block ${newBlock.id} on chain at height ${newBlock.height}")
           val newState =
             ergoWalletService.scanBlockUpdate(state, newBlock, settings.walletSettings.dustLimit) match {
@@ -276,14 +278,17 @@ class ErgoWalletActor(settings: ErgoSettings,
                 log.error(errorMsg, ex)
                 state.copy(error = Some(errorMsg))
               case Success(updatedState) =>
+                if (walletFreshlyCreated) {
+                  logger.info(s"Freshly created wallet initialized at height $nextBlockHeight without scanning the past.")
+                }
                 updatedState
             }
           context.become(loadedWallet(newState))
         } else if (nextBlockHeight < newBlock.height) {
-          log.warn(s"Wallet: skipped blocks found starting from $nextBlockHeight, going back to scan them")
-          self ! ScanInThePast(nextBlockHeight, false)
+          log.warn(s"Wallet at height ${state.getWalletHeight}: skipped blocks found starting from $nextBlockHeight, going back to scan them")
+          self ! ScanInThePast(nextBlockHeight, rescan = false)
         } else {
-          log.warn(s"Wallet: block in the past reported at ${newBlock.height}, blockId: ${newBlock.id}")
+          log.warn(s"Wallet at height ${state.getWalletHeight}: block in the past reported at ${newBlock.height}, blockId: ${newBlock.id}")
         }
       }
 
@@ -492,7 +497,7 @@ class ErgoWalletActor(settings: ErgoSettings,
     sender() ! txsToSend
   }
 
-  override def receive: Receive = emptyWallet
+  override def receive: Receive = expectWalletReading
 
   private def wrapLegalExc[T](e: Throwable): Failure[T] =
     if (e.getMessage.startsWith("Illegal key size")) {
@@ -524,6 +529,17 @@ object ErgoWalletActor extends ScorexLogging {
     walletActorRef
   }
 
+  /** Wallet transitions either from Default -> Initialized or Default -> Restored */
+  trait WalletPhase
+  object WalletPhase {
+    /** Wallet is expecting either Creation or Restoration */
+    case object UnInitialized extends WalletPhase
+    /** New wallet initialized with generated mnemonic in this runtime */
+    case object Created extends WalletPhase
+    /** Wallet restored from existing mnemonic in this runtime */
+    case object Restored extends WalletPhase
+  }
+
   // Private signals the wallet actor sends to itself
   /**
     * A signal the wallet actor sends to itself to scan a block in the past

src/main/scala/org/ergoplatform/nodeView/wallet/ErgoWalletService.scala

@@ -73,7 +73,7 @@ trait ErgoWalletService {
                     settings: ErgoSettings,
                     mnemonic: SecretString,
                     mnemonicPassOpt: Option[SecretString],
-                    walletPass: SecretString, 
+                    walletPass: SecretString,
                     usePre1627KeyDerivation: Boolean): Try[ErgoWalletState]
 
   /**
@@ -563,6 +563,7 @@ class ErgoWalletServiceImpl(override val ergoSettings: ErgoSettings) extends Erg
         block,
         state.outputsFilter,
         dustLimit,
+        state.walletPhase,
         ergoSettings.walletSettings.walletProfile).map { case (reg, offReg, updatedOutputsFilter) =>
         state.copy(registry = reg, offChainRegistry = offReg, outputsFilter = Some(updatedOutputsFilter))
       }

src/main/scala/org/ergoplatform/nodeView/wallet/ErgoWalletState.scala

@@ -6,6 +6,7 @@ import org.ergoplatform._
 import org.ergoplatform.nodeView.history.ErgoHistory.Height
 import org.ergoplatform.nodeView.mempool.ErgoMemPoolReader
 import org.ergoplatform.nodeView.state.{ErgoStateContext, ErgoStateReader, UtxoStateReader}
+import org.ergoplatform.nodeView.wallet.ErgoWalletActor.WalletPhase
 import org.ergoplatform.nodeView.wallet.ErgoWalletState.FilterFn
 import org.ergoplatform.nodeView.wallet.persistence.{OffChainRegistry, WalletRegistry, WalletStorage}
 import org.ergoplatform.settings.{ErgoSettings, Parameters}
@@ -27,6 +28,7 @@ case class ErgoWalletState(
     utxoStateReaderOpt: Option[UtxoStateReader],
     parameters: Parameters,
     maxInputsToUse: Int,
+    walletPhase: WalletPhase,
     error: Option[String] = None,
     rescanInProgress: Boolean
   ) extends ScorexLogging {
@@ -90,7 +92,11 @@ case class ErgoWalletState(
     }
   }
 
-  // Read a box from UTXO set if the node has it, otherwise, from the wallet
+  /**
+    * Read a box from UTXO set if the node has it, otherwise, from the wallet
+    * @param boxId of the box to read
+    * @return maybe ErgoBox
+    */
   def readBoxFromUtxoWithWalletFallback(boxId: BoxId): Option[ErgoBox] = {
     utxoStateReaderOpt match {
       case Some(utxoReader) =>
@@ -100,7 +106,10 @@ case class ErgoWalletState(
     }
   }
 
-  // expected height of a next block when the wallet is receiving a new block with the height blockHeight
+  /** Get expected height of a next block when the wallet is receiving a new block with the height blockHeight
+    * @param blockHeight height of the block being currently received
+    * @param isFullBlocksPruned whether node has all the full blocks and applies them sequentially
+    */
   def expectedNextBlockHeight(blockHeight: Height, isFullBlocksPruned: Boolean): Height = {
     val walletHeight = getWalletHeight
     if (!isFullBlocksPruned) {
@@ -153,6 +162,7 @@ object ErgoWalletState {
         utxoStateReaderOpt = None,
         parameters,
         maxInputsToUse,
+        walletPhase = WalletPhase.UnInitialized,
         rescanInProgress = false
       )
     }

src/main/scala/org/ergoplatform/nodeView/wallet/WalletScanLogic.scala

@@ -3,6 +3,7 @@ package org.ergoplatform.nodeView.wallet
 import com.google.common.hash.BloomFilter
 import org.ergoplatform.modifiers.ErgoFullBlock
 import org.ergoplatform.modifiers.mempool.ErgoTransaction
+import org.ergoplatform.nodeView.wallet.ErgoWalletActor.WalletPhase
 import org.ergoplatform.nodeView.wallet.IdUtils.{EncodedBoxId, encodedBoxId}
 import org.ergoplatform.nodeView.wallet.persistence.{OffChainRegistry, WalletRegistry}
 import org.ergoplatform.nodeView.wallet.scanning.{Scan, ScanWalletInteraction}
@@ -45,10 +46,11 @@ object WalletScanLogic extends ScorexLogging {
                             block: ErgoFullBlock,
                             cachedOutputsFilter: Option[BloomFilter[Array[Byte]]],
                             dustLimit: Option[Long],
+                            walletPhase: WalletPhase,
                             walletProfile: WalletProfile): Try[(WalletRegistry, OffChainRegistry, BloomFilter[Array[Byte]])] = {
     scanBlockTransactions(
       registry, offChainRegistry, walletVars,
-      block.height, block.id, block.transactions, cachedOutputsFilter, dustLimit, walletProfile)
+      block.height, block.id, block.transactions, cachedOutputsFilter, dustLimit, walletProfile, walletPhase)
   }
 
   /**
@@ -61,6 +63,8 @@ object WalletScanLogic extends ScorexLogging {
     * @param blockId             - block id
     * @param transactions        - block transactions
     * @param cachedOutputsFilter - Bloom filter for previously created outputs
+    * @param walletProfile       - indicates intended use case for the node wallet
+    * @param walletPhase         - whether wallet was created or restored
     * @return updated wallet database, offchain snapshot and the Bloom filter for wallet outputs
     */
   def scanBlockTransactions(registry: WalletRegistry,
@@ -71,7 +75,8 @@ object WalletScanLogic extends ScorexLogging {
                             transactions: Seq[ErgoTransaction],
                             cachedOutputsFilter: Option[BloomFilter[Array[Byte]]],
                             dustLimit: Option[Long],
-                            walletProfile: WalletProfile): Try[(WalletRegistry, OffChainRegistry, BloomFilter[Array[Byte]])] = {
+                            walletProfile: WalletProfile,
+                            walletPhase: WalletPhase): Try[(WalletRegistry, OffChainRegistry, BloomFilter[Array[Byte]])] = {
 
     // Take unspent wallet outputs Bloom Filter from cache
     // or recreate it from unspent outputs stored in the database
@@ -163,7 +168,7 @@ object WalletScanLogic extends ScorexLogging {
     }
 
     // function effects: updating registry and offchainRegistry datasets
-    registry.updateOnBlock(scanRes, blockId, height)
+    registry.updateOnBlock(scanRes, blockId, height, walletPhase)
       .map { _ =>
         //data needed to update the offchain-registry
         val walletUnspent = registry.walletUnspentBoxes()

src/main/scala/org/ergoplatform/nodeView/wallet/persistence/WalletRegistry.scala

@@ -1,7 +1,6 @@
 package org.ergoplatform.nodeView.wallet.persistence
 
 import java.io.File
-
 import org.ergoplatform.ErgoBox.BoxId
 import org.ergoplatform.nodeView.wallet.IdUtils.{EncodedTokenId, encodedTokenId}
 import org.ergoplatform.nodeView.wallet.{WalletTransaction, WalletTransactionSerializer}
@@ -15,6 +14,7 @@ import Constants.{PaymentsScanId, ScanId}
 import org.ergoplatform.ErgoBox
 import org.ergoplatform.ErgoLikeContext.Height
 import org.ergoplatform.modifiers.history.header.PreGenesisHeader
+import org.ergoplatform.nodeView.wallet.ErgoWalletActor.WalletPhase
 import scorex.db.LDBVersionedStore
 
 import scala.util.{Failure, Success, Try}
@@ -239,8 +239,9 @@ class WalletRegistry(store: LDBVersionedStore)(ws: WalletSettings) extends Score
     * @param scanResults - block scan data (outputs created and spent along with corresponding transactions)
     * @param blockId     - block identifier
     * @param blockHeight - block height
+    * @param walletPhase - whether wallet is uninitialized, created or restored
     */
-  def updateOnBlock(scanResults: ScanResults, blockId: ModifierId, blockHeight: Int): Try[Unit] = {
+  def updateOnBlock(scanResults: ScanResults, blockId: ModifierId, blockHeight: Int, walletPhase: WalletPhase): Try[Unit] = {
 
     // first, put newly created outputs and related transactions into key-value bag
     val bag1 = putBoxes(KeyValuePairsBag.empty, scanResults.outputs)
@@ -252,7 +253,7 @@ class WalletRegistry(store: LDBVersionedStore)(ws: WalletSettings) extends Score
 
     // and update wallet digest
     updateDigest(bag3) { case WalletDigest(height, wBalance, wTokensSeq) =>
-      if (height + 1 != blockHeight) {
+      if (height + 1 != blockHeight && walletPhase != WalletPhase.Created) {
         log.error(s"Blocks were skipped during wallet scanning, from $height until $blockHeight")
       }
       val spentWalletBoxes = spentBoxesWithTx.map(_._2).filter(_.scans.contains(PaymentsScanId))

src/test/scala/org/ergoplatform/nodeView/wallet/ErgoWalletServiceSpec.scala

@@ -5,6 +5,7 @@ import org.ergoplatform._
 import org.ergoplatform.db.DBSpec
 import org.ergoplatform.modifiers.mempool.{ErgoTransaction, UnconfirmedTransaction}
 import org.ergoplatform.nodeView.mempool.ErgoMemPoolReader
+import org.ergoplatform.nodeView.wallet.ErgoWalletActor.WalletPhase
 import org.ergoplatform.nodeView.wallet.WalletScanLogic.ScanResults
 import org.ergoplatform.nodeView.wallet.persistence.{OffChainRegistry, WalletRegistry, WalletStorage}
 import org.ergoplatform.nodeView.wallet.requests.{AssetIssueRequest, PaymentRequest}
@@ -20,6 +21,7 @@ import org.ergoplatform.wallet.boxes.{ErgoBoxSerializer, ReplaceCompactCollectBo
 import org.ergoplatform.wallet.crypto.ErgoSignature
 import org.ergoplatform.wallet.mnemonic.Mnemonic
 import org.ergoplatform.wallet.secrets.ExtendedSecretKey
+import org.ergoplatform.wallet.utils.FileUtils
 import org.scalacheck.Gen
 import org.scalatest.BeforeAndAfterAll
 import scorex.db.{LDBKVStore, LDBVersionedStore}
@@ -37,6 +39,7 @@ class ErgoWalletServiceSpec
     with ErgoWalletSupport
     with ErgoTransactionGenerators
     with DBSpec
+    with FileUtils
     with BeforeAndAfterAll {
 
   override val ergoSettings: ErgoSettings = settings
@@ -61,6 +64,7 @@ class ErgoWalletServiceSpec
       utxoStateReaderOpt = Option.empty,
       parameters,
       maxInputsToUse = 1000,
+      walletPhase = WalletPhase.UnInitialized,
       rescanInProgress = false
     )
   }
@@ -189,7 +193,7 @@ class ErgoWalletServiceSpec
 
           // let's update wallet registry with a transaction from a block
           val genesisBlock = makeGenesisBlock(pks.head.pubkey, randomNewAsset)
-          wState.registry.updateOnBlock(ScanResults(allBoxes, Seq.empty, Seq(walletTx1)), genesisBlock.id, blockHeight = 100).get
+          wState.registry.updateOnBlock(ScanResults(allBoxes, Seq.empty, Seq(walletTx1)), genesisBlock.id, blockHeight = 100, WalletPhase.Created).get
 
           // transaction should be retrieved by only a scan id that was associated with it
           val txs1 = walletService.getScanTransactions(wState, ScanId @@ 0.shortValue(), 100)
@@ -220,7 +224,7 @@ class ErgoWalletServiceSpec
           val unspentBoxes = boxes.map(bx => bx.copy(spendingHeightOpt = None, spendingTxIdOpt = None, scans = Set(PaymentsScanId)))
           val spentBox = boxes.head.copy(spendingHeightOpt = Some(10000), spendingTxIdOpt = Some(txId), scans = Set(PaymentsScanId))
           val allBoxes = unspentBoxes :+ spentBox
-          wState.registry.updateOnBlock(ScanResults(allBoxes, Seq.empty, Seq.empty), blockId, 100).get
+          wState.registry.updateOnBlock(ScanResults(allBoxes, Seq.empty, Seq.empty), blockId, 100, WalletPhase.Created).get
 
           val walletService = new ErgoWalletServiceImpl(settings)
           val actualUnspentOnlyWalletBoxes = walletService.getWalletBoxes(wState, unspentOnly = true, considerUnconfirmed = false).toList
@@ -293,6 +297,8 @@ class ErgoWalletServiceSpec
   property("it should lock/unlock wallet") {
     withVersionedStore(2) { versionedStore =>
       withStore { store =>
+        deleteRecursive(WalletStorage.storageFolder(settings))
+        deleteRecursive(WalletRegistry.registryFolder(settings))
         val walletState = initialState(store, versionedStore)
         val walletService = new ErgoWalletServiceImpl(settings)
         val pass = Random.nextString(10)

src/test/scala/org/ergoplatform/nodeView/wallet/WalletScanLogicSpec.scala

@@ -5,6 +5,7 @@ import WalletScanLogic.{extractWalletOutputs, scanBlockTransactions}
 import org.ergoplatform.db.DBSpec
 import org.ergoplatform.{ErgoBox, ErgoBoxCandidate, Input}
 import org.ergoplatform.modifiers.mempool.ErgoTransaction
+import org.ergoplatform.nodeView.wallet.ErgoWalletActor.WalletPhase
 import org.ergoplatform.nodeView.wallet.persistence.{OffChainRegistry, WalletRegistry}
 import org.ergoplatform.nodeView.wallet.scanning.{EqualsScanningPredicate, ScanRequest, ScanWalletInteraction}
 import org.ergoplatform.wallet.Constants
@@ -129,7 +130,7 @@ class WalletScanLogicSpec extends ErgoPropertyTest with DBSpec with WalletTestOp
       //simplest case - we're scanning an empty block
       val (r0, o0, f0) =
         scanBlockTransactions(emptyReg, emptyOff, walletVars, height0, blockId,
-                              Seq.empty, None, None, WalletProfile.User).get
+                              Seq.empty, None, None, WalletProfile.User, WalletPhase.Created).get
       val r0digest = r0.fetchDigest()
       r0digest.walletBalance shouldBe 0
       r0digest.walletAssetBalances.size shouldBe 0
@@ -154,7 +155,7 @@ class WalletScanLogicSpec extends ErgoPropertyTest with DBSpec with WalletTestOp
 
         val (r1, o1, f1) =
           scanBlockTransactions(registry, off, walletVars, height1, blockId,
-                                txs, Some(f0), None, WalletProfile.User).get
+                                txs, Some(f0), None, WalletProfile.User, WalletPhase.Created).get
         val r1digest = r1.fetchDigest()
         r1digest.walletBalance shouldBe (regDigestBefore + trackedTransaction.paymentValues.sum)
         r1digest.walletAssetBalances.size shouldBe 0
@@ -175,7 +176,7 @@ class WalletScanLogicSpec extends ErgoPropertyTest with DBSpec with WalletTestOp
 
         val (r2, o2, f2) =
           scanBlockTransactions(registry, off, walletVars, height1 + 1, blockId,
-                                Seq(spendingTx), Some(f1), None, WalletProfile.User).get
+                                Seq(spendingTx), Some(f1), None, WalletProfile.User, WalletPhase.Created).get
 
         val r2digest = r2.fetchDigest()
         r2digest.walletBalance shouldBe (regDigestBefore + trackedTransaction.paymentValues.sum)
@@ -197,7 +198,7 @@ class WalletScanLogicSpec extends ErgoPropertyTest with DBSpec with WalletTestOp
 
         val (r3, o3, f3) =
           scanBlockTransactions(registry, off, walletVars, height1 + 2, blockId,
-                                Seq(spendingTx2), Some(f2), None, WalletProfile.User).get
+                                Seq(spendingTx2), Some(f2), None, WalletProfile.User, WalletPhase.Created).get
 
         val r3digest = r3.fetchDigest()
         r3digest.walletBalance shouldBe regDigestBefore
@@ -217,7 +218,7 @@ class WalletScanLogicSpec extends ErgoPropertyTest with DBSpec with WalletTestOp
 
         val (r4, o4, _) =
           scanBlockTransactions(registry, off, walletVars, height1 + 3, blockId,
-                                threeTxs, Some(f3), None, WalletProfile.User).get
+                                threeTxs, Some(f3), None, WalletProfile.User, WalletPhase.Created).get
 
         val r4digest = r4.fetchDigest()
         r4digest.walletBalance shouldBe regDigestBefore

src/test/scala/org/ergoplatform/nodeView/wallet/persistence/WalletRegistryBenchmark.scala

@@ -3,6 +3,7 @@ package org.ergoplatform.nodeView.wallet.persistence
 import org.ergoplatform.{ErgoAddressEncoder, ErgoBox, Input}
 import org.ergoplatform.ErgoBox.{AdditionalRegisters, TokenId}
 import org.ergoplatform.modifiers.mempool.ErgoTransaction
+import org.ergoplatform.nodeView.wallet.ErgoWalletActor.WalletPhase
 import org.ergoplatform.nodeView.wallet.WalletScanLogic.ScanResults
 import org.ergoplatform.nodeView.wallet.{WalletTransaction, WalletVars}
 import org.ergoplatform.utils.ErgoTestConstants
@@ -54,7 +55,7 @@ object WalletRegistryBenchmark extends App with ErgoTestConstants {
   }
 
   val scanResults0 = ScanResults(boxes, Seq.empty, Seq.empty)
-  registry.updateOnBlock(scanResults0, ModifierId @@ Base16.encode(Array.fill(32)(0: Byte)), 1).get
+  registry.updateOnBlock(scanResults0, ModifierId @@ Base16.encode(Array.fill(32)(0: Byte)), 1, WalletPhase.Created).get
   println("keys: " + walletVars.proverOpt.get.secretKeys.size)
 
   val bts0 = System.currentTimeMillis()
@@ -73,7 +74,7 @@ object WalletRegistryBenchmark extends App with ErgoTestConstants {
   }
 
   val scanResults1 = ScanResults(Seq.empty, Seq.empty, txs)
-  registry.updateOnBlock(scanResults1, ModifierId @@ Base16.encode(Array.fill(32)(1: Byte)), 2).get
+  registry.updateOnBlock(scanResults1, ModifierId @@ Base16.encode(Array.fill(32)(1: Byte)), 2, WalletPhase.Created).get
 
   val tts0 = System.currentTimeMillis()
   val txsRead = registry.allWalletTxs()