Correct environment for Template Compiler

data/shared/src/main/scala/sigma/ast/ErgoTree.scala

@@ -25,13 +25,13 @@ case class UnparsedErgoTree(bytes: mutable.WrappedArray[Byte], error: Validation
   * ErgoTreeSerializer defines top-level serialization format of the scripts.
   * The interpretation of the byte array depend on the first `header` byte, which uses VLQ encoding up to 30 bits.
   * Currently we define meaning for only first byte, which may be extended in future versions.
-  * 7  6  5  4  3  2  1  0
+  *   7  6  5  4  3  2  1  0
   * -------------------------
   * |  |  |  |  |  |  |  |  |
   * -------------------------
   * Bit 7 == 1 if the header contains more than 1 byte (default == 0)
   * Bit 6 - reserved for GZIP compression (should be 0)
-  * Bit 5 == 1 - reserved for context dependent costing (should be = 0)
+  * Bit 5 == 1 - reserved (should be = 0)
   * Bit 4 == 1 if constant segregation is used for this ErgoTree (default = 0)
   * (see https://github.com/ScorexFoundation/sigmastate-interpreter/issues/264)
   * Bit 3 == 1 if size of the whole tree is serialized after the header byte (default = 0)

parsers/shared/src/main/scala/sigmastate/lang/ContractParser.scala

@@ -3,7 +3,7 @@ package sigmastate.lang
 import fastparse._
 import fastparse.NoWhitespace._
 import SigmaParser._
-import sigma.ast.SType
+import sigma.ast.{Constant, SType}
 import sigma.ast.syntax.SValue
 import sigmastate.lang.parsers.Basic
 
@@ -187,9 +187,9 @@ object ContractParser {
 
     def annotation[_: P] = P("@contract")
 
-    def paramDefault[_: P] = P(WL.? ~ `=` ~ WL.? ~ ExprLiteral).map(s => s.asWrappedType)
+    def paramDefault[_: P] = P(WL.? ~ `=` ~ WL.? ~ ExprLiteral)
 
-    def param[_: P] = P(WL.? ~ Id.! ~ ":" ~ Type ~ paramDefault.?).map(s => ContractParam(s._1, s._2, s._3))
+    def param[_: P] = P(WL.? ~ Id.! ~ ":" ~ Type ~ paramDefault.?).map(s => ContractParam(s._1, s._2, s._3.map(_.value)))
 
     def params[_: P] = P("(" ~ param.rep(1, ",").? ~ ")")
   }

parsers/shared/src/test/scala/sigmastate/lang/ContractParserSpec.scala

@@ -3,6 +3,7 @@ package sigmastate.lang
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.propspec.AnyPropSpec
 import org.scalatestplus.scalacheck.ScalaCheckPropertyChecks
+import sigma.ast.SType.AnyOps
 import sigma.ast._
 
 class ContractParserSpec extends AnyPropSpec with ScalaCheckPropertyChecks with Matchers {
@@ -34,8 +35,8 @@ class ContractParserSpec extends AnyPropSpec with ScalaCheckPropertyChecks with
 
     parsed.name shouldBe "contractName"
     parsed.params should contain theSameElementsInOrderAs Seq(
-      ContractParam("p1", SInt, Some(IntConstant(5).asWrappedType)),
-      ContractParam("p2", SString, Some(StringConstant("default string").asWrappedType)),
+      ContractParam("p1", SInt, Some(5.asWrappedType)),
+      ContractParam("p2", SString, Some("default string".asWrappedType)),
       ContractParam("param3", SLong, None)
     )
   }

parsers/shared/src/test/scala/sigmastate/lang/LangTests.scala

@@ -1,16 +1,15 @@
 package sigmastate.lang
 
 import org.scalatest.matchers.should.Matchers
-import sigma.{Coll, _}
 import sigma.ast.SCollection.SByteArray
 import sigma.ast.syntax.{SValue, ValueOps}
 import sigma.ast._
 import sigma.crypto.CryptoConstants
 import sigma.data.{CAnyValue, CSigmaDslBuilder, ProveDHTuple, ProveDlog, SigmaBoolean}
 import sigma.util.Extensions.BigIntegerOps
+import sigma._
 import sigmastate.helpers.NegativeTesting
 import sigmastate.interpreter.Interpreter.ScriptEnv
-import sigma.ast.{Ident, MethodCallLike}
 
 import java.math.BigInteger
 

sc/shared/src/main/scala/sigmastate/eval/GraphBuilding.scala

@@ -381,6 +381,18 @@ trait GraphBuilding extends SigmaLibrary { IR: IRContext =>
   def error(msg: String) = throw new GraphBuildingException(msg, None)
   def error(msg: String, srcCtx: Option[SourceContext]) = throw new GraphBuildingException(msg, srcCtx)
 
+  /** Graph node to represent a placeholder of a constant in ErgoTree.
+    * @param id Zero based index in ErgoTree.constants array.
+    * @param resultType type descriptor of the constant value.
+    */
+  case class ConstantPlaceholder[T](id: Int, resultType: Elem[T]) extends Def[T]
+
+  /** Smart constructor method for [[ConstantPlaceholder]], should be used instead of the
+    * class constructor.
+    */
+  @inline def constantPlaceholder[T](id: Int, eT: Elem[T]): Ref[T] = ConstantPlaceholder(id, eT)
+
+
   /** Translates the given typed expression to IR graph representing a function from
     * Context to some type T.
     * @param env contains values for each named constant used
@@ -465,6 +477,8 @@ trait GraphBuilding extends SigmaLibrary { IR: IRContext =>
           val resV = toRep(v)(e)
           resV
       }
+      case sigma.ast.ConstantPlaceholder(id, tpe) =>
+        constantPlaceholder(id, stypeToElem(tpe))
       case sigma.ast.Context => ctx
       case Global => sigmaDslBuilder
       case Height => ctx.HEIGHT

sc/shared/src/main/scala/sigmastate/eval/TreeBuilding.scala

@@ -183,6 +183,10 @@ trait TreeBuilding extends SigmaLibrary { IR: IRContext =>
           case None =>
             mkConstant[tpe.type](x.asInstanceOf[tpe.WrappedType], tpe)
         }
+      case Def(IR.ConstantPlaceholder(id, elem)) =>
+        val tpe = elemToSType(elem)
+        mkConstantPlaceholder[tpe.type](id, tpe)
+
       case Def(wc: LiftedConst[a,_]) =>
         val tpe = elemToSType(s.elem)
         mkConstant[tpe.type](wc.constValue.asInstanceOf[tpe.WrappedType], tpe)

sc/shared/src/main/scala/sigmastate/lang/SigmaCompiler.scala

@@ -72,7 +72,8 @@ class SigmaCompiler private(settings: CompilerSettings) {
     val predefinedFuncRegistry = new PredefinedFuncRegistry(builder)
     val binder = new SigmaBinder(env, builder, networkPrefix, predefinedFuncRegistry)
     val bound = binder.bind(parsed)
-    val typer = new SigmaTyper(builder, predefinedFuncRegistry, settings.lowerMethodCalls)
+    val typeEnv = env.collect { case (k, v: SType) => k -> v }
+    val typer = new SigmaTyper(builder, predefinedFuncRegistry, typeEnv, settings.lowerMethodCalls)
     val typed = typer.typecheck(bound)
     typed
   }
@@ -91,7 +92,12 @@ class SigmaCompiler private(settings: CompilerSettings) {
 
   /** Compiles the given typed expression. */
   def compileTyped(env: ScriptEnv, typedExpr: SValue)(implicit IR: IRContext): CompilerResult[IR.type] = {
-    val compiledGraph = IR.buildGraph(env, typedExpr)
+    val placeholdersEnv = env
+        .collect { case (name, t: SType) => name -> t }
+        .zipWithIndex
+        .map { case ((name, t), index) => name -> ConstantPlaceholder(index, t) }
+        .toMap
+    val compiledGraph = IR.buildGraph(env ++ placeholdersEnv, typedExpr)
     val compiledTree = IR.buildTree(compiledGraph)
     CompilerResult(env, "<no source code>", compiledGraph, compiledTree)
   }

sc/shared/src/main/scala/sigmastate/lang/SigmaTemplateCompiler.scala

@@ -1,12 +1,10 @@
 package sigmastate.lang
 
 import fastparse.Parsed
-import org.ergoplatform.sdk.ContractTemplate
-import sigmastate.eval.CompiletimeIRContext
-import org.ergoplatform.sdk.Parameter
+import org.ergoplatform.sdk.{ContractTemplate, Parameter}
 import sigma.ast.SourceContext
 import sigma.ast.syntax.SValue
-import sigmastate.interpreter.Interpreter.ScriptEnv
+import sigmastate.eval.CompiletimeIRContext
 import sigmastate.lang.parsers.ParserException
 
 /** Compiler which compiles Ergo contract templates into a [[ContractTemplate]]. */
@@ -19,13 +17,14 @@ class SigmaTemplateCompiler(networkPrefix: Byte) {
    * @param source The ErgoScript contract source code.
    * @return The contract template.
    */
-  def compile(env: ScriptEnv, source: String): ContractTemplate = {
+  def compile(source: String): ContractTemplate = {
     ContractParser.parse(source) match {
-      case Parsed.Success(template, _) => {
+      case Parsed.Success(parsedTemplate, _) =>
         implicit val ir = new CompiletimeIRContext
-        val result = sigmaCompiler.compileParsed(env, template.body)
-        assemble(template, result.buildTree)
-      }
+        val parEnv = parsedTemplate.signature.params.map { p => p.name -> p.tpe }.toMap
+        val result = sigmaCompiler.compileParsed(parEnv, parsedTemplate.body)
+        assemble(parsedTemplate, result.buildTree)
+
       case f: Parsed.Failure =>
         throw new ParserException(s"Contract template syntax error: $f", Some(SourceContext.fromParserFailure(f)))
     }

sc/shared/src/main/scala/sigmastate/lang/SigmaTyper.scala

@@ -1,6 +1,5 @@
 package sigmastate.lang
 
-import org.ergoplatform._
 import sigma.ast.SCollection.{SBooleanArray, SByteArray}
 import sigma.ast._
 import sigma.ast.syntax.SValue
@@ -19,6 +18,7 @@ import scala.collection.mutable.ArrayBuffer
   */
 class SigmaTyper(val builder: SigmaBuilder,
                  predefFuncRegistry: PredefinedFuncRegistry,
+                 typeEnv: Map[String, SType],
                  lowerMethodCalls: Boolean) {
   import SigmaTyper._
   import builder._
@@ -28,8 +28,10 @@ class SigmaTyper(val builder: SigmaBuilder,
 
   import SType.tT
 
-  private val predefinedEnv: Map[String, SType] =
-      predefFuncRegistry.funcs.map { case (k, f) => k -> f.declaration.tpe }.toMap
+  private val predefinedEnv: Map[String, SType] = {
+      val predefFuncs = predefFuncRegistry.funcs.map { case (k, f) => k -> f.declaration.tpe }.toMap
+      predefFuncs ++ typeEnv
+  }
 
   private def processGlobalMethod(srcCtx: Nullable[SourceContext],
                                   method: SMethod,

sc/shared/src/test/scala/sigmastate/CompilerTestsBase.scala

@@ -9,8 +9,9 @@ import sigma.ast.syntax.{SValue, SigmaPropValue}
 import sigma.serialization.ValueSerializer
 import sigmastate.eval.IRContext
 import sigma.ast.syntax.ValueOps
+import sigmastate.helpers.{NegativeTesting, SigmaPPrint}
 
-trait CompilerTestsBase extends TestsBase {
+trait CompilerTestsBase extends TestsBase with NegativeTesting {
   protected val _lowerMethodCalls = new DynamicVariable[Boolean](true)
 
   /** Returns true if MethodCall nodes should be lowered by TypeChecker to the
@@ -63,4 +64,12 @@ trait CompilerTestsBase extends TestsBase {
     val tree = mkTestErgoTree(prop)
     (tree, prop)
   }
+
+  /** Checks expectation pretty printing the actual value if there is a difference. */
+  def checkEquals[T](actual: T, expected: T): Unit = {
+    if (expected != actual) {
+      SigmaPPrint.pprintln(actual, width = 100)
+    }
+    actual shouldBe expected
+  }
 }