Merge pull request #1073 from ergoplatform/60upcast

Disabling auto-upcast and checking method call args emptiness in trees >= v3

Author: kushti

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

@@ -75,6 +75,8 @@ case class UnparsedErgoTree(bytes: mutable.WrappedArray[Byte], error: Validation
   *                         for optimized execution.
   *                         ErgoTreeSerializer parsing method computes the value of
   *                         this flag and provides it to the constructor.
+  * @param givenIsUsingBlockchainContext optional flag which indicates that blockchain context related operations
+  *                                      are used in the tree
   */
 case class ErgoTree private[sigma](
     header: HeaderType,

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

@@ -10,7 +10,7 @@ import sigma.data.Nullable
 import sigma.exceptions.ConstraintFailed
 import sigma.serialization.OpCodes
 import sigma.serialization.ValueCodes.OpCode
-import sigma.{AnyValue, Coll, Colls, Environment, Evaluation, Platform}
+import sigma.{AnyValue, Coll, Colls, Environment, Evaluation, Platform, VersionContext}
 
 import scala.util.DynamicVariable
 
@@ -664,7 +664,7 @@ class TransformingSigmaBuilder extends StdSigmaBuilder {
     * @param right operand of the operation (right sub-expression)
     * @return a pair (l,r) of the arguments appropriately upcasted.
     */
-  private def applyUpcast[T <: SType](left: Value[T], right: Value[T]): (Value[T], Value[T]) =
+  protected def applyUpcast[T <: SType](left: Value[T], right: Value[T]): (Value[T], Value[T]) =
     (left.tpe, right.tpe) match {
       case (t1: SNumericType, t2: SNumericType) if t1 != t2 =>
         val tmax = t1 max t2
@@ -740,7 +740,22 @@ case object CheckingSigmaBuilder extends CheckingSigmaBuilder
 case object TransformingSigmaBuilder extends TransformingSigmaBuilder
 
 /** Builder of ErgoTree nodes which is used in deserializers. */
-case object DeserializationSigmaBuilder extends TransformingSigmaBuilder
+case object DeserializationSigmaBuilder extends TransformingSigmaBuilder {
+  // since v3 trees, Upcast nodes are not inserted automatically
+  // when v3 nodes appeared on the Ergo blockchain, 90+% of
+  // mining nodes are rejecting trees invalid auto-upcast,
+  // so no such trees expected in the longest chain
+  // the reason to remove auto-upcast is to make deserialization
+  // always producing tree which was serialized
+  override protected def applyUpcast[T <: SType](left: Value[T], right: Value[T]): (Value[T], Value[T]) = {
+    if (VersionContext.current.isV3OrLaterErgoTreeVersion) {
+      (left, right)
+    } else {
+      super.applyUpcast(left, right)
+    }
+  }
+}
+
 
 object Constraints {
   /** Represents a constraint on arguments of binary operation. */

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

@@ -1996,7 +1996,7 @@ case object SGlobalMethods extends MonoTypeMethods {
     .withIRInfo(MethodCallIrBuilder,
       javaMethodOf[SigmaDslBuilder, RType[_]]("none"),
       { mtype => Array(mtype.tRange) })
-    .withInfo(MethodCall, "Returns empty Option[T] of given type T.")
+    .withInfo(PropertyCall, "Returns empty Option[T] of given type T.")
 
   protected override def getMethods() = super.getMethods() ++ {
     if (VersionContext.current.isV3OrLaterErgoTreeVersion) {

data/shared/src/main/scala/sigma/serialization/MethodCallSerializer.scala

@@ -5,6 +5,7 @@ import sigma.ast.{MethodCall, SContextMethods, SMethod, SType, STypeSubst, SType
 import sigma.util.safeNewArray
 import SigmaByteWriter._
 import debox.cfor
+import sigma.VersionContext
 import sigma.ast.SContextMethods.BlockchainContextMethodNames
 import sigma.serialization.CoreByteWriter.{ArgInfo, DataInfo}
 
@@ -48,6 +49,10 @@ case class MethodCallSerializer(cons: (Value[SType], SMethod, IndexedSeq[Value[S
     val methodId = r.getByte()
     val obj = r.getValue()
     val args = r.getValues()
+    // introducing the same check we have in serializer since v3 trees
+    if (VersionContext.current.isV3OrLaterErgoTreeVersion) {
+      assert(args.nonEmpty)
+    }
     val method = SMethod.fromIds(typeId, methodId)
 
     val explicitTypes = if (method.hasExplicitTypeArgs) {

data/shared/src/main/scala/sigma/serialization/transformers/ByIndexSerializer.scala

@@ -4,6 +4,7 @@ import sigma.ast.{ByIndex, Value}
 import sigma.ast.syntax._
 import sigma.serialization.{SigmaByteReader, SigmaByteWriter, ValueSerializer}
 import ValueSerializer._
+import sigma.VersionContext
 import sigma.ast.syntax.SValue
 import sigma.ast.Operations.ByIndexInfo._
 import sigma.serialization.SigmaByteWriter._
@@ -25,7 +26,11 @@ case class ByIndexSerializer(cons: (Value[SCollection[SType]], Value[SInt.type],
 
   override def parse(r: SigmaByteReader): Value[SType] = {
     val input = r.getValue().asCollection[SType]
-    val index = r.getValue().upcastTo(SInt)
+    val index = if (VersionContext.current.isV3OrLaterErgoTreeVersion){
+      r.getValue().asValue[SInt.type]
+    } else {
+      r.getValue().upcastTo(SInt)
+    }
     val default = r.getOption(r.getValue())
     cons(input, index, default)
   }

interpreter/shared/src/test/scala/sigma/serialization/SubstConstantsSerializerSpecification.scala

@@ -1,16 +1,25 @@
 package sigma.serialization
 
-import sigma.ast.{EQ, SInt, SubstConstants}
+import sigma.VersionContext
+import sigma.ast.{ConcreteCollection, EQ, IntArrayConstant, IntConstant, SInt, SNumericType, SubstConstants, Upcast, Value}
 import sigma.ast.syntax.IntValue
-import sigma.ast.{ConcreteCollection, IntArrayConstant, IntConstant}
 import sigma.serialization.ErgoTreeSerializer.DefaultSerializer
 import sigmastate.CrossVersionProps
 
 class SubstConstantsSerializerSpecification extends SerializationSpecification
   with CrossVersionProps {
 
   property("SubstConstant deserialization round trip") {
-    forAll(numExprTreeNodeGen) { prop =>
+    forAll(numExprTreeNodeGen) { propRaw =>
+      val prop = if(VersionContext.current.isV3OrLaterErgoTreeVersion) {
+        val p = VersionContext.withVersions(2, 2) {
+          // roundtrip to add Upcast nodes needed for v3 trees
+          ValueSerializer.deserialize(ValueSerializer.serialize(propRaw))
+        }
+        Upcast(p.asInstanceOf[Value[SNumericType]], SInt)
+      } else {
+        propRaw
+      }
       val tree = mkTestErgoTree(EQ(prop, IntConstant(1)).toSigmaProp)
       val bytes = DefaultSerializer.serializeErgoTree(tree)
       val newVals = ConcreteCollection(Array[IntValue](1), SInt)
@@ -19,4 +28,4 @@ class SubstConstantsSerializerSpecification extends SerializationSpecification
     }
   }
 
-}
+}

interpreter/shared/src/test/scala/sigma/serialization/generators/ObjectGenerators.scala

@@ -78,6 +78,7 @@ trait ObjectGenerators extends TypeGenerators
   implicit lazy val arbBoxConstant: Arbitrary[BoxConstant] = Arbitrary(boxConstantGen)
   implicit lazy val arbAvlTreeConstant: Arbitrary[AvlTreeConstant] = Arbitrary(avlTreeConstantGen)
   implicit lazy val arbBigIntConstant: Arbitrary[BigIntConstant] = Arbitrary(bigIntConstGen)
+  implicit lazy val arbUnsignedBigIntConstant: Arbitrary[UnsignedBigIntConstant] = Arbitrary(unsignedBigIntConstGen)
   implicit lazy val arbGetVarBox: Arbitrary[BoxValue] = Arbitrary(getVar[SBox.type])
   implicit lazy val arbGetVarAvlTree : Arbitrary[AvlTreeValue]   = Arbitrary(getVarAvlTreeGen)
   implicit lazy val arbProveDlog     : Arbitrary[ProveDlog]      = Arbitrary(proveDlogGen)
@@ -572,12 +573,13 @@ trait ObjectGenerators extends TypeGenerators
     )
   } yield node
 
-  def numExprTreeGen: Gen[Value[SNumericType]] =
+  def numExprTreeGen: Gen[Value[SNumericType]] = {
     Gen.oneOf(arbByteConstants.arbitrary,
       arbIntConstants.arbitrary,
       arbLongConstants.arbitrary,
       arbBigIntConstant.arbitrary,
       Gen.delay(numExprTreeNodeGen))
+  }
 
   def comparisonExprTreeNodeGen: Gen[Value[SBoolean.type]] = for {
     left <- numExprTreeNodeGen

sc/shared/src/test/scala/sigmastate/serialization/DeserializationResilience.scala

@@ -27,12 +27,12 @@ import sigmastate.utils.Helpers._
 
 import java.math.BigInteger
 import java.nio.ByteBuffer
-import scala.collection.immutable.Seq
 import scala.collection.mutable
 import scala.util.{Failure, Success, Try}
 
 trait DeserializationResilienceTesting extends SerializationSpecification
     with CompilerTestingCommons with CompilerCrossVersionProps {
+
   protected def traceReaderCallDepth(expr: SValue): (IndexedSeq[Int], IndexedSeq[Int]) = {
     class LoggingSigmaByteReader(r: Reader) extends
         SigmaByteReader(r,
@@ -207,10 +207,12 @@ class DeserializationResilience extends DeserializationResilienceTesting {
         val (callDepths, levels) = traceReaderCallDepth(expr)
         callDepths shouldEqual levels
       }
-      forAll(numExprTreeNodeGen) { numExpr =>
-        val expr = EQ(numExpr, IntConstant(1))
-        val (callDepths, levels) = traceReaderCallDepth(expr)
-        callDepths shouldEqual levels
+      if(!VersionContext.current.isV3OrLaterErgoTreeVersion) { // to avoid issues with upcast in trees >= v3
+        forAll(numExprTreeNodeGen) { numExpr =>
+          val expr = EQ(numExpr, IntConstant(1))
+          val (callDepths, levels) = traceReaderCallDepth(expr)
+          callDepths shouldEqual levels
+        }
       }
       forAll(sigmaBooleanGen) { sigmaBool =>
         val (callDepths, levels) = traceReaderCallDepth(sigmaBool)

sc/shared/src/test/scala/sigmastate/serialization/ErgoTreeSerializerSpecification.scala

@@ -2,14 +2,15 @@ package sigma.serialization
 
 import org.ergoplatform.ErgoBox
 import org.ergoplatform.validation.ValidationRules.CheckDeserializedScriptIsSigmaProp
-import sigma.SigmaProp
+import sigma.{SigmaProp, VersionContext}
 import sigma.ast._
 import sigma.ast.syntax.SigmaPropValue
 import sigma.data.CBigInt
 import sigma.util.Extensions.SigmaPropOps
 import sigma.validation.ValidationException
 import ErgoTree.EmptyConstants
 import ErgoTree.HeaderType
+import scorex.util.encode.Base16
 import sigma.compiler.ir.IRContext
 import sigma.eval.Extensions.SigmaBooleanOps
 import sigmastate._
@@ -25,6 +26,8 @@ class ErgoTreeSerializerSpecification extends SerializationSpecification
     beginPass(noConstPropagationPass)
   }
 
+
+
   private def extractConstants(prop: SigmaPropValue)(implicit IR: IRContext): Seq[ErgoTree] = {
     import ErgoTree._
     val env = Map[String, Any]()
@@ -222,4 +225,16 @@ class ErgoTreeSerializerSpecification extends SerializationSpecification
       treeBytes shouldBe propBytes.toArray
     }
   }
+
+  property("v3 tree with upcast") {
+    val treeBytes = Base16.decode("0b15ea02e4dc650cfe020300020008b20e020102020100").get
+
+    VersionContext.withVersions(3, 3) {
+      val tree = DefaultSerializer.deserializeErgoTree(treeBytes)
+      val treeBytes2 = DefaultSerializer.serializeErgoTree(tree)
+
+      treeBytes.sameElements(treeBytes2) shouldBe true
+    }
+  }
+
 }

sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala

@@ -127,6 +127,12 @@ class BasicOpsSpecification extends CompilerTestingCommons
       prop shouldBe propExp
 
     val tree = ErgoTree.fromProposition(ergoTreeHeaderInTests, prop)
+
+    // check ErgoTree roundtrip
+    val tBytes = ErgoTreeSerializer.DefaultSerializer.serializeErgoTree(tree)
+    val tBytes2 = ErgoTreeSerializer.DefaultSerializer.serializeErgoTree(ErgoTreeSerializer.DefaultSerializer.deserializeErgoTree(tBytes))
+    tBytes.sameElements(tBytes2) shouldBe true
+
     val p3 = prover.dlogSecrets(2).publicImage
     val boxToSpend = testBox(10, tree,
       additionalRegisters = additionalRegistersOpt.getOrElse(Map(