registers, collections, collection operations draft

build.sbt

@@ -11,6 +11,7 @@ val testingDependencies = Seq(
 )
 
 libraryDependencies ++= Seq(
+  "org.bouncycastle" % "bcprov-jdk15on" % "1.58",
   "com.typesafe.akka" %% "akka-actor" % "2.4.+",
   "org.scorexfoundation" %% "scorex-core" % "2.+",
   "org.bitbucket.inkytonik.kiama" %% "kiama" % "2.1.0"

src/main/scala/sigmastate/interpreter/Interpreter.scala

@@ -20,16 +20,14 @@ import scapi.sigma.rework.FirstProverMessage
 import sigmastate.utxo.CostTable
 
 
-
-
 trait Interpreter {
   type CTX <: Context[CTX]
   type StateT <: StateTree
   type SigmaT <: SigmaTree
 
   type ProofT = UncheckedTree //todo:  ProofT <: UncheckedTree ?
 
-  val dlogGroup: DlogGroup = new BcDlogECFp()
+  lazy val dlogGroup: DlogGroup = new BcDlogECFp()
 
   /**
     * Max cost of a script interpreter can accept
@@ -55,24 +53,30 @@ trait Interpreter {
   }
 
   protected val relations: Strategy = everywherebu(rule[SigmaStateTree] {
-    case EQ(l: Value, r: Value) => BooleanLeaf.fromBoolean(l == r)
-    case NEQ(l: Value, r: Value) => BooleanLeaf.fromBoolean(l != r)
-    case GT(l: IntLeaf, r: IntLeaf) => BooleanLeaf.fromBoolean(l.value > r.value)
-    case GE(l: IntLeaf, r: IntLeaf) => BooleanLeaf.fromBoolean(l.value >= r.value)
-    case LT(l: IntLeaf, r: IntLeaf) => BooleanLeaf.fromBoolean(l.value < r.value)
-    case LE(l: IntLeaf, r: IntLeaf) => BooleanLeaf.fromBoolean(l.value <= r.value)
+    case EQ(l: Value, r: Value) if l.evaluated && r.evaluated =>
+      BooleanLeafConstant.fromBoolean(l == r)
+    case NEQ(l: Value, r: Value) if l.evaluated && r.evaluated =>
+      BooleanLeafConstant.fromBoolean(l != r)
+    case GT(l: IntLeafConstant, r: IntLeafConstant) =>
+      BooleanLeafConstant.fromBoolean(l.value > r.value)
+    case GE(l: IntLeafConstant, r: IntLeafConstant) =>
+      BooleanLeafConstant.fromBoolean(l.value >= r.value)
+    case LT(l: IntLeafConstant, r: IntLeafConstant) =>
+      BooleanLeafConstant.fromBoolean(l.value < r.value)
+    case LE(l: IntLeafConstant, r: IntLeafConstant) =>
+      BooleanLeafConstant.fromBoolean(l.value <= r.value)
   })
 
   protected val operations: Strategy = everywherebu(rule[SigmaStateTree] {
-    case Plus(l: IntLeaf, r: IntLeaf) => IntLeaf(l.value + r.value)
-    case Minus(l: IntLeaf, r: IntLeaf) => IntLeaf(l.value - r.value)
-    case Xor(l: ByteArrayLeaf, r: ByteArrayLeaf) =>
+    case Plus(l: IntLeafConstant, r: IntLeafConstant) => IntLeafConstant(l.value + r.value)
+    case Minus(l: IntLeafConstant, r: IntLeafConstant) => IntLeafConstant(l.value - r.value)
+    case Xor(l: ByteArrayLeafConstant, r: ByteArrayLeafConstant) =>
       assert(l.value.length == r.value.length)
-      ByteArrayLeaf(Helpers.xor(l.value, r.value))
-    case Append(l: ByteArrayLeaf, r: ByteArrayLeaf) =>
+      ByteArrayLeafConstant(Helpers.xor(l.value, r.value))
+    case Append(l: ByteArrayLeafConstant, r: ByteArrayLeafConstant) =>
       require(l.value.length + r.value.length < 10000) //todo: externalize this maximum intermediate value length limit
-      ByteArrayLeaf(l.value ++ r.value)
-    case CalcBlake2b256(l: ByteArrayLeaf) => ByteArrayLeaf(Blake2b256(l.value))
+      ByteArrayLeafConstant(l.value ++ r.value)
+    case c@CalcBlake2b256Inst(l: ByteArrayLeafConstant) if l.evaluated => c.function(l)
   })
 
   protected val conjs: Strategy = everywherebu(rule[SigmaStateTree] {

src/main/scala/sigmastate/interpreter/ProverInterpreter.scala

@@ -30,7 +30,7 @@ trait ProverInterpreter extends Interpreter with AttributionCore {
 
   val secrets: Seq[SigmaProtocolPrivateInput[_]]
 
-  val contextExtenders: Map[Int, ByteArrayLeaf]
+  val contextExtenders: Map[Int, ByteArrayLeafConstant]
 
   def enrichContext(tree: SigmaStateTree): ContextExtension = {
     val targetName = CustomByteArray.getClass.getSimpleName.replace("$", "")
@@ -106,14 +106,16 @@ trait ProverInterpreter extends Interpreter with AttributionCore {
   def prove(exp: SigmaStateTree, context: CTX, message: Array[Byte]): Try[ProverResult[ProofT]] = Try {
     val candidateProp = reduceToCrypto(exp, context).get
 
+    println(candidateProp)
+
     val (cProp, ext) = (candidateProp.isInstanceOf[SigmaT] match {
       case true => (candidateProp, ContextExtension(Map()))
       case false =>
         val extension = enrichContext(candidateProp)
         //todo: no need for full reduction here probably
         (reduceToCrypto(candidateProp, context.withExtension(extension)).get, extension)
     }).ensuring { res =>
-      res._1.isInstanceOf[BooleanLeaf] ||
+      res._1.isInstanceOf[BooleanLeafConstant] ||
         res._1.isInstanceOf[CAND] ||
         res._1.isInstanceOf[COR] ||
         res._1.isInstanceOf[DLogNode] ||
@@ -122,7 +124,7 @@ trait ProverInterpreter extends Interpreter with AttributionCore {
 
 
     ProverResult(cProp match {
-      case tree: BooleanLeaf =>
+      case tree: BooleanLeafConstant =>
         tree match {
           case TrueLeaf => NoProof
           case FalseLeaf => ???