6.0.0-Alpha2 candidate for devnets

.gitignore

@@ -8,7 +8,6 @@
 *.fdb_latexmk
 *.gz
 
-
 yarn.lock
 *.log
 yarn.lock

core/jvm/src/main/scala/sigma/crypto/Platform.scala

@@ -185,6 +185,7 @@ object Platform {
     case _: Int => tpe == SInt
     case _: Long => tpe == SLong
     case _: BigInt => tpe == SBigInt
+    case _: UnsignedBigInt => tpe == SUnsignedBigInt
     case _: String => tpe == SString  // TODO v6.0: remove this case (see https://github.com/ScorexFoundation/sigmastate-interpreter/issues/905)
     case _: GroupElement => tpe.isGroupElement
     case _: SigmaProp => tpe.isSigmaProp

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

@@ -25,6 +25,7 @@ object Evaluation {
     case SAny => AnyType
     case SUnit => UnitType
     case SBigInt => BigIntRType
+    case SUnsignedBigInt => UnsignedBigIntRType
     case SBox => BoxRType
     case SContext => ContextRType
     case SGlobal => SigmaDslBuilderRType
@@ -67,6 +68,7 @@ object Evaluation {
     case AnyType => SAny
     case UnitType => SUnit
     case BigIntRType => SBigInt
+    case UnsignedBigIntRType => SUnsignedBigInt
     case GroupElementRType => SGroupElement
     case AvlTreeRType => SAvlTree
     case ot: OptionType[_] => SOption(rtypeToSType(ot.tA))

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

@@ -6,8 +6,8 @@ import java.math.BigInteger
 import sigma.data._
 
 /**
-  * Functions defined for 256-bit signed integers
-  * */
+  * Base class for signed 256-bits integers
+  */
 trait BigInt {
   /** Convert this BigInt value to Byte.
     * @throws ArithmeticException if overflow happens.
@@ -169,8 +169,163 @@ trait BigInt {
     * @return a 256-bit signed integer whose value is (this >> n). `n` should be in 0..255 range (inclusive).
     */
   def shiftRight(n: Int): BigInt
+
+  /**
+    * @return unsigned representation of this BigInt, or exception if its value is negative
+    */
+  def toUnsigned: UnsignedBigInt
+
+  /**
+    * @return unsigned representation of this BigInt modulo `m`. Cryptographic mod operation is done, ie result is
+    *         non-negative always
+    */
+  def toUnsignedMod(m: UnsignedBigInt): UnsignedBigInt
 }
 
+
+trait UnsignedBigInt {
+  /** Convert this BigInt value to Byte.
+    * @throws ArithmeticException if overflow happens.
+    */
+  def toByte: Byte
+
+  /** Convert this BigInt value to Short.
+    * @throws ArithmeticException if overflow happens.
+    */
+  def toShort: Short
+
+  /** Convert this BigInt value to Int.
+    * @throws ArithmeticException if overflow happens.
+    */
+  def toInt: Int
+
+  /** Convert this BigInt value to Int.
+    * @throws ArithmeticException if overflow happens.
+    */
+  def toLong: Long
+
+  /** Returns a big-endian representation of this BigInt in a collection of bytes.
+    * For example, the value {@code 0x1213141516171819} would yield the
+    * byte array {@code {0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19}}.
+    * @since 2.0
+    */
+  def toBytes: Coll[Byte]
+
+
+  /** Compares this numeric with that numeric for order.  Returns a negative integer, zero, or a positive integer as the
+    * `this` is less than, equal to, or greater than `that`.
+    */
+  def compareTo(that: UnsignedBigInt): Int
+
+  /** Returns a BigInt whose value is {@code (this + that)}.
+    *
+    * @param  that value to be added to this BigInt.
+    * @return { @code this + that}
+    */
+  def add(that: UnsignedBigInt): UnsignedBigInt
+  def +(that: UnsignedBigInt): UnsignedBigInt = add(that)
+
+  /** Returns a BigInt whose value is {@code (this - that)}.
+    *
+    * @param  that value to be subtracted from this BigInt.
+    * @return { @code this - that}
+    */
+  def subtract(that: UnsignedBigInt): UnsignedBigInt
+
+  def -(that: UnsignedBigInt): UnsignedBigInt = subtract(that)
+
+  /** Returns a BigInt whose value is {@code (this * that)}.
+    *
+    * @implNote An implementation may offer better algorithmic
+    *           performance when { @code that == this}.
+    * @param  that value to be multiplied by this BigInt.
+    * @return { @code this * that}
+    */
+  def multiply(that: UnsignedBigInt): UnsignedBigInt
+  def *(that: UnsignedBigInt): UnsignedBigInt = multiply(that)
+
+  /** Returns a BigInt whose value is {@code (this / that)}.
+    *
+    * @param  that value by which this BigInt is to be divided.
+    * @return { @code this / that}
+    * @throws ArithmeticException if { @code that} is zero.
+    */
+  def divide(that: UnsignedBigInt): UnsignedBigInt
+  def /(that: UnsignedBigInt): UnsignedBigInt = divide(that)
+
+  /**
+    * Returns a BigInt whose value is {@code (this mod m}).  This method
+    * differs from {@code remainder} in that it always returns a
+    * <i>non-negative</i> BigInteger.
+    *
+    * @param  m the modulus.
+    * @return { @code this mod m}
+    * @throws ArithmeticException { @code m} &le; 0
+    * @see #remainder
+    */
+  def mod(m: UnsignedBigInt): UnsignedBigInt
+  def %(m: UnsignedBigInt): UnsignedBigInt = mod(m)
+
+  /**
+    * Returns the minimum of this BigInteger and {@code val}.
+    *
+    * @param  that value with which the minimum is to be computed.
+    * @return the BigInteger whose value is the lesser of this BigInteger and
+    *         { @code val}.  If they are equal, either may be returned.
+    */
+  def min(that: UnsignedBigInt): UnsignedBigInt
+
+  /**
+    * Returns the maximum of this BigInteger and {@code val}.
+    *
+    * @param  that value with which the maximum is to be computed.
+    * @return the BigInteger whose value is the greater of this and
+    *         { @code val}.  If they are equal, either may be returned.
+    */
+  def max(that: UnsignedBigInt): UnsignedBigInt
+
+  /** Returns a BigInteger whose value is `(this & that)`.
+    * @param that value to be AND'ed with this BigInteger.
+    * @return `this & that`
+    */
+  def and(that: UnsignedBigInt): UnsignedBigInt
+  def &(that: UnsignedBigInt): UnsignedBigInt = and(that)
+
+  /** Returns a BigInteger whose value is `(this | that)`.
+    *
+    * @param that value to be OR'ed with this BigInteger.
+    * @return `this | that`
+    */
+  def or(that: UnsignedBigInt): UnsignedBigInt
+  def |(that: UnsignedBigInt): UnsignedBigInt = or(that)
+
+  def modInverse(m: UnsignedBigInt): UnsignedBigInt
+  def plusMod(that: UnsignedBigInt, m: UnsignedBigInt): UnsignedBigInt
+  def subtractMod(that: UnsignedBigInt, m: UnsignedBigInt): UnsignedBigInt
+  def multiplyMod(that: UnsignedBigInt, m: UnsignedBigInt): UnsignedBigInt
+
+  /**
+    * @return a big integer whose value is `this xor that`
+    */
+  def xor(that: UnsignedBigInt): UnsignedBigInt
+
+  /**
+    * @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).)
+    */
+  def shiftLeft(n: Int): UnsignedBigInt
+
+  /**
+    * @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).)
+    */
+  def shiftRight(n: Int): UnsignedBigInt
+
+  def toSigned(): BigInt
+}
+
+
+
 /** Base class for points on elliptic curves. */
 trait GroupElement {
   /** Checks if the provided element is an identity element. */
@@ -183,6 +338,8 @@ trait GroupElement {
     */
   def exp(k: BigInt): GroupElement
 
+  def expUnsigned(k: UnsignedBigInt): GroupElement
+
   /** Group operation. */
   def multiply(that: GroupElement): GroupElement
 
@@ -490,7 +647,6 @@ trait Header {
     * @return result of header's proof-of-work validation
     */
   def checkPow: Boolean
-
 }
 
 /** Runtime representation of Context ErgoTree type.
@@ -589,6 +745,17 @@ trait Context {
     */
   def getVar[T](id: Byte)(implicit cT: RType[T]): Option[T]
 
+  /**
+    * A variant of `getVar` to extract a context variable by id and type from any input
+    *
+    * @param inputId - input index
+    * @param id - context variable id
+    * @tparam T - expected type of the variable
+    * @return Some(value) if the variable is defined in the context AND has the given type.
+    *         None otherwise
+    */
+  def getVarFromInput[T](inputId: Short, id: Byte)(implicit cT: RType[T]): Option[T]
+
   def vars: Coll[AnyValue]
 
   /** Maximum version of ErgoTree currently activated on the network.
@@ -727,6 +894,20 @@ trait SigmaDslBuilder {
     */
   def groupGenerator: GroupElement
 
+  /**
+    * @return big integer provided as input approximately encoded using NBits,
+    *         see (https://bitcoin.stackexchange.com/questions/57184/what-does-the-nbits-value-represent)
+    *         for format details
+    */
+  def encodeNbits(bi: BigInt): Long
+
+  /**
+    * @return big integer decoded from NBits value provided,
+    *         see (https://bitcoin.stackexchange.com/questions/57184/what-does-the-nbits-value-represent)
+    *         for format details
+    */
+  def decodeNbits(l: Long): BigInt
+
   /**
     * Transforms serialized bytes of ErgoTree with segregated constants by replacing constants
     * at given positions with new values. This operation allow to use serialized scripts as
@@ -753,6 +934,8 @@ trait SigmaDslBuilder {
   /** Create DSL big integer from existing `java.math.BigInteger`*/
   def BigInt(n: BigInteger): BigInt
 
+  def UnsignedBigInt(n: BigInteger): UnsignedBigInt
+
   /** Extract `java.math.BigInteger` from DSL's `BigInt` type*/
   def toBigInteger(n: BigInt): BigInteger
 
@@ -765,7 +948,17 @@ trait SigmaDslBuilder {
   /** Returns a byte-wise XOR of the two collections of bytes. */
   def xor(l: Coll[Byte], r: Coll[Byte]): Coll[Byte]
 
+  /** Calculates value of a custom Autolykos 2 hash function */
+  def powHit(k: Int, msg: Coll[Byte], nonce: Coll[Byte], h: Coll[Byte], N: Int): BigInt
+
+  /** Deserializes provided `bytes` into a value of type `T`. **/
+  def deserializeTo[T](bytes: Coll[Byte])(implicit cT: RType[T]): T
+
   /** Returns a number decoded from provided big-endian bytes array. */
   def fromBigEndianBytes[T](bytes: Coll[Byte])(implicit cT: RType[T]): T
+
+  def some[T](value: T)(implicit cT: RType[T]): Option[T]
+
+  def none[T]()(implicit cT: RType[T]): Option[T]
 }