Input/Ordering Block Implementation

.gitignore

@@ -8,6 +8,9 @@ devnet
 .ensime_cache/
 scorex.yaml
 
+# LLM reports on code analysis etc
+llm_generated
+
 # scala build folders
 target
 

AGENTS.md

@@ -34,4 +34,5 @@
 ## Development Restrictions
 - **Code Changes**: Only modify code in `src/test/` folders
 - **Production Code**: Do not touch production code in `src/main/` directories
-- **Test Focus**: All development work should be test-related only
+- **Test Focus**: All development work should be test-related only
+- **Generated Specs**: All LLM-generated specifications should be placed in the `llm_generated/` folder

build.sbt

@@ -43,7 +43,7 @@ val circeVersion = "0.13.0"
 val akkaVersion = "2.6.10"
 val akkaHttpVersion = "10.2.4"
 
-val sigmaStateVersion = "6.0.2"
+val sigmaStateVersion = "6.0.2-30-59782d92-SNAPSHOT"
 val ficusVersion = "1.4.7"
 
 // for testing current sigmastate build (see sigmastate-ergo-it jenkins job)
@@ -185,7 +185,7 @@ docker / dockerfile := {
   val configMainNet = (IntegrationTest / resourceDirectory).value / "mainnetTemplate.conf"
 
   new Dockerfile {
-    from("openjdk:11-jre-slim")
+    from("eclipse-temurin:11-jre-jammy")
     label("ergo-integration-tests", "ergo-integration-tests")
     add(assembly.value, "/opt/ergo/ergo.jar")
     add(Seq(configDevNet), "/opt/ergo")

ergo-core/src/main/scala/org/ergoplatform/consensus/ProgressInfo.scala

@@ -16,16 +16,20 @@ import scorex.util.ModifierId
 case class ProgressInfo[PM <: BlockSection](branchPoint: Option[ModifierId],
                                             toRemove: Seq[PM],
                                             toApply: Seq[PM],
-                                            toDownload: Seq[(NetworkObjectTypeId.Value, ModifierId)])
-                                           (implicit encoder: ScorexEncoder) {
+                                            toDownload: Map[NetworkObjectTypeId.Value, ModifierId]) {
 
-  if (toRemove.nonEmpty)
+  if (toRemove.nonEmpty) {
     require(branchPoint.isDefined, s"Branch point should be defined for non-empty `toRemove`")
+  }
 
   lazy val chainSwitchingNeeded: Boolean = toRemove.nonEmpty
 
   override def toString: String = {
-    s"ProgressInfo(BranchPoint: ${branchPoint.map(encoder.encodeId)}, " +
+    s"ProgressInfo(BranchPoint: ${branchPoint.map(ScorexEncoder.encodeId)}, " +
       s" to remove: ${toRemove.map(_.encodedId)}, to apply: ${toApply.map(_.encodedId)})"
   }
 }
+
+object ProgressInfo {
+  val empty: ProgressInfo[BlockSection] = ProgressInfo[BlockSection](None, Seq.empty, Seq.empty, Map.empty)
+}

ergo-core/src/main/scala/org/ergoplatform/core/core.scala

@@ -13,18 +13,18 @@ package object core {
 
   type VersionTag = VersionTag.Type
 
-  def idsToString(ids: Seq[(NetworkObjectTypeId.Value, util.ModifierId)])(implicit enc: ScorexEncoder): String = {
+  def idsToString(ids: Seq[(NetworkObjectTypeId.Value, util.ModifierId)]): String = {
     List(ids.headOption, ids.lastOption)
       .flatten
-      .map { case (typeId, id) => s"($typeId,${enc.encodeId(id)})" }
+      .map { case (typeId, id) => s"($typeId,${ScorexEncoder.encodeId(id)})" }
       .mkString("[", "..", "]")
   }
 
-  def idsToString(modifierType: NetworkObjectTypeId.Value, ids: Seq[util.ModifierId])(implicit encoder: ScorexEncoder): String = {
+  def idsToString(modifierType: NetworkObjectTypeId.Value, ids: Seq[util.ModifierId]): String = {
     idsToString(ids.map(id => (modifierType, id)))
   }
 
-  def idsToString(invData: InvData)(implicit encoder: ScorexEncoder): String = idsToString(invData.typeId, invData.ids)
+  def idsToString(invData: InvData): String = idsToString(invData.typeId, invData.ids)
 
   def bytesToId: Array[Byte] => util.ModifierId = scorex.util.bytesToId
 

ergo-core/src/main/scala/org/ergoplatform/http/api/ApiCodecs.scala

@@ -1,9 +1,9 @@
 package org.ergoplatform.http.api
 
-import cats.syntax.either._
+import cats.syntax.either._ // needed for Scala 2.11
+import io.circe._           // needed for Scala 2.11
 import sigmastate.utils.Helpers._
 
-import io.circe._
 import io.circe.syntax._
 import org.bouncycastle.util.BigIntegers
 import org.ergoplatform.ErgoBox.RegisterId

ergo-core/src/main/scala/org/ergoplatform/mining/AutolykosPowScheme.scala

@@ -3,6 +3,8 @@ package org.ergoplatform.mining
 import com.google.common.primitives.{Bytes, Ints, Longs}
 import org.bouncycastle.util.BigIntegers
 import org.ergoplatform.ErgoLikeContext.Height
+import org.ergoplatform.settings.Parameters
+import org.ergoplatform.{AutolykosSolution, BlockSolutionSearchResult, InputBlockFound, InputBlockHeaderFound, InputSolutionFound, NoSolutionFound, NothingFound, OrderingBlockFound, OrderingBlockHeaderFound, OrderingSolutionFound, ProveBlockResult}
 import org.ergoplatform.mining.difficulty.DifficultySerializer
 import org.ergoplatform.modifiers.ErgoFullBlock
 import org.ergoplatform.modifiers.history._
@@ -12,6 +14,7 @@ import org.ergoplatform.modifiers.history.header.{Header, HeaderSerializer, Head
 import org.ergoplatform.modifiers.mempool.ErgoTransaction
 import org.ergoplatform.nodeView.history.ErgoHistoryUtils.GenesisHeight
 import org.ergoplatform.nodeView.mempool.TransactionMembershipProof
+import org.ergoplatform.settings.Parameters
 import scorex.crypto.authds.{ADDigest, SerializedAdProof}
 import scorex.crypto.hash.{Blake2b256, Digest32}
 import scorex.util.{ModifierId, ScorexLogging}
@@ -106,7 +109,7 @@ class AutolykosPowScheme(val k: Int, val n: Int) extends ScorexLogging {
       // for version 1, we check equality of left and right sides of the equation
       require(checkPoWForVersion1(header), "Incorrect points")
     } else {
-      require(checkPoWForVersion2(header), "h(f) < b condition not met")
+      require(checkOrderingBlockPoW(header), "h(f) < b condition not met")
     }
   }
 
@@ -116,13 +119,21 @@ class AutolykosPowScheme(val k: Int, val n: Int) extends ScorexLogging {
     * @param header - header to check PoW for
     * @return whether PoW is valid or not
     */
-  def checkPoWForVersion2(header: Header): Boolean = {
-    val b = getB(header.nBits)
+  def checkOrderingBlockPoW(header: Header): Boolean = {
     // for version 2, we're calculating hit and compare it with target
     val hit = hitForVersion2(header)
+
+    val b = getB(header.nBits)
     hit < b
   }
 
+  def checkInputBlockPoW(header: Header, parameters: Parameters): Boolean = {
+    val hit = hitForVersion2(header) // todo: cache hit in header
+
+    val orderingTarget = getB(header.nBits)
+    val inputTarget = orderingTarget * parameters.subBlocksPerBlock
+    hit < inputTarget
+  }
   /**
     * Check PoW for Autolykos v1 header
     *
@@ -241,7 +252,7 @@ class AutolykosPowScheme(val k: Int, val n: Int) extends ScorexLogging {
   /**
     * Get target `b` from encoded difficulty `nBits`
     */
-  private[mining] def getB(nBits: Long): BigInt = {
+  def getB(nBits: Long): BigInt = {
     q / DifficultySerializer.decodeCompactBits(nBits)
   }
 
@@ -278,6 +289,7 @@ class AutolykosPowScheme(val k: Int, val n: Int) extends ScorexLogging {
 
   //Proving-related code which is not critical for consensus below
 
+
   /**
     * Autolykos solver suitable for CPU-mining in testnet and devnets.
     *
@@ -295,7 +307,8 @@ class AutolykosPowScheme(val k: Int, val n: Int) extends ScorexLogging {
             votes: Array[Byte],
             sk: PrivateKey,
             minNonce: Long = Long.MinValue,
-            maxNonce: Long = Long.MaxValue): Option[Header] = {
+            maxNonce: Long = Long.MaxValue,
+            parameters: Parameters): ProveBlockResult = {
     val (parentId, height) = AutolykosPowScheme.derivedHeaderFields(parentOpt)
 
     val h = HeaderWithoutPow(version, parentId, adProofsRoot, stateRoot, transactionsRoot, timestamp,
@@ -305,7 +318,11 @@ class AutolykosPowScheme(val k: Int, val n: Int) extends ScorexLogging {
     val x = randomSecret()
     val hbs = Ints.toByteArray(h.height)
     val N = calcN(h)
-    checkNonces(version, hbs, msg, sk, x, b, N, minNonce, maxNonce).map(solution => h.toHeader(solution))
+    checkNonces(version, hbs, msg, sk, x, b, N, minNonce, maxNonce, parameters) match {
+      case NoSolutionFound => NothingFound
+      case InputSolutionFound(as) => InputBlockHeaderFound(h.toHeader(as))
+      case OrderingSolutionFound(as) => OrderingBlockHeaderFound(h.toHeader(as))
+    }
   }
 
   /**
@@ -323,18 +340,25 @@ class AutolykosPowScheme(val k: Int, val n: Int) extends ScorexLogging {
                  votes: Array[Byte],
                  sk: PrivateKey,
                  minNonce: Long = Long.MinValue,
-                 maxNonce: Long = Long.MaxValue): Option[ErgoFullBlock] = {
+                 maxNonce: Long = Long.MaxValue,
+                 parameters: Parameters): ProveBlockResult = {
 
     val transactionsRoot = BlockTransactions.transactionsRoot(transactions, version)
     val adProofsRoot = ADProofs.proofDigest(adProofBytes)
 
-    prove(parentOpt, version, nBits, stateRoot, adProofsRoot, transactionsRoot,
-      timestamp, extensionCandidate.digest, votes, sk, minNonce, maxNonce).map { h =>
+    def constructBlockFromHeader(h: Header) = {
       val adProofs = ADProofs(h.id, adProofBytes)
       val blockTransactions = BlockTransactions(h.id, version, transactions)
       val extension = extensionCandidate.toExtension(h.id)
       new ErgoFullBlock(h, blockTransactions, extension, Some(adProofs))
     }
+
+    prove(parentOpt, version, nBits, stateRoot, adProofsRoot, transactionsRoot,
+      timestamp, extensionCandidate.digest, votes, sk, minNonce, maxNonce, parameters) match {
+      case NothingFound => NothingFound
+      case InputBlockHeaderFound(h) => InputBlockFound(constructBlockFromHeader(h))
+      case OrderingBlockHeaderFound(h) => OrderingBlockFound(constructBlockFromHeader(h))
+    }
   }
 
   /**
@@ -344,7 +368,8 @@ class AutolykosPowScheme(val k: Int, val n: Int) extends ScorexLogging {
   def proveCandidate(candidateBlock: CandidateBlock,
                      sk: PrivateKey,
                      minNonce: Long = Long.MinValue,
-                     maxNonce: Long = Long.MaxValue): Option[ErgoFullBlock] = {
+                     maxNonce: Long = Long.MaxValue,
+                     parameters: Parameters): ProveBlockResult = {
     proveBlock(candidateBlock.parentOpt,
       candidateBlock.version,
       candidateBlock.nBits,
@@ -356,13 +381,14 @@ class AutolykosPowScheme(val k: Int, val n: Int) extends ScorexLogging {
       candidateBlock.votes,
       sk,
       minNonce,
-      maxNonce
+      maxNonce,
+      parameters
     )
   }
 
   /**
     * Check nonces from `startNonce` to `endNonce` for message `m`, secrets `sk` and `x`, difficulty `b`.
-    * Return AutolykosSolution if there is any valid nonce in this interval.
+    * Return BlockSolutionSearchResult if there is any valid nonce in this interval, for ordering or input block.
     */
   private[mining] def checkNonces(version: Header.Version,
                                   h: Array[Byte],
@@ -372,14 +398,18 @@ class AutolykosPowScheme(val k: Int, val n: Int) extends ScorexLogging {
                                   b: BigInt,
                                   N: Int,
                                   startNonce: Long,
-                                  endNonce: Long): Option[AutolykosSolution] = {
+                                  endNonce: Long,
+                                  parameters: Parameters): BlockSolutionSearchResult = {
+
+    val subblocksPerBlock = parameters.subBlocksPerBlock
+
     log.debug(s"Going to check nonces from $startNonce to $endNonce")
     val p1 = groupElemToBytes(genPk(sk))
     val p2 = groupElemToBytes(genPk(x))
 
     @tailrec
-    def loop(i: Long): Option[AutolykosSolution] = if (i == endNonce) {
-      None
+    def loop(i: Long): BlockSolutionSearchResult = if (i == endNonce) {
+      NoSolutionFound
     } else {
       if (i % 1000000 == 0 && i > 0) println(s"$i nonce tested")
       val nonce = Longs.toByteArray(i)
@@ -397,8 +427,11 @@ class AutolykosPowScheme(val k: Int, val n: Int) extends ScorexLogging {
         toBigInt(hash(indexes.map(i => genElement(version, m, p1, p2, Ints.toByteArray(i), h)).sum.toByteArray))
       }
       if (d <= b) {
-        log.debug(s"Solution found at $i")
-        Some(AutolykosSolution(genPk(sk), genPk(x), nonce, d))
+        log.debug(s"Ordering block solution found at $i")
+        OrderingSolutionFound(new AutolykosSolution(genPk(sk), genPk(x), nonce, d))
+      } else if (d <= b * subblocksPerBlock) {
+        log.debug(s"Input block solution found at $i")
+        InputSolutionFound(new AutolykosSolution(genPk(sk), genPk(x), nonce, d))
       } else {
         loop(i + 1)
       }

ergo-core/src/main/scala/org/ergoplatform/mining/AutolykosSolution.scala

@@ -5,34 +5,19 @@ import sigmastate.utils.Helpers._
 import io.circe.syntax._
 import io.circe.{Decoder, Encoder, HCursor}
 import org.bouncycastle.util.BigIntegers
+import org.ergoplatform.AutolykosSolution
+import org.ergoplatform.AutolykosSolution.pkForV2
 import org.ergoplatform.http.api.ApiCodecs
 import org.ergoplatform.modifiers.history.header.Header.Version
 import org.ergoplatform.settings.Algos
 import org.ergoplatform.serialization.ErgoSerializer
 import scorex.util.serialization.{Reader, Writer}
 import sigma.crypto.{CryptoConstants, EcPointType}
+import org.ergoplatform.AutolykosSolution.pkForV2
 
-/**
-  * Solution for an Autolykos PoW puzzle.
-  *
-  * In Autolykos v.1 all the four fields are used, in Autolykos v.2 only pk and n fields are used.
-  *
-  * @param pk - miner public key. Should be used to collect block rewards
-  * @param w  - one-time public key. Prevents revealing of miners secret
-  * @param n  - nonce (8 bytes)
-  * @param d  - distance between pseudo-random number, corresponding to nonce `n` and a secret,
-  *           corresponding to `pk`. The lower `d` is, the harder it was to find this solution.
-  */
-case class AutolykosSolution(pk: EcPointType,
-                             w: EcPointType,
-                             n: Array[Byte],
-                             d: BigInt) {
-  val encodedPk: Array[Byte] = groupElemToBytes(pk)
-}
 
-object AutolykosSolution extends ApiCodecs {
-  // "pk", "w" and "d" values for Autolykos v2 solution, where they not passed from outside
-  val pkForV2: EcPointType = CryptoConstants.dlogGroup.identity
+object AutolykosSolutionJsonCodecs extends ApiCodecs {
+  // "w" and "d" values for Autolykos v2 solution, where they not passed from outside
   val wForV2: EcPointType = CryptoConstants.dlogGroup.generator
   val dForV2: BigInt = 0
 
@@ -52,12 +37,37 @@ object AutolykosSolution extends ApiCodecs {
       n <- c.downField("n").as[Array[Byte]]
       dOpt <- c.downField("d").as[Option[BigInt]]
     } yield {
-      AutolykosSolution(pkOpt.getOrElse(pkForV2), wOpt.getOrElse(wForV2), n, dOpt.getOrElse(dForV2))
+      new AutolykosSolution(pkOpt.getOrElse(pkForV2), wOpt.getOrElse(wForV2), n, dOpt.getOrElse(dForV2))
     }
   }
 
 }
 
+case class WeakAutolykosSolution(pk: EcPointType, n: Array[Byte]) {
+  val encodedPk: Array[Byte] = groupElemToBytes(pk)
+}
+
+object WeakAutolykosSolution extends ApiCodecs {
+
+  implicit val jsonEncoder: Encoder[WeakAutolykosSolution] = { s: WeakAutolykosSolution =>
+    Map(
+      "pk" -> s.pk.asJson,
+      "n" -> Algos.encode(s.n).asJson
+    ).asJson
+  }
+
+  implicit val jsonDecoder: Decoder[WeakAutolykosSolution] = { c: HCursor =>
+    for {
+      pkOpt <- c.downField("pk").as[Option[EcPointType]]
+      n <- c.downField("n").as[Array[Byte]]
+    } yield {
+      WeakAutolykosSolution(pkOpt.getOrElse(pkForV2), n)
+    }
+  }
+
+}
+
+
 
 /**
   * Binary serializer for Autolykos v1 solution,
@@ -81,7 +91,7 @@ class AutolykosV1SolutionSerializer extends ErgoSerializer[AutolykosSolution] {
     val nonce = r.getBytes(8)
     val dBytesLength = r.getUByte()
     val d = BigInt(BigIntegers.fromUnsignedByteArray(r.getBytes(dBytesLength)))
-    AutolykosSolution(pk, w, nonce, d)
+    new AutolykosSolution(pk, w, nonce, d)
   }
 
 }
@@ -102,7 +112,7 @@ class AutolykosV2SolutionSerializer extends ErgoSerializer[AutolykosSolution] {
   override def parse(r: Reader): AutolykosSolution = {
     val pk = groupElemFromBytes(r.getBytes(PublicKeyLength))
     val nonce = r.getBytes(8)
-    AutolykosSolution(pk, wForV2, nonce, dForV2)
+    new AutolykosSolution(pk, wForV2, nonce, dForV2)
   }
 
 }