merging w. 6.0.0

build.sbt

@@ -82,9 +82,9 @@ ThisBuild / dynverSeparator := "-"
 
 val bouncycastleBcprov = "org.bouncycastle" % "bcprov-jdk15on" % "1.66"
 
-val scrypto            = "org.scorexfoundation" %% "scrypto" % "2.3.0-4-a0bc6176-SNAPSHOT"
+val scrypto            = "org.scorexfoundation" %% "scrypto" % "3.0.0"
 val scryptoDependency =
-  libraryDependencies += "org.scorexfoundation" %%% "scrypto" % "2.3.0-4-a0bc6176-SNAPSHOT"
+  libraryDependencies += "org.scorexfoundation" %%% "scrypto" % "3.0.0"
 
 val scorexUtil         = "org.scorexfoundation" %% "scorex-util" % "0.2.1"
 val scorexUtilDependency =

core/shared/src/main/scala/sigma/Colls.scala

@@ -45,6 +45,19 @@ trait Coll[@specialized A] {
     */
   def apply(i: Int): A
 
+  /** The element at given index or None if there is no such element. Indices start at `0`.
+    *
+    *  @param  i       the index
+    *  @return         the element at the given index, or None if there is no such element
+    */
+  def get(i: Int): Option[A] = {
+    if (isDefinedAt(i)) {
+      Some(apply(i))
+    } else {
+      None
+    }
+  }
+
   /** Tests whether this $coll contains given index.
     *
     *  The implementations of methods `apply` and `isDefinedAt` turn a `Coll[A]` into
@@ -76,6 +89,18 @@ trait Coll[@specialized A] {
     * produces a collection ((x0, y0), ..., (xK, yK)) where K = min(N, M) */
   def zip[@specialized B](ys: Coll[B]): Coll[(A, B)]
 
+  /**
+    * @return true if first elements of this collection form given `ys` collection, false otherwise.
+    *         E.g. [1,2,3] starts with [1,2]
+    */
+  def startsWith(ys: Coll[A]): Boolean
+
+  /**
+    * @return true if last elements of this collection form given `ys` collection, false otherwise.
+    *         E.g. [1,2,3] ends with [2,3]
+    */
+  def endsWith(ys: Coll[A]): Boolean
+
   /** Tests whether a predicate holds for at least one element of this collection.
     *  @param   p     the predicate used to test elements.
     *  @return        `true` if the given predicate `p` is satisfied by at least one element of this collection, otherwise `false`

core/shared/src/main/scala/sigma/SigmaDsl.scala

@@ -1,7 +1,8 @@
 package sigma
 
-import java.math.BigInteger
+import sigma.ast.SType
 
+import java.math.BigInteger
 import sigma.data._
 
 /**
@@ -154,19 +155,18 @@ trait BigInt {
   def |(that: BigInt): BigInt = or(that)
 
   /**
-    * @return a big integer whose value is `this xor that`
+    * @return a big integer whose value is `this xor that`.
+    *         This method returns a negative BigInteger if and only if exactly one of this and val are negative.
     */
   def xor(that: BigInt): BigInt
 
   /**
-    * @return a 256-bit signed integer whose value is (this << n). The shift distance, n, may be negative,
-    *         in which case this method performs a right shift. (Computes floor(this * 2n).)
+    * @return a 256-bit signed integer whose value is (this << n). `n` should be in 0..255 range (inclusive).
     */
   def shiftLeft(n: Int): BigInt
 
   /**
-    * @return a 256-bit signed integer whose value is (this >> n). Sign extension is performed. The shift distance, n,
-    *         may be negative, in which case this method performs a left shift. (Computes floor(this / 2n).)
+    * @return a 256-bit signed integer whose value is (this >> n). `n` should be in 0..255 range (inclusive).
     */
   def shiftRight(n: Int): BigInt
 
@@ -918,7 +918,13 @@ trait SigmaDslBuilder {
   /** Construct a new authenticated dictionary with given parameters and tree root digest. */
   def avlTree(operationFlags: Byte, digest: Coll[Byte], keyLength: Int, valueLengthOpt: Option[Int]): AvlTree
 
+  /** Serializes the given `value` into bytes using the default serialization format. */
+  def serialize[T](value: T)(implicit cT: RType[T]): Coll[Byte]
+
   /** Returns a byte-wise XOR of the two collections of bytes. */
   def xor(l: Coll[Byte], r: Coll[Byte]): Coll[Byte]
+
+  /** Returns a number decoded from provided big-endian bytes array. */
+  def fromBigEndianBytes[T](bytes: Coll[Byte])(implicit cT: RType[T]): T
 }
 

core/shared/src/main/scala/sigma/data/CollsOverArrays.scala

@@ -39,6 +39,10 @@ class CollOverArray[@specialized A](val toArray: Array[A], val builder: CollBuil
 
   @inline def zip[@specialized B](ys: Coll[B]): PairColl[A, B] = builder.pairColl(this, ys)
 
+  @inline def startsWith(ys: Coll[A]): Boolean = toArray.startsWith(ys.toArray)
+
+  @inline def endsWith(ys: Coll[A]): Boolean = toArray.endsWith(ys.toArray)
+
   def append(other: Coll[A]): Coll[A] = {
     if (toArray.length <= 0) return other
     val result = if (VersionContext.current.isJitActivated) {
@@ -350,6 +354,16 @@ class PairOfCols[@specialized L, @specialized R](val ls: Coll[L], val rs: Coll[R
 
   def zip[@specialized B](ys: Coll[B]): PairColl[(L,R), B] = builder.pairColl(this, ys)
 
+  def startsWith(ys: Coll[(L, R)]): Boolean = ys match {
+    case yp: PairOfCols[L, R] => ls.startsWith(yp.ls) && rs.startsWith(yp.rs)
+    case _ => toArray.startsWith(ys.toArray)
+  }
+
+  def endsWith(ys: Coll[(L, R)]): Boolean = ys match {
+    case yp: PairOfCols[L, R] => ls.endsWith(yp.ls) && rs.endsWith(yp.rs)
+    case _ => toArray.endsWith(ys.toArray)
+  }
+
   override def indices: Coll[Int] = if (ls.length <= rs.length) ls.indices else rs.indices
 
   override def flatMap[B: RType](f: ((L, R)) => Coll[B]): Coll[B] =

core/shared/src/main/scala/sigma/reflection/ReflectionData.scala

@@ -191,6 +191,9 @@ object ReflectionData {
         mkMethod(clazz, "apply", Array[Class[_]](classOf[Int])) { (obj, args) =>
           obj.asInstanceOf[Coll[_]].apply(args(0).asInstanceOf[Int])
         },
+        mkMethod(clazz, "get", Array[Class[_]](classOf[Int])) { (obj, args) =>
+          obj.asInstanceOf[Coll[_]].get(args(0).asInstanceOf[Int])
+        },
         mkMethod(clazz, "append", Array[Class[_]](classOf[Coll[_]])) { (obj, args) =>
           obj.asInstanceOf[Coll[Any]].append(args(0).asInstanceOf[Coll[Any]])
         },
@@ -199,6 +202,18 @@ object ReflectionData {
         },
         mkMethod(clazz, "map", Array[Class[_]](classOf[Function1[_, _]], classOf[RType[_]])) { (obj, args) =>
           obj.asInstanceOf[Coll[Any]].map(args(0).asInstanceOf[Any => Any])(args(1).asInstanceOf[RType[Any]])
+        },
+        mkMethod(clazz, "reverse", Array[Class[_]]()) { (obj, args) =>
+          obj.asInstanceOf[Coll[Any]].reverse
+        },
+        mkMethod(clazz, "distinct", Array[Class[_]]()) { (obj, args) =>
+          obj.asInstanceOf[Coll[Any]].distinct
+        },
+        mkMethod(clazz, "startsWith", Array[Class[_]](classOf[Coll[_]])) { (obj, args) =>
+          obj.asInstanceOf[Coll[Any]].startsWith(args(0).asInstanceOf[Coll[Any]])
+        },
+        mkMethod(clazz, "endsWith", Array[Class[_]](classOf[Coll[_]])) { (obj, args) =>
+          obj.asInstanceOf[Coll[Any]].endsWith(args(0).asInstanceOf[Coll[Any]])
         }
       )
     )
@@ -476,8 +491,15 @@ object ReflectionData {
         mkMethod(clazz, "sha256", Array[Class[_]](cColl)) { (obj, args) =>
           obj.asInstanceOf[SigmaDslBuilder].sha256(args(0).asInstanceOf[Coll[Byte]])
         },
+        mkMethod(clazz, "serialize", Array[Class[_]](classOf[Object], classOf[RType[_]])) { (obj, args) =>
+          obj.asInstanceOf[SigmaDslBuilder].serialize[Any](
+            args(0).asInstanceOf[Any])(args(1).asInstanceOf[RType[Any]])
+        },
         mkMethod(clazz, "decodePoint", Array[Class[_]](cColl)) { (obj, args) =>
           obj.asInstanceOf[SigmaDslBuilder].decodePoint(args(0).asInstanceOf[Coll[Byte]])
+        },
+        mkMethod(clazz, "fromBigEndianBytes", Array[Class[_]](cColl, classOf[RType[_]])) { (obj, args) =>
+          obj.asInstanceOf[SigmaDslBuilder].fromBigEndianBytes(args(0).asInstanceOf[Coll[Byte]])(args(1).asInstanceOf[RType[_]])
         }
       )
     )