Merge pull request #1188 from ergoplatform/v3.3.3

Candidate for 3.3.3

Dockerfile

@@ -28,5 +28,5 @@ EXPOSE 9020 9052
 WORKDIR /home/ergo
 VOLUME ["/home/ergo/.ergo"]
 ENV MAX_HEAP 3G
-ENTRYPOINT java -Xmx${MAX_HEAP} -jar /home/ergo/ergo.jar
-CMD [""]
+ENTRYPOINT java -Xmx${MAX_HEAP} -jar /home/ergo/ergo.jar $0 $1 $2 $3
+CMD []

benchmarks/src/test/scala/org/ergoplatform/bench/CrawlerRunner.scala

@@ -68,7 +68,7 @@ class CrawlerRunner(args: Array[String]) extends Application {
 
   override val nodeViewSynchronizer: ActorRef =
     ErgoNodeViewSynchronizer(networkControllerRef, nodeViewHolderRef, ErgoSyncInfoMessageSpec,
-      settings.network, timeProvider)
+      ergoSettings, timeProvider)
 
 }
 

src/main/scala/org/ergoplatform/ErgoApp.scala

@@ -13,7 +13,6 @@ import org.ergoplatform.local._
 import org.ergoplatform.mining.ErgoMinerRef
 import org.ergoplatform.network.{ErgoNodeViewSynchronizer, ModeFeature}
 import org.ergoplatform.nodeView.history.ErgoSyncInfoMessageSpec
-import org.ergoplatform.nodeView.state.ErgoState
 import org.ergoplatform.nodeView.{ErgoNodeViewRef, ErgoReadersHolderRef}
 import org.ergoplatform.settings.{Args, ErgoSettings, NetworkType}
 import scorex.core.api.http._
@@ -33,7 +32,9 @@ import scala.util.{Failure, Success}
 
 class ErgoApp(args: Args) extends ScorexLogging {
 
-  private var ergoSettings: ErgoSettings = ErgoSettings.read(args)
+  log.info(s"Running with args: $args")
+
+  private val ergoSettings: ErgoSettings = ErgoSettings.read(args)
 
   implicit private def settings: ScorexSettings = ergoSettings.scorexSettings
 
@@ -104,7 +105,7 @@ class ErgoApp(args: Args) extends ScorexLogging {
 
   private val nodeViewSynchronizer: ActorRef =
     ErgoNodeViewSynchronizer(networkControllerRef, nodeViewHolderRef, ErgoSyncInfoMessageSpec,
-      settings.network, timeProvider)
+      ergoSettings, timeProvider)
 
   private val apiRoutes: Seq[ApiRoute] = Seq(
     EmissionApiRoute(ergoSettings),
@@ -182,11 +183,6 @@ class ErgoApp(args: Args) extends ScorexLogging {
     }
   }
 
-  private def isEmptyState: Boolean = {
-    val dir = ErgoState.stateDir(ergoSettings)
-    Option(dir.listFiles()).fold(true)(_.isEmpty)
-  }
-
 }
 
 object ErgoApp extends ScorexLogging {

src/main/scala/org/ergoplatform/network/ErgoNodeViewSynchronizer.scala

@@ -6,7 +6,7 @@ import org.ergoplatform.modifiers.{ErgoFullBlock, ErgoPersistentModifier}
 import org.ergoplatform.network.ErgoNodeViewSynchronizer.CheckModifiersToDownload
 import org.ergoplatform.nodeView.history.{ErgoHistory, ErgoSyncInfo, ErgoSyncInfoMessageSpec}
 import org.ergoplatform.nodeView.mempool.ErgoMemPool
-import org.ergoplatform.settings.Constants
+import org.ergoplatform.settings.{Constants, ErgoSettings}
 import scorex.core.NodeViewHolder._
 import scorex.core.{ModifierTypeId, PersistentNodeViewModifier}
 import scorex.core.network.NetworkController.ReceivableMessages.SendToNetwork
@@ -22,19 +22,24 @@ import scorex.util.ModifierId
 import scala.concurrent.ExecutionContext
 import scala.concurrent.duration._
 
+/**
+  * Tweaks on top of Scorex' NodeViewSynchronizer made for optimizing Ergo network
+  */
 class ErgoNodeViewSynchronizer(networkControllerRef: ActorRef,
                                viewHolderRef: ActorRef,
                                syncInfoSpec: ErgoSyncInfoMessageSpec.type,
-                               networkSettings: NetworkSettings,
+                               settings: ErgoSettings,
                                timeProvider: NetworkTimeProvider)
                               (implicit ex: ExecutionContext)
   extends NodeViewSynchronizer[ErgoTransaction, ErgoSyncInfo, ErgoSyncInfoMessageSpec.type, ErgoPersistentModifier,
-    ErgoHistory, ErgoMemPool](networkControllerRef, viewHolderRef, syncInfoSpec, networkSettings, timeProvider,
-    Constants.modifierSerializers) {
+    ErgoHistory, ErgoMemPool](networkControllerRef, viewHolderRef, syncInfoSpec,
+    settings.scorexSettings.network, timeProvider, Constants.modifierSerializers) {
 
   override protected val deliveryTracker =
     new ErgoDeliveryTracker(context.system, deliveryTimeout, maxDeliveryChecks, self, timeProvider)
 
+  protected val networkSettings: NetworkSettings = settings.scorexSettings.network
+
   /**
     * Approximate number of modifiers to be downloaded simultaneously
     */
@@ -89,8 +94,11 @@ class ErgoNodeViewSynchronizer(networkControllerRef: ActorRef,
 
           val newModifierIds = modifierTypeId match {
             case Transaction.ModifierTypeId =>
-              // We download transactions only if the chain is synced
-              if (history.isHeadersChainSynced && history.fullBlockHeight == history.headersHeight) {
+              // We download transactions only if the node is not needed for externally provided proofs
+              // (so having UTXO set, and the chain is synced
+              if (!settings.nodeSettings.stateType.requireProofs &&
+                    history.isHeadersChainSynced &&
+                    history.fullBlockHeight == history.headersHeight) {
                 invData.ids.filter(mid => deliveryTracker.status(mid, mempool) == ModifiersStatus.Unknown)
               } else {
                 Seq.empty
@@ -156,19 +164,19 @@ object ErgoNodeViewSynchronizer {
   def props(networkControllerRef: ActorRef,
             viewHolderRef: ActorRef,
             syncInfoSpec: ErgoSyncInfoMessageSpec.type,
-            networkSettings: NetworkSettings,
+            settings: ErgoSettings,
             timeProvider: NetworkTimeProvider)
            (implicit ex: ExecutionContext): Props =
-    Props(new ErgoNodeViewSynchronizer(networkControllerRef, viewHolderRef, syncInfoSpec, networkSettings,
+    Props(new ErgoNodeViewSynchronizer(networkControllerRef, viewHolderRef, syncInfoSpec, settings,
       timeProvider))
 
   def apply(networkControllerRef: ActorRef,
             viewHolderRef: ActorRef,
             syncInfoSpec: ErgoSyncInfoMessageSpec.type,
-            networkSettings: NetworkSettings,
+            settings: ErgoSettings,
             timeProvider: NetworkTimeProvider)
            (implicit context: ActorRefFactory, ex: ExecutionContext): ActorRef =
-    context.actorOf(props(networkControllerRef, viewHolderRef, syncInfoSpec, networkSettings, timeProvider))
+    context.actorOf(props(networkControllerRef, viewHolderRef, syncInfoSpec, settings, timeProvider))
 
   case object CheckModifiersToDownload
 

src/main/scala/org/ergoplatform/nodeView/mempool/ErgoMemPool.scala

@@ -82,8 +82,7 @@ class ErgoMemPool private[mempool](pool: OrderedTxPool)(implicit settings: ErgoS
               _ => new ErgoMemPool(pool.put(tx)) -> ProcessingOutcome.Accepted
             )
           case _ =>
-            this -> ProcessingOutcome.Declined(
-              new Exception("Transaction validation not supported"))
+            new ErgoMemPool(pool.put(tx)) -> ProcessingOutcome.Accepted
         }
       } else {
         this -> ProcessingOutcome.Declined(

src/test/scala/org/ergoplatform/nodeView/mempool/ErgoMemPoolSpec.scala

@@ -25,6 +25,12 @@ class ErgoMemPoolSpec extends FlatSpec
     txs.foreach { tx =>
       pool.process(tx, us)._2 shouldBe ProcessingOutcome.Accepted
     }
+
+    // light mode
+    val poolLight = ErgoMemPool.empty(lightModeSettings)
+    txs.foreach { tx =>
+      poolLight.process(tx, us)._2 shouldBe ProcessingOutcome.Accepted
+    }
   }
 
   it should "decline already contained transaction" in {

src/test/scala/org/ergoplatform/sanity/ErgoSanity.scala

@@ -10,7 +10,7 @@ import org.ergoplatform.nodeView.history.{ErgoHistory, ErgoSyncInfo, ErgoSyncInf
 import org.ergoplatform.nodeView.mempool.ErgoMemPool
 import org.ergoplatform.nodeView.state.{DigestState, UtxoState}
 import org.ergoplatform.sanity.ErgoSanity._
-import org.ergoplatform.settings.Constants
+import org.ergoplatform.settings.{Constants, ErgoSettings}
 import org.ergoplatform.settings.Constants.HashLength
 import org.ergoplatform.utils.{ErgoTestHelpers, HistoryTestHelpers}
 import org.scalacheck.Gen
@@ -91,15 +91,15 @@ trait ErgoSanity[ST <: MinimalState[PM, ST]] extends HistoryTests[TX, PM, SI, HT
   class SyncronizerMock(networkControllerRef: ActorRef,
                         viewHolderRef: ActorRef,
                         syncInfoSpec: ErgoSyncInfoMessageSpec.type,
-                        networkSettings: NetworkSettings,
+                        settings: ErgoSettings,
                         timeProvider: NetworkTimeProvider,
                         history: ErgoHistory,
                         pool: ErgoMemPool)
                        (implicit ec: ExecutionContext) extends ErgoNodeViewSynchronizer(
     networkControllerRef,
     viewHolderRef,
     syncInfoSpec,
-    networkSettings,
+    settings,
     timeProvider)(ec) {
 
     override def preStart(): Unit = {

src/test/scala/org/ergoplatform/sanity/ErgoSanityDigest.scala

@@ -71,7 +71,7 @@ class ErgoSanityDigest extends ErgoSanity[DIGEST_ST] {
         ncProbe.ref,
         vhProbe.ref,
         ErgoSyncInfoMessageSpec,
-        settings.scorexSettings.network,
+        settings,
         tp,
         h,
         pool)

src/test/scala/org/ergoplatform/sanity/ErgoSanityUTXO.scala

@@ -9,7 +9,7 @@ import org.ergoplatform.nodeView.mempool.ErgoMemPool
 import org.ergoplatform.nodeView.state.StateType
 import org.ergoplatform.nodeView.state.wrapped.WrappedUtxoState
 import org.ergoplatform.sanity.ErgoSanity._
-import org.ergoplatform.settings.{Args, ErgoSettings}
+import org.ergoplatform.settings.ErgoSettings
 import org.ergoplatform.utils.ErgoTestHelpers
 import org.scalacheck.Gen
 import scorex.core.network.ConnectedPeer
@@ -66,7 +66,7 @@ class ErgoSanityUTXO extends ErgoSanity[UTXO_ST] with ErgoTestHelpers {
         ncProbe.ref,
         vhProbe.ref,
         ErgoSyncInfoMessageSpec,
-        settings.scorexSettings.network,
+        settings,
         tp,
         h,
         pool)

src/test/scala/org/ergoplatform/utils/ErgoTestConstants.scala

@@ -5,7 +5,7 @@ import org.ergoplatform.mining.difficulty.LinearDifficultyControl
 import org.ergoplatform.mining.emission.EmissionRules
 import org.ergoplatform.mining.{AutolykosPowScheme, DefaultFakePowScheme}
 import org.ergoplatform.modifiers.history.ExtensionCandidate
-import org.ergoplatform.nodeView.state.{ErgoState, ErgoStateContext, StateConstants, UpcomingStateContext}
+import org.ergoplatform.nodeView.state.{ErgoState, ErgoStateContext, StateConstants, StateType, UpcomingStateContext}
 import org.ergoplatform.settings.Constants.HashLength
 import org.ergoplatform.settings.ValidationRules._
 import org.ergoplatform.settings._
@@ -38,6 +38,11 @@ trait ErgoTestConstants extends ScorexLogging {
   val initSettings: ErgoSettings = ErgoSettings.read(Args(Some("src/test/resources/application.conf"), None))
 
   val settings: ErgoSettings = initSettings
+
+  val lightModeSettings: ErgoSettings = initSettings.copy(
+    nodeSettings = initSettings.nodeSettings.copy(stateType = StateType.Digest)
+  )
+
   val emission: EmissionRules = settings.chainSettings.emissionRules
   val coinsTotal: Long = emission.coinsTotal
   val stateConstants: StateConstants = StateConstants(None, settings)