From 8208dd8c4aaa39c2fdb6823d986954e71d77cb19 Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Tue, 3 Sep 2024 12:46:56 +0300
Subject: [PATCH 1/2] Box.getReg with computable index

---
 .gitignore                                    |   1 +
 .../src/main/scala/sigma/SigmaDsl.scala       |  17 ++
 .../sigma/reflection/ReflectionData.scala     |   3 +
 .../main/scala/sigma/util/NBitsUtils.scala    |  84 ++++++++
 .../scala/org/ergoplatform/ErgoHeader.scala   | 182 ++++++++++++++++++
 .../org/ergoplatform/HeaderWithoutPow.scala   | 145 ++++++++++++++
 .../src/main/scala/sigma/ast/methods.scala    |  67 +++++--
 .../src/main/scala/sigma/data/CHeader.scala   | 142 ++++++++++++++
 .../scala/sigma/eval/ErgoTreeEvaluator.scala  |   2 +-
 .../sigma/pow/Autolykos2PowValidation.scala   | 176 +++++++++++++++++
 .../sigma/serialization/DataSerializer.scala  |  14 +-
 docs/LangSpec.md                              |   4 +
 .../main/scala/sigmastate/eval/CHeader.scala  |  34 ----
 .../interpreter/CErgoTreeEvaluator.scala      |   6 +-
 .../ConstantSerializerSpecification.scala     |  41 ++--
 .../DataSerializerSpecification.scala         | 135 +++++++++----
 .../MethodCallSerializerSpecification.scala   |  23 +++
 .../SerializationSpecification.scala          |  21 +-
 .../generators/ObjectGenerators.scala         |  10 +-
 .../generators/TypeGenerators.scala           |   3 +-
 .../special/sigma/SigmaTestingData.scala      |  16 +-
 .../sigma/compiler/ir/GraphBuilding.scala     |  11 +-
 .../sigma/compiler/ir/GraphIRReflection.scala |   3 +
 .../scala/sigma/compiler/ir/IRContext.scala   |   2 +-
 .../scala/sigma/compiler/ir/MethodCalls.scala |  16 +-
 .../sigma/compiler/ir/TreeBuilding.scala      |  16 +-
 .../ir/wrappers/sigma/SigmaDslUnit.scala      |   1 +
 .../ir/wrappers/sigma/impl/SigmaDslImpl.scala |  24 ++-
 .../sigma/compiler/phases/SigmaTyper.scala    |   6 +-
 .../scala/sigma/LanguageSpecificationV5.scala |  17 +-
 .../scala/sigma/LanguageSpecificationV6.scala |  58 +++++-
 .../test/scala/sigma/SigmaDslTesting.scala    |  18 +-
 .../sigmastate/ErgoTreeSpecification.scala    |  13 +-
 .../TestingInterpreterSpecification.scala     |  91 +++++++--
 .../scala/sigmastate/TypesSpecification.scala |   2 -
 .../utxo/BasicOpsSpecification.scala          |  43 +++++
 .../org/ergoplatform/sdk/js/Header.scala      |   6 +-
 .../scala/org/ergoplatform/sdk/js/Isos.scala  |  12 +-
 .../org/ergoplatform/sdk/js/IsosSpec.scala    |   4 +-
 .../ergoplatform/sdk/DataJsonEncoder.scala    |   8 +
 .../org/ergoplatform/sdk/JsonCodecs.scala     |  17 +-
 .../sdk/DataJsonEncoderSpecification.scala    |  92 ++++++---
 42 files changed, 1365 insertions(+), 221 deletions(-)
 create mode 100644 core/shared/src/main/scala/sigma/util/NBitsUtils.scala
 create mode 100644 data/shared/src/main/scala/org/ergoplatform/ErgoHeader.scala
 create mode 100644 data/shared/src/main/scala/org/ergoplatform/HeaderWithoutPow.scala
 create mode 100644 data/shared/src/main/scala/sigma/data/CHeader.scala
 create mode 100644 data/shared/src/main/scala/sigma/pow/Autolykos2PowValidation.scala
 delete mode 100644 interpreter/shared/src/main/scala/sigmastate/eval/CHeader.scala

diff --git a/.gitignore b/.gitignore
index 4dc1640004..3570923b1d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,6 +11,7 @@
 
 yarn.lock
 *.log
+yarn.lock
 docs/spec/out/
 test-out/
 flamegraphs/
diff --git a/core/shared/src/main/scala/sigma/SigmaDsl.scala b/core/shared/src/main/scala/sigma/SigmaDsl.scala
index df2b419273..ba22d911e2 100644
--- a/core/shared/src/main/scala/sigma/SigmaDsl.scala
+++ b/core/shared/src/main/scala/sigma/SigmaDsl.scala
@@ -459,6 +459,23 @@ trait Header {
 
   /** Miner votes for changing system parameters. */
   def votes: Coll[Byte] //3 bytes
+
+  /** Bytes which are coming from future versions of the protocol, so
+    * their meaning is not known to current version of Sigma, but they
+    * are stored to get the same id as future version users.
+    */
+  def unparsedBytes: Coll[Byte]
+
+  /**
+    * @return header bytes without proof of work, a PoW is generated over them
+    */
+  def serializeWithoutPoW: Coll[Byte]
+
+  /**
+    * @return result of header's proof-of-work validation
+    */
+  def checkPow: Boolean
+
 }
 
 /** Runtime representation of Context ErgoTree type.
diff --git a/core/shared/src/main/scala/sigma/reflection/ReflectionData.scala b/core/shared/src/main/scala/sigma/reflection/ReflectionData.scala
index 028e68bf72..2a5e74e659 100644
--- a/core/shared/src/main/scala/sigma/reflection/ReflectionData.scala
+++ b/core/shared/src/main/scala/sigma/reflection/ReflectionData.scala
@@ -346,6 +346,9 @@ object ReflectionData {
         },
         mkMethod(clazz, "powDistance", Array[Class[_]]()) { (obj, _) =>
           obj.asInstanceOf[Header].powDistance
+        },
+        mkMethod(clazz, "checkPow", Array[Class[_]]()) { (obj, _) =>
+          obj.asInstanceOf[Header].checkPow
         }
       )
     )
diff --git a/core/shared/src/main/scala/sigma/util/NBitsUtils.scala b/core/shared/src/main/scala/sigma/util/NBitsUtils.scala
new file mode 100644
index 0000000000..36d526d1d5
--- /dev/null
+++ b/core/shared/src/main/scala/sigma/util/NBitsUtils.scala
@@ -0,0 +1,84 @@
+package sigma.util
+
+import java.math.BigInteger
+
+object NBitsUtils {
+
+  /**
+    * <p>The "compact" format is a representation of a whole number N using an unsigned 32 bit number similar to a
+    * floating point format. The most significant 8 bits are the unsigned exponent of base 256. This exponent can
+    * be thought of as "number of bytes of N". The lower 23 bits are the mantissa. Bit number 24 (0x800000) represents
+    * the sign of N. Therefore, N = (-1^sign) * mantissa * 256^(exponent-3).</p>
+    *
+    * <p>Satoshi's original implementation used BN_bn2mpi() and BN_mpi2bn(). MPI uses the most significant bit of the
+    * first byte as sign. Thus 0x1234560000 is compact 0x05123456 and 0xc0de000000 is compact 0x0600c0de. Compact
+    * 0x05c0de00 would be -0x40de000000.</p>
+    *
+    * <p>Bitcoin only uses this "compact" format for encoding difficulty targets, which are unsigned 256bit quantities.
+    * Thus, all the complexities of the sign bit and using base 256 are probably an implementation accident.</p>
+    */
+  def decodeCompactBits(compact: Long): BigInt = {
+    val size: Int = (compact >> 24).toInt & 0xFF
+    val bytes: Array[Byte] = new Array[Byte](4 + size)
+    bytes(3) = size.toByte
+    if (size >= 1) bytes(4) = ((compact >> 16) & 0xFF).toByte
+    if (size >= 2) bytes(5) = ((compact >> 8) & 0xFF).toByte
+    if (size >= 3) bytes(6) = (compact & 0xFF).toByte
+    decodeMPI(bytes)
+  }
+
+  /**
+    * @see Utils#decodeCompactBits(long)
+    */
+  def encodeCompactBits(requiredDifficulty: BigInt): Long = {
+    val value = requiredDifficulty.bigInteger
+    var result: Long = 0L
+    var size: Int = value.toByteArray.length
+    if (size <= 3) {
+      result = value.longValue << 8 * (3 - size)
+    } else {
+      result = value.shiftRight(8 * (size - 3)).longValue
+    }
+    // The 0x00800000 bit denotes the sign.
+    // Thus, if it is already set, divide the mantissa by 256 and increase the exponent.
+    if ((result & 0x00800000L) != 0) {
+      result >>= 8
+      size += 1
+    }
+    result |= size << 24
+    val a: Int = if (value.signum == -1) 0x00800000 else 0
+    result |= a
+    result
+  }
+
+
+  /** Parse 4 bytes from the byte array (starting at the offset) as unsigned 32-bit integer in big endian format. */
+  def readUint32BE(bytes: Array[Byte]): Long = ((bytes(0) & 0xffL) << 24) | ((bytes(1) & 0xffL) << 16) | ((bytes(2) & 0xffL) << 8) | (bytes(3) & 0xffL)
+
+  /**
+    * MPI encoded numbers are produced by the OpenSSL BN_bn2mpi function. They consist of
+    * a 4 byte big endian length field, followed by the stated number of bytes representing
+    * the number in big endian format (with a sign bit).
+    *
+    */
+  private def decodeMPI(mpi: Array[Byte]): BigInteger = {
+
+    val length: Int = readUint32BE(mpi).toInt
+    val buf = new Array[Byte](length)
+    System.arraycopy(mpi, 4, buf, 0, length)
+
+    if (buf.length == 0) {
+      BigInteger.ZERO
+    } else {
+      val isNegative: Boolean = (buf(0) & 0x80) == 0x80
+      if (isNegative) buf(0) = (buf(0) & 0x7f).toByte
+      val result: BigInteger = new BigInteger(buf)
+      if (isNegative) {
+        result.negate
+      } else {
+        result
+      }
+    }
+  }
+
+}
diff --git a/data/shared/src/main/scala/org/ergoplatform/ErgoHeader.scala b/data/shared/src/main/scala/org/ergoplatform/ErgoHeader.scala
new file mode 100644
index 0000000000..2c6a40d46d
--- /dev/null
+++ b/data/shared/src/main/scala/org/ergoplatform/ErgoHeader.scala
@@ -0,0 +1,182 @@
+package org.ergoplatform
+
+import scorex.crypto.authds.ADDigest
+import scorex.crypto.hash.{Blake2b256, Digest32}
+import scorex.util.ModifierId
+import sigma.Colls
+import sigma.crypto.{BigIntegers, CryptoConstants, EcPointType}
+import sigma.serialization.{GroupElementSerializer, SigmaByteReader, SigmaByteWriter, SigmaSerializer}
+
+import scala.runtime.ScalaRunTime
+import scala.util.hashing.MurmurHash3
+
+
+
+/**
+  * Solution for an Autolykos PoW puzzle.
+  *
+  * In Autolykos v.1 all the four fields are used, in Autolykos v.2 only pk and n fields are used.
+  *
+  * @param pk - miner public key. Should be used to collect block rewards
+  * @param w  - one-time public key. Prevents revealing of miners secret
+  * @param n  - nonce (8 bytes)
+  * @param d  - distance between pseudo-random number, corresponding to nonce `n` and a secret,
+  *           corresponding to `pk`. The lower `d` is, the harder it was to find this solution.
+  */
+class AutolykosSolution(val pk: EcPointType,
+                        val w: EcPointType,
+                        val n: Array[Byte],
+                        val d: BigInt) {
+
+    val encodedPk: Array[Byte] = GroupElementSerializer.toBytes(pk)
+
+    override def hashCode(): Int = {
+        var h = pk.hashCode()
+        h = h * 31 + w.hashCode()
+        h = h * 31 + MurmurHash3.arrayHash(n)
+        h = h * 31 + d.hashCode()
+        h
+    }
+
+    override def equals(obj: Any): Boolean = {
+        obj match {
+            case other: AutolykosSolution =>
+                this.pk == other.pk &&
+                  this.n.sameElements(other.n) &&
+                  this.w == other.w &&
+                  this.d == other.d
+
+            case _ => false
+        }
+    }
+}
+
+
+object AutolykosSolution {
+    // "pk", "w" and "d" values for Autolykos v2 solution, where they not passed from outside
+    val pkForV2: EcPointType = CryptoConstants.dlogGroup.identity
+    val wForV2: EcPointType = CryptoConstants.dlogGroup.generator
+    val dForV2: BigInt = 0
+
+    object sigmaSerializerV1 extends SigmaSerializer[AutolykosSolution, AutolykosSolution] {
+        override def serialize(s: AutolykosSolution, w: SigmaByteWriter): Unit = {
+            GroupElementSerializer.serialize(s.pk, w)
+            GroupElementSerializer.serialize(s.w, w)
+            require(s.n.length == 8) // non-consensus check on prover side
+            w.putBytes(s.n)
+            val dBytes = BigIntegers.asUnsignedByteArray(s.d.bigInteger)
+            w.putUByte(dBytes.length)
+            w.putBytes(dBytes)
+        }
+
+        override def parse(r: SigmaByteReader): AutolykosSolution = {
+            val pk = GroupElementSerializer.parse(r)
+            val w = GroupElementSerializer.parse(r)
+            val nonce = r.getBytes(8)
+            val dBytesLength = r.getUByte()
+            val d = BigInt(BigIntegers.fromUnsignedByteArray(r.getBytes(dBytesLength)))
+            new AutolykosSolution(pk, w, nonce, d)
+        }
+    }
+
+    object sigmaSerializerV2 extends SigmaSerializer[AutolykosSolution, AutolykosSolution] {
+        override def serialize(s: AutolykosSolution, w: SigmaByteWriter): Unit = {
+            GroupElementSerializer.serialize(s.pk, w)
+            require(s.n.length == 8) // non-consensus check on prover side
+            w.putBytes(s.n)
+        }
+
+        override def parse(r: SigmaByteReader): AutolykosSolution = {
+            val pk = GroupElementSerializer.parse(r)
+            val nonce = r.getBytes(8)
+            new AutolykosSolution(pk, wForV2, nonce, dForV2)
+        }
+    }
+}
+
+/**
+  * Header of a block. It authenticates link to a previous block, other block sections
+  * (transactions, UTXO set transformation proofs, extension), UTXO set, votes for parameters
+  * to be changed and proof-of-work related data.
+  *
+  * @param version - protocol version
+  * @param parentId - id of a parent block header
+  * @param ADProofsRoot - digest of UTXO set transformation proofs
+  * @param stateRoot - AVL+ tree digest of UTXO set (after the block)
+  * @param transactionsRoot - Merkle tree digest of transactions in the block (BlockTransactions section)
+  * @param timestamp - block generation time reported by a miner
+  * @param nBits - difficulty encoded
+  * @param height - height of the block (genesis block height == 1)
+  * @param extensionRoot - Merkle tree digest of the extension section of the block
+  * @param powSolution - solution for the proof-of-work puzzle
+  * @param votes - votes for changing system parameters
+  * @param unparsedBytes - bytes from future versions of the protocol our version can't parse
+  * @param _bytes - serialized bytes of the header when not `null`
+  */
+case class ErgoHeader(override val version: ErgoHeader.Version,
+                      override val parentId: ModifierId,
+                      override val ADProofsRoot: Digest32,
+                      override val stateRoot: ADDigest, //33 bytes! extra byte with tree height here!
+                      override val transactionsRoot: Digest32,
+                      override val timestamp: ErgoHeader.Timestamp,
+                      override val nBits: Long, //actually it is unsigned int
+                      override val height: Int,
+                      override val extensionRoot: Digest32,
+                      powSolution: AutolykosSolution,
+                      override val votes: Array[Byte], //3 bytes
+                      override val unparsedBytes: Array[Byte],
+                      _bytes: Array[Byte]) extends
+  HeaderWithoutPow(version, parentId, ADProofsRoot, stateRoot, transactionsRoot, timestamp,
+    nBits, height, extensionRoot, votes, unparsedBytes) {
+
+    lazy val bytes = if(_bytes != null) {
+        _bytes
+    } else {
+        ErgoHeader.sigmaSerializer.toBytes(this)
+    }
+
+    lazy val serializedId: Array[Byte] = Blake2b256.hash(bytes)
+
+    lazy val id = Colls.fromArray(serializedId)
+
+    override def hashCode(): Int = id.hashCode()
+
+    override def equals(other: Any): Boolean = other match {
+        case h: ErgoHeader => h.id == this.id
+        case _ => false
+    }
+}
+
+
+object ErgoHeader {
+
+    type Timestamp = Long
+
+    type Version = Byte
+
+    object sigmaSerializer extends SigmaSerializer[ErgoHeader, ErgoHeader] {
+        override def serialize(hdr: ErgoHeader, w: SigmaByteWriter): Unit = {
+            HeaderWithoutPowSerializer.serialize(hdr, w)
+            if (hdr.version == 1) {
+                AutolykosSolution.sigmaSerializerV1.serialize(hdr.powSolution, w)
+            } else {
+                AutolykosSolution.sigmaSerializerV2.serialize(hdr.powSolution, w)
+            }
+        }
+
+        override def parse(r: SigmaByteReader): ErgoHeader = {
+            val start = r.position
+            val headerWithoutPow = HeaderWithoutPowSerializer.parse(r)
+            val powSolution = if (headerWithoutPow.version == 1) {
+                AutolykosSolution.sigmaSerializerV1.parse(r)
+            } else {
+                AutolykosSolution.sigmaSerializerV2.parse(r)
+            }
+            val end = r.position
+            val len = end - start
+            r.position = start
+            val headerBytes = r.getBytes(len) // also moves position back to end
+            headerWithoutPow.toHeader(powSolution, headerBytes)
+        }
+    }
+}
\ No newline at end of file
diff --git a/data/shared/src/main/scala/org/ergoplatform/HeaderWithoutPow.scala b/data/shared/src/main/scala/org/ergoplatform/HeaderWithoutPow.scala
new file mode 100644
index 0000000000..21a10a5036
--- /dev/null
+++ b/data/shared/src/main/scala/org/ergoplatform/HeaderWithoutPow.scala
@@ -0,0 +1,145 @@
+package org.ergoplatform
+
+import scorex.crypto.authds.ADDigest
+import scorex.crypto.hash.Digest32
+import scorex.util.{ModifierId, bytesToId, idToBytes}
+import sigma.serialization.{SigmaByteReader, SigmaByteWriter, SigmaSerializer}
+import scorex.util.Extensions._
+
+/**
+  * Header without proof-of-work puzzle solution, see Header class description for details.
+  */
+class HeaderWithoutPow(val version:  Byte, // 1 byte
+                       val parentId: ModifierId, // 32 bytes
+                       val ADProofsRoot: Digest32, // 32 bytes
+                       val stateRoot: ADDigest, //33 bytes! extra byte with tree height here!
+                       val transactionsRoot: Digest32, // 32 bytes
+                       val timestamp: Long,
+                       val nBits: Long, //actually it is unsigned int
+                       val height: Int,
+                       val extensionRoot: Digest32,
+                       val votes: Array[Byte], //3 bytes
+                       val unparsedBytes: Array[Byte]) {
+  def toHeader(powSolution: AutolykosSolution, bytes: Array[Byte]): ErgoHeader =
+    ErgoHeader(version, parentId, ADProofsRoot, stateRoot, transactionsRoot, timestamp,
+      nBits, height, extensionRoot, powSolution, votes, unparsedBytes, bytes)
+
+  override def toString: String = {
+    s"HeaderWithoutPow($version, $parentId, ${bytesToId(ADProofsRoot)}, ${bytesToId(stateRoot)}, " +
+      s"${bytesToId(transactionsRoot)}, $timestamp, $nBits, $height, ${bytesToId(extensionRoot)}, ${bytesToId(votes)}, " +
+      s"${bytesToId(unparsedBytes)} )"
+  }
+}
+
+object HeaderWithoutPow {
+
+  def apply(version: Byte, parentId: ModifierId, ADProofsRoot: Digest32, stateRoot: ADDigest,
+            transactionsRoot: Digest32, timestamp: Long, nBits: Long, height: Int,
+            extensionRoot: Digest32, votes: Array[Byte], unparsedBytes: Array[Byte]): HeaderWithoutPow = {
+    new HeaderWithoutPow(version, parentId, ADProofsRoot, stateRoot, transactionsRoot, timestamp,
+      nBits, height, extensionRoot, votes, unparsedBytes)
+  }
+
+}
+
+object HeaderWithoutPowSerializer extends SigmaSerializer[HeaderWithoutPow, HeaderWithoutPow] {
+
+  override def serialize(h: HeaderWithoutPow, w: SigmaByteWriter): Unit = {
+    w.put(h.version)
+    w.putBytes(idToBytes(h.parentId))
+    w.putBytes(h.ADProofsRoot)
+    w.putBytes(h.transactionsRoot)
+    w.putBytes(h.stateRoot)
+    w.putULong(h.timestamp)
+    w.putBytes(h.extensionRoot)
+    DifficultySerializer.serialize(h.nBits, w)
+    w.putUInt(h.height.toLong)
+    w.putBytes(h.votes)
+
+    // For block version >= 2, this new byte encodes length of possible new fields.
+    // Set to 0 for now, so no new fields.
+    if (h.version > HeaderVersion.InitialVersion) {
+      w.putUByte(h.unparsedBytes.length)
+      w.putBytes(h.unparsedBytes)
+    }
+  }
+
+  override def parse(r: SigmaByteReader): HeaderWithoutPow = {
+    val version = r.getByte()
+    val parentId = bytesToId(r.getBytes(32))
+    val ADProofsRoot = Digest32 @@ r.getBytes(32)
+    val transactionsRoot = Digest32 @@ r.getBytes(32)
+    val stateRoot = ADDigest @@ r.getBytes(33)
+    val timestamp = r.getULong()
+    val extensionHash = Digest32 @@ r.getBytes(32)
+    val nBits = DifficultySerializer.parse(r)
+    val height = r.getUInt().toIntExact
+    val votes = r.getBytes(3)
+
+    // For block version >= 2, a new byte encodes length of possible new fields.
+    // If this byte > 0, we read new fields but do nothing, as semantics of the fields is not known.
+    val unparsedBytes = if (version > HeaderVersion.InitialVersion) {
+      val newFieldsSize = r.getUByte()
+      if (newFieldsSize > 0 && version > HeaderVersion.Interpreter60Version) {
+        // new bytes could be added only for block version >= 5
+        r.getBytes(newFieldsSize)
+      } else {
+        Array.emptyByteArray
+      }
+    } else {
+      Array.emptyByteArray
+    }
+
+    HeaderWithoutPow(version, parentId, ADProofsRoot, stateRoot, transactionsRoot, timestamp,
+      nBits, height, extensionHash, votes, unparsedBytes)
+  }
+
+}
+
+
+object DifficultySerializer extends SigmaSerializer[Long, Long] {
+
+  /** Parse 4 bytes from the byte array (starting at the offset) as unsigned 32-bit integer in big endian format. */
+  def readUint32BE(bytes: Array[Byte]): Long = ((bytes(0) & 0xffL) << 24) | ((bytes(1) & 0xffL) << 16) | ((bytes(2) & 0xffL) << 8) | (bytes(3) & 0xffL)
+
+  def uint32ToByteArrayBE(value: Long): Array[Byte] = {
+    Array(0xFF & (value >> 24), 0xFF & (value >> 16), 0xFF & (value >> 8), 0xFF & value).map(_.toByte)
+  }
+
+  override def serialize(obj: Long, w: SigmaByteWriter): Unit = {
+    w.putBytes(uint32ToByteArrayBE(obj))
+  }
+
+  override def parse(r: SigmaByteReader): Long = {
+    readUint32BE(r.getBytes(4))
+  }
+
+}
+
+object HeaderVersion {
+  type Value = Byte
+
+  /**
+    * Block version during mainnet launch
+    */
+  val InitialVersion: Value = 1.toByte
+
+  /**
+    * Block version after the Hardening hard-fork
+    * Autolykos v2 PoW, witnesses in transactions Merkle tree
+    */
+  val HardeningVersion: Value = 2.toByte
+
+  /**
+    * Block version after the 5.0 soft-fork
+    * 5.0 interpreter with JITC, monotonic height rule (EIP-39)
+    */
+  val Interpreter50Version: Value = 3.toByte
+
+  /**
+    * Block version after the 6.0 soft-fork
+    * 6.0 interpreter (EIP-50)
+    */
+  val Interpreter60Version: Value = 4.toByte
+
+}
diff --git a/data/shared/src/main/scala/sigma/ast/methods.scala b/data/shared/src/main/scala/sigma/ast/methods.scala
index e4cf0007e0..ab3f00a675 100644
--- a/data/shared/src/main/scala/sigma/ast/methods.scala
+++ b/data/shared/src/main/scala/sigma/ast/methods.scala
@@ -309,13 +309,6 @@ case object SBigIntMethods extends SNumericTypeMethods {
   /** Type for which this container defines methods. */
   override def ownerType: SMonoType = SBigInt
 
-  final val ToNBitsCostInfo = OperationCostInfo(
-    FixedCost(JitCost(5)), NamedDesc("NBitsMethodCall"))
-
-  //id = 8 to make it after toBits
-  val ToNBits = SMethod(this, "nbits", SFunc(this.ownerType, SLong), 8, ToNBitsCostInfo.costKind)
-                  .withInfo(ModQ, "Encode this big integer value as NBits")
-
   /** The following `modQ` methods are not fully implemented in v4.x and this descriptors.
     * This descritors are remain here in the code and are waiting for full implementation
     * is upcoming soft-forks at which point the cost parameters should be calculated and
@@ -333,7 +326,7 @@ case object SBigIntMethods extends SNumericTypeMethods {
 
   protected override def getMethods(): Seq[SMethod]  = {
     if (VersionContext.current.isV6SoftForkActivated) {
-      super.getMethods() ++ Seq(ToNBits)
+      super.getMethods()
       //    ModQMethod,
       //    PlusModQMethod,
       //    MinusModQMethod,
@@ -1063,7 +1056,7 @@ case object SBoxMethods extends MonoTypeMethods {
          | identifier followed by box index in the transaction outputs.
         """.stripMargin ) // see ExtractCreationInfo
 
-  lazy val getRegMethod = SMethod(this, "getReg",
+  lazy val getRegMethodV5 = SMethod(this, "getReg",
     SFunc(Array(SBox, SInt), SOption(tT), Array(paramT)), 7, ExtractRegisterAs.costKind)
       .withInfo(ExtractRegisterAs,
         """ Extracts register by id and type.
@@ -1072,23 +1065,49 @@ case object SBoxMethods extends MonoTypeMethods {
         """.stripMargin,
         ArgInfo("regId", "zero-based identifier of the register."))
 
+  lazy val getRegMethodV6 = SMethod(this, "getReg",
+    SFunc(Array(SBox, SInt), SOption(tT), Array(paramT)), 7, ExtractRegisterAs.costKind, Seq(tT))
+    .withIRInfo(MethodCallIrBuilder,
+      javaMethodOf[Box, Int, RType[_]]("getReg"),
+      { mtype => Array(mtype.tRange.asOption[SType].elemType) })
+    .withInfo(MethodCall, """ Extracts register by id and type.
+                            | Type param \lst{T} expected type of the register.
+                            | Returns \lst{Some(value)} if the register is defined and has given type and \lst{None} otherwise
+        """.stripMargin,
+      ArgInfo("regId", "zero-based identifier of the register."))
+
   lazy val tokensMethod = SMethod(
     this, "tokens", SFunc(SBox, ErgoBox.STokensRegType), 8, FixedCost(JitCost(15)))
       .withIRInfo(MethodCallIrBuilder)
       .withInfo(PropertyCall, "Secondary tokens")
 
-
-  // should be lazy to solve recursive initialization
-  protected override def getMethods() = super.getMethods() ++ Array(
+  lazy val commonBoxMethods = super.getMethods() ++ Array(
     ValueMethod, // see ExtractAmount
     PropositionBytesMethod, // see ExtractScriptBytes
     BytesMethod, // see ExtractBytes
     BytesWithoutRefMethod, // see ExtractBytesWithNoRef
     IdMethod, // see ExtractId
     creationInfoMethod,
-    getRegMethod,
     tokensMethod
   ) ++ registers(8)
+
+  lazy val v5Methods = commonBoxMethods ++ Array(
+    getRegMethodV5
+  )
+
+  lazy val v6Methods = commonBoxMethods ++ Array(
+    getRegMethodV6
+  )
+
+  // should be lazy to solve recursive initialization
+  protected override def getMethods() = {
+    if (VersionContext.current.isV6SoftForkActivated) {
+      v6Methods
+    } else {
+      v5Methods
+    }
+  }
+
 }
 
 /** Type descriptor of `AvlTree` type of ErgoTree. */
@@ -1456,11 +1475,27 @@ case object SHeaderMethods extends MonoTypeMethods {
   lazy val powDistanceMethod      = propertyCall("powDistance", SBigInt, 14, FixedCost(JitCost(10)))
   lazy val votesMethod            = propertyCall("votes", SByteArray, 15, FixedCost(JitCost(10)))
 
-  protected override def getMethods() = super.getMethods() ++ Seq(
+  // cost of checkPoW is 700 as about 2*32 hashes required, and 1 hash (id) over short data costs 10
+  lazy val checkPowMethod = SMethod(
+    this, "checkPow", SFunc(Array(SHeader), SBoolean), 16, FixedCost(JitCost(700)))
+    .withIRInfo(MethodCallIrBuilder)
+    .withInfo(MethodCall, "Validate header's proof-of-work")
+
+  private lazy val v5Methods = super.getMethods() ++ Seq(
     idMethod, versionMethod, parentIdMethod, ADProofsRootMethod, stateRootMethod, transactionsRootMethod,
     timestampMethod, nBitsMethod, heightMethod, extensionRootMethod, minerPkMethod, powOnetimePkMethod,
-    powNonceMethod, powDistanceMethod, votesMethod
-  )
+    powNonceMethod, powDistanceMethod, votesMethod)
+
+  // 6.0 : checkPow method added
+  private lazy val v6Methods = v5Methods ++ Seq(checkPowMethod)
+
+  protected override def getMethods() = {
+    if (VersionContext.current.isV6SoftForkActivated) {
+      v6Methods
+    } else {
+      v5Methods
+    }
+  }
 }
 
 /** Type descriptor of `PreHeader` type of ErgoTree. */
diff --git a/data/shared/src/main/scala/sigma/data/CHeader.scala b/data/shared/src/main/scala/sigma/data/CHeader.scala
new file mode 100644
index 0000000000..aa5a5756d2
--- /dev/null
+++ b/data/shared/src/main/scala/sigma/data/CHeader.scala
@@ -0,0 +1,142 @@
+package sigma.data
+
+import org.ergoplatform.{AutolykosSolution, ErgoHeader, HeaderWithoutPow, HeaderWithoutPowSerializer}
+import scorex.crypto.authds.ADDigest
+import scorex.crypto.hash.Digest32
+import scorex.util.{bytesToId, idToBytes}
+import sigma.pow.Autolykos2PowValidation
+import sigma.{AvlTree, BigInt, Coll, Colls, GroupElement, Header}
+
+/** A default implementation of [[Header]] interface.
+  *
+  * @see [[Header]] for detailed descriptions
+  */
+class CHeader(val ergoHeader: ErgoHeader) extends Header with WrapperOf[ErgoHeader] {
+
+  /** Bytes representation of ModifierId of this Header */
+  override lazy val id: Coll[Byte] = ergoHeader.id
+
+  /** Block version, to be increased on every soft and hardfork. */
+  override def version: Byte = ergoHeader.version
+
+  /** Bytes representation of ModifierId of the parent block */
+  override def parentId: Coll[Byte] = Colls.fromArray(idToBytes(ergoHeader.parentId))
+
+  /** Hash of ADProofs for transactions in a block */
+  override def ADProofsRoot: Coll[Byte] = Colls.fromArray(ergoHeader.ADProofsRoot)
+
+  /** AvlTree of a state after block application */
+  override def stateRoot: AvlTree = CAvlTree(AvlTreeData.avlTreeFromDigest(Colls.fromArray(ergoHeader.stateRoot)))
+
+  /** Root hash (for a Merkle tree) of transactions in a block. */
+  override def transactionsRoot: Coll[Byte] = Colls.fromArray(ergoHeader.transactionsRoot)
+
+  /** Block timestamp (in milliseconds since beginning of Unix Epoch) */
+  override def timestamp: Long = ergoHeader.timestamp
+
+  /** Current difficulty in a compressed view.
+    * NOTE: actually it is unsigned Int */
+  override def nBits: Long = ergoHeader.nBits
+
+  /** Block height */
+  override def height: Int = ergoHeader.height
+
+  /** Root hash of extension section */
+  override def extensionRoot: Coll[Byte] = Colls.fromArray(ergoHeader.extensionRoot)
+
+  /** Miner public key. Should be used to collect block rewards.
+    * Part of Autolykos solution. */
+  override def minerPk: GroupElement = CGroupElement(ergoHeader.powSolution.pk)
+
+  /** One-time public key. Prevents revealing of miners secret. */
+  override def powOnetimePk: GroupElement = CGroupElement(ergoHeader.powSolution.w)
+
+  /** nonce */
+  override def powNonce: Coll[Byte] = Colls.fromArray(ergoHeader.powSolution.n)
+
+  /** Distance between pseudo-random number, corresponding to nonce `powNonce` and a secret,
+    * corresponding to `minerPk`. The lower `powDistance` is, the harder it was to find this solution. */
+  override def powDistance: BigInt = CBigInt(ergoHeader.powSolution.d.bigInteger)
+
+  /** Miner votes for changing system parameters. */
+  override def votes: Coll[Byte] = Colls.fromArray(ergoHeader.votes)
+
+  override def unparsedBytes: Coll[Byte] = Colls.fromArray(ergoHeader.unparsedBytes)
+
+  /** The data value wrapped by this wrapper. */
+  override def wrappedValue: ErgoHeader = ergoHeader
+
+  override def serializeWithoutPoW: Coll[Byte] = {
+    Colls.fromArray(HeaderWithoutPowSerializer.toBytes(ergoHeader))
+  }
+
+  override def checkPow: Boolean = {
+    Autolykos2PowValidation.checkPoWForVersion2(this)
+  }
+
+  override def toString: String =
+    s"""CHeader(
+       |  id: ${id},
+       |  version: ${version},
+       |  tx proofs hash: ${ADProofsRoot},
+       |  state root: ${stateRoot.digest},
+       |  transactions root: ${transactionsRoot},
+       |  time: $timestamp,
+       |  nbits: $nBits,
+       |  extension root: $extensionRoot,
+       |  miner pubkey: $minerPk,
+       |  pow one time pubkey(from AL 1): $powOnetimePk,
+       |  pow nonce: $powNonce,
+       |  pow distance (from AL 1): $powDistance,
+       |  votes: $votes,
+       |  unparsed bytes: $unparsedBytes
+       |)""".stripMargin
+
+  override def hashCode(): Int = id.hashCode()
+
+  override def equals(other: Any): Boolean = other match {
+    case ch: CHeader => ch.id == this.id
+    case _ => false
+  }
+
+  def copy(): CHeader = new CHeader(ergoHeader.copy()) // used in tests only
+}
+
+object CHeader {
+
+  def apply( version: Byte,
+             parentId: Coll[Byte],
+             ADProofsRoot: Coll[Byte],
+             stateRootDigest: Coll[Byte],
+             transactionsRoot: Coll[Byte],
+             timestamp: Long,
+             nBits: Long,
+             height: Int,
+             extensionRoot: Coll[Byte],
+             minerPk: GroupElement,
+             powOnetimePk: GroupElement,
+             powNonce: Coll[Byte],
+             powDistance: BigInt,
+             votes: Coll[Byte],
+             unparsedBytes: Coll[Byte]): CHeader = {
+
+    val solution = new AutolykosSolution(
+      minerPk.asInstanceOf[CGroupElement].wrappedValue,
+      powOnetimePk.asInstanceOf[CGroupElement].wrappedValue,
+      powNonce.toArray,
+      powDistance.asInstanceOf[CBigInt].wrappedValue)
+
+    val h = ErgoHeader(version, bytesToId(parentId.toArray), Digest32 @@ ADProofsRoot.toArray,
+      ADDigest @@ stateRootDigest.toArray, Digest32 @@ transactionsRoot.toArray, timestamp, nBits, height,
+      Digest32 @@ extensionRoot.toArray, solution, votes.toArray, unparsedBytes.toArray, null)
+
+    new CHeader(h)
+  }
+
+  /** Size of of Header.votes array. */
+  val VotesSize: Int = SigmaConstants.VotesArraySize.value
+
+  /** Size of nonce array from Autolykos POW solution in Header.powNonce array. */
+  val NonceSize: Int = SigmaConstants.AutolykosPowSolutionNonceArraySize.value
+
+}
diff --git a/data/shared/src/main/scala/sigma/eval/ErgoTreeEvaluator.scala b/data/shared/src/main/scala/sigma/eval/ErgoTreeEvaluator.scala
index 52f839354c..6df82125df 100644
--- a/data/shared/src/main/scala/sigma/eval/ErgoTreeEvaluator.scala
+++ b/data/shared/src/main/scala/sigma/eval/ErgoTreeEvaluator.scala
@@ -1,6 +1,6 @@
 package sigma.eval
 
-import sigma.{AvlTree, Coll, Context}
+import sigma.{AvlTree, Coll, Context, Header}
 import sigma.ast.{Constant, FixedCost, MethodCall, OperationCostInfo, OperationDesc, PerItemCost, SType, TypeBasedCost}
 import sigma.data.KeyValueColl
 
diff --git a/data/shared/src/main/scala/sigma/pow/Autolykos2PowValidation.scala b/data/shared/src/main/scala/sigma/pow/Autolykos2PowValidation.scala
new file mode 100644
index 0000000000..23cf722194
--- /dev/null
+++ b/data/shared/src/main/scala/sigma/pow/Autolykos2PowValidation.scala
@@ -0,0 +1,176 @@
+package sigma.pow
+
+
+import scorex.crypto.hash.Blake2b256
+import scorex.utils.{Bytes, Ints, Longs}
+import sigma.Header
+import sigma.crypto.{BcDlogGroup, BigIntegers, CryptoConstants}
+import sigma.util.NBitsUtils
+
+/**
+  * Functions used to validate Autolykos2 Proof-of-Work.
+  */
+object Autolykos2PowValidation {
+
+  type Height = Int
+
+  /**
+    * k value for k-sum problem Autolykos is based on (find k numbers in table on N size)
+    */
+  private val k = 32
+
+  /**
+    * Initial size of N  value for k-sum problem Autolykos is based on (find k numbers in table on N size).
+    * It grows from it since predefined block height in Autolykos 2.
+    */
+  private val NStart = 26
+
+  /**
+    * Group order, used in Autolykos V.1 for non-outsourceability,
+    * and also to obtain target in both Autolykos v1 and v2
+    */
+  private val q: BigInt = CryptoConstants.dlogGroup.order
+
+  /**
+    * Number of elements in a table to find k-sum problem solution on top of
+    */
+  val NBase: Int = Math.pow(2, NStart.toDouble).toInt
+
+  /**
+    * Initial height since which table (`N` value) starting to increase by 5% per `IncreasePeriodForN` blocks
+    */
+  val IncreaseStart: Height = 600 * 1024
+
+  /**
+    * Table size (`N`) increased every 50 * 1024 blocks
+    */
+  val IncreasePeriodForN: Height = 50 * 1024
+
+  /**
+    * On this height, the table (`N` value) will stop to grow.
+    * Max N on and after this height would be 2,143,944,600 which is still less than 2^^31.
+    */
+  val NIncreasementHeightMax: Height = 4198400
+
+  /**
+    * Blake2b256 hash function invocation
+    * @param in - input bit-string
+    * @return - 256 bits (32 bytes) array
+    */
+  def hash(in: Array[Byte]): Array[Byte] = Blake2b256.hash(in)
+
+  /**
+    * Convert byte array to unsigned integer
+    * @param in - byte array
+    * @return - unsigned integer
+    */
+  def toBigInt(in: Array[Byte]): BigInt = BigInt(BigIntegers.fromUnsignedByteArray(in))
+
+  /**
+    * Constant data to be added to hash function to increase its calculation time
+    */
+  val M: Array[Byte] = (0 until 1024).toArray.flatMap(i => Longs.toByteArray(i.toLong))
+
+  /**
+    * Calculates table size (N value) for a given height (moment of time)
+    *
+    * @see papers/yellow/pow/ErgoPow.tex for full description and test vectors
+    * @param headerHeight - height of a header to mine
+    * @return - N value
+    */
+  def calcN(headerHeight: Height): Int = {
+    val height = Math.min(NIncreasementHeightMax, headerHeight)
+    if (height < IncreaseStart) {
+      NBase
+    } else {
+      val itersNumber = (height - IncreaseStart) / IncreasePeriodForN + 1
+      (1 to itersNumber).foldLeft(NBase) { case (step, _) =>
+        step / 100 * 105
+      }
+    }
+  }
+
+  def calcN(header: Header): Int = calcN(header.height)
+
+  /**
+    * Hash function that takes `m` and `nonceBytes` and returns a list of size `k` with numbers in
+    * [0,`N`)
+    */
+  private def genIndexes(k: Int, seed: Array[Byte], N: Int): Seq[Int] = {
+    val hash = Blake2b256(seed)
+    val extendedHash = Bytes.concat(hash, hash.take(3))
+    (0 until k).map { i =>
+      BigInt(1, extendedHash.slice(i, i + 4)).mod(N).toInt
+    }
+  }.ensuring(_.length == k)
+
+  /**
+    * Generate element of Autolykos equation.
+    */
+  private def genElementV2(indexBytes: Array[Byte], heightBytes: => Array[Byte]): BigInt = {
+    // Autolykos v. 2: H(j|h|M) (line 5 from the Algo 2 of the spec)
+    toBigInt(hash(Bytes.concat(indexBytes, heightBytes, M)).drop(1))
+  }
+
+  def hitForVersion2ForMessage(k: Int, msg: Array[Byte], nonce: Array[Byte], h: Array[Byte], N: Int): BigInt = {
+
+    val prei8 = BigIntegers.fromUnsignedByteArray(hash(Bytes.concat(msg, nonce)).takeRight(8))
+    val i = BigIntegers.asUnsignedByteArray(4, prei8.mod(BigInt(N).underlying()))
+    val f = Blake2b256(Bytes.concat(i, h, M)).drop(1) // .drop(1) is the same as takeRight(31)
+    val seed = Bytes.concat(f, msg, nonce) // Autolykos v1, Alg. 2, line4:
+
+    val indexes = genIndexes(k, seed, N)
+    //pk and w not used in v2
+    val elems = indexes.map(idx => genElementV2(Ints.toByteArray(idx), h))
+    val f2 = elems.sum
+
+    // sum as byte array is always about 32 bytes
+    val array: Array[Byte] = BigIntegers.asUnsignedByteArray(32, f2.underlying())
+    val ha = hash(array)
+    toBigInt(ha)
+  }
+
+  /**
+    * Header digest ("message" for default GPU miners) a miner is working on
+    */
+  def msgByHeader(h: Header): Array[Byte] = Blake2b256(h.serializeWithoutPoW.toArray)
+
+  /**
+    * Get hit for Autolykos v2 header (to test it then against PoW target)
+    *
+    * @param header - header to check PoW for
+    * @return PoW hit
+    */
+  def hitForVersion2(header: Header): BigInt = {
+
+    val msg = msgByHeader(header)
+    val nonce = header.powNonce
+
+    val h = Ints.toByteArray(header.height)  // used in AL v.2 only
+
+    val N = calcN(header)
+
+    hitForVersion2ForMessage(k, msg, nonce.toArray, h, N)
+  }
+
+  /**
+    * Get target `b` from encoded difficulty `nBits`
+    */
+  def getB(nBits: Long): BigInt = {
+    q / NBitsUtils.decodeCompactBits(nBits)
+  }
+
+  /**
+    * Check PoW for Autolykos v2 header
+    *
+    * @param header - header to check PoW for
+    * @return whether PoW is valid or not
+    */
+  def checkPoWForVersion2(header: Header): Boolean = {
+    val b = getB(header.nBits)
+    // for version 2, we're calculating hit and compare it with target
+    val hit = hitForVersion2(header)
+    hit < b
+  }
+
+}
diff --git a/data/shared/src/main/scala/sigma/serialization/DataSerializer.scala b/data/shared/src/main/scala/sigma/serialization/DataSerializer.scala
index 5f554e96a1..92a54f9aa4 100644
--- a/data/shared/src/main/scala/sigma/serialization/DataSerializer.scala
+++ b/data/shared/src/main/scala/sigma/serialization/DataSerializer.scala
@@ -1,8 +1,9 @@
 package sigma.serialization
 
-import org.ergoplatform.ErgoBox
+import org.ergoplatform.{ErgoBox, ErgoHeader}
+import sigma.VersionContext
 import sigma.ast._
-import sigma.data.CBox
+import sigma.data.{CBox, CHeader}
 
 /** This works in tandem with ConstantSerializer, if you change one make sure to check the other.*/
 object DataSerializer extends CoreDataSerializer {
@@ -15,6 +16,9 @@ object DataSerializer extends CoreDataSerializer {
     case SBox =>
       val b = v.asInstanceOf[CBox]
       ErgoBox.sigmaSerializer.serialize(b.ebox, w.asInstanceOf[SigmaByteWriter])
+    case SHeader if VersionContext.current.isV6SoftForkActivated =>
+      val h = v.asInstanceOf[CHeader]
+      ErgoHeader.sigmaSerializer.serialize(h.ergoHeader, w.asInstanceOf[SigmaByteWriter])
     case _ =>
       super.serialize(v, tpe, w)
   }
@@ -32,6 +36,12 @@ object DataSerializer extends CoreDataSerializer {
         val res = CBox(ErgoBox.sigmaSerializer.parse(r.asInstanceOf[SigmaByteReader]))
         r.level = r.level - 1
         res
+      case SHeader if VersionContext.current.isV6SoftForkActivated =>
+        val depth = r.level
+        r.level = depth + 1
+        val res = new CHeader(ErgoHeader.sigmaSerializer.parse(r.asInstanceOf[SigmaByteReader]))
+        r.level = r.level - 1
+        res
       case t =>
         super.deserialize(t, r)
     }).asInstanceOf[T#WrappedType]
diff --git a/docs/LangSpec.md b/docs/LangSpec.md
index ba66748f08..1f05a3b403 100644
--- a/docs/LangSpec.md
+++ b/docs/LangSpec.md
@@ -249,6 +249,10 @@ class Context {
 
 /** Represents data of the block headers available in scripts. */
 class Header {  
+
+  /** Validate header's proof-of-work */  
+  def checkPow: Boolean
+  
   /** Bytes representation of ModifierId of this Header */
   def id: Coll[Byte]
 
diff --git a/interpreter/shared/src/main/scala/sigmastate/eval/CHeader.scala b/interpreter/shared/src/main/scala/sigmastate/eval/CHeader.scala
deleted file mode 100644
index 7062fa0f0e..0000000000
--- a/interpreter/shared/src/main/scala/sigmastate/eval/CHeader.scala
+++ /dev/null
@@ -1,34 +0,0 @@
-package sigmastate.eval
-
-import sigma.data.SigmaConstants
-import sigma.{AvlTree, BigInt, Coll, GroupElement, Header}
-
-/** A default implementation of [[Header]] interface.
-  *
-  * @see [[Header]] for detailed descriptions
-  */
-case class CHeader(
-    id: Coll[Byte],
-    version: Byte,
-    parentId: Coll[Byte],
-    ADProofsRoot: Coll[Byte],
-    stateRoot: AvlTree,
-    transactionsRoot: Coll[Byte],
-    timestamp: Long,
-    nBits: Long,
-    height: Int,
-    extensionRoot: Coll[Byte],
-    minerPk: GroupElement,
-    powOnetimePk: GroupElement,
-    powNonce: Coll[Byte],
-    powDistance: BigInt,
-    votes: Coll[Byte]
-) extends Header
-
-object CHeader {
-  /** Size of of Header.votes array. */
-  val VotesSize: Int = SigmaConstants.VotesArraySize.value
-
-  /** Size of nonce array from Autolykos POW solution in Header.powNonce array. */
-  val NonceSize: Int = SigmaConstants.AutolykosPowSolutionNonceArraySize.value
-}
\ No newline at end of file
diff --git a/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala b/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala
index de8aa6b620..a72510f641 100644
--- a/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala
+++ b/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala
@@ -5,15 +5,17 @@ import sigma.ast._
 import sigma.ast.syntax._
 import sigmastate.eval.{CAvlTreeVerifier, CProfiler}
 import sigmastate.interpreter.Interpreter.ReductionResult
-import sigma.{AvlTree, Coll, Colls, Context, VersionContext}
+import sigma.{AvlTree, Coll, Colls, Context, Header, VersionContext}
 import sigma.util.Extensions._
 import debox.{cfor, Buffer => DBuffer}
 import scorex.crypto.authds.ADKey
 import sigma.ast.SAvlTreeMethods._
+import sigma.ast.SHeaderMethods.checkPowMethod
 import sigma.ast.SType
 import sigma.data.{CSigmaProp, KeyValueColl, SigmaBoolean}
 import sigma.eval.{AvlTreeVerifier, ErgoTreeEvaluator, EvalSettings, Profiler}
 import sigma.eval.ErgoTreeEvaluator.DataEnv
+import sigmastate.interpreter.CErgoTreeEvaluator.fixedCostOp
 
 import scala.collection.compat.immutable.ArraySeq
 import scala.util.{DynamicVariable, Failure, Success}
@@ -449,7 +451,7 @@ object CErgoTreeEvaluator {
     * HOTSPOT: don't beautify the code
     * Note, `null` is used instead of Option to avoid allocations.
     */
-  def fixedCostOp[R <: AnyRef](costInfo: OperationCostInfo[FixedCost])
+  def fixedCostOp[R](costInfo: OperationCostInfo[FixedCost])
                               (block: => R)(implicit E: ErgoTreeEvaluator): R = {
     if (E != null) {
       var res: R = null.asInstanceOf[R]
diff --git a/interpreter/shared/src/test/scala/sigma/serialization/ConstantSerializerSpecification.scala b/interpreter/shared/src/test/scala/sigma/serialization/ConstantSerializerSpecification.scala
index 43e9cf9e5d..c9478c8356 100644
--- a/interpreter/shared/src/test/scala/sigma/serialization/ConstantSerializerSpecification.scala
+++ b/interpreter/shared/src/test/scala/sigma/serialization/ConstantSerializerSpecification.scala
@@ -9,7 +9,7 @@ import sigma.ast.{BigIntConstant, ByteArrayConstant, Constant, DeserializationSi
 import sigmastate.eval._
 import sigma.Extensions.ArrayOps
 import sigma.ast._
-import sigma.{AvlTree, Colls, Evaluation}
+import sigma.{AvlTree, Colls, Evaluation, Header, VersionContext}
 import sigma.ast.SType.AnyOps
 import scorex.util.encode.Base16
 import sigma.ast.BoolArrayConstant.BoolArrayTypeCode
@@ -17,6 +17,7 @@ import sigma.ast.ByteArrayConstant.ByteArrayTypeCode
 import sigma.ast.syntax.{BoolValue, SValue}
 import sigma.crypto.EcPointType
 import sigma.util.Extensions.{BigIntegerOps, EcpOps, SigmaBooleanOps}
+
 import scala.annotation.nowarn
 
 class ConstantSerializerSpecification extends TableSerializationSpecification {
@@ -25,22 +26,29 @@ class ConstantSerializerSpecification extends TableSerializationSpecification {
     implicit val wWrapped = wrappedTypeGen(tpe)
     implicit val tT = Evaluation.stypeToRType(tpe)
     implicit val tag = tT.classTag
+
+    val withVersion = if (tpe == SHeader) {
+      Some(VersionContext.V6SoftForkVersion)
+    } else {
+      None
+    }
+
     forAll { xs: Array[T#WrappedType] =>
       implicit val tAny = sigma.AnyType
-      roundTripTest(Constant[SCollection[T]](xs.toColl, SCollection(tpe)))
-      roundTripTest(Constant[SType](xs.toColl.map(x => (x, x)).asWrappedType, SCollection(STuple(tpe, tpe)))) // pairs are special case
+      roundTripTest(Constant[SCollection[T]](xs.toColl, SCollection(tpe)), withVersion)
+      roundTripTest(Constant[SType](xs.toColl.map(x => (x, x)).asWrappedType, SCollection(STuple(tpe, tpe))), withVersion) // pairs are special case
       val triples = xs.toColl.map(x => TupleColl(x, x, x)).asWrappedType
-      roundTripTest(Constant[SType](triples, SCollection(STuple(tpe, tpe, tpe))))
+      roundTripTest(Constant[SType](triples, SCollection(STuple(tpe, tpe, tpe))), withVersion)
       val quartets = xs.toColl.map(x => TupleColl(x, x, x, x)).asWrappedType
-      roundTripTest(Constant[SType](quartets, SCollection(STuple(tpe, tpe, tpe, tpe))))
-      roundTripTest(Constant[SCollection[SCollection[T]]](xs.toColl.map(x => Colls.fromItems(x, x)), SCollection(SCollection(tpe))))
+      roundTripTest(Constant[SType](quartets, SCollection(STuple(tpe, tpe, tpe, tpe))), withVersion)
+      roundTripTest(Constant[SCollection[SCollection[T]]](xs.toColl.map(x => Colls.fromItems(x, x)), SCollection(SCollection(tpe))), withVersion)
       roundTripTest(Constant[SType](
         xs.toColl.map { x =>
           val arr = Colls.fromItems(x, x)
           (arr, arr)
         }.asWrappedType,
         SCollection(STuple(SCollection(tpe), SCollection(tpe)))
-      ))
+      ), withVersion)
     }
   }
 
@@ -49,14 +57,19 @@ class ConstantSerializerSpecification extends TableSerializationSpecification {
     implicit val tT = Evaluation.stypeToRType(tpe)
     @nowarn implicit val tag = tT.classTag
     implicit val tAny: RType[Any] = sigma.AnyType
+    val withVersion = if (tpe == SHeader) {
+      Some(VersionContext.V6SoftForkVersion)
+    } else {
+      None
+    }
     forAll { in: (T#WrappedType, T#WrappedType) =>
       val (x,y) = (in._1, in._2)
-      roundTripTest(Constant[SType]((x, y).asWrappedType, STuple(tpe, tpe)))
-      roundTripTest(Constant[SType](TupleColl(x, y, x).asWrappedType, STuple(tpe, tpe, tpe)))
-      roundTripTest(Constant[SType](TupleColl(x, y, x, y).asWrappedType, STuple(tpe, tpe, tpe, tpe)))
-      roundTripTest(Constant[STuple](Colls.fromItems[Any](x, y, (x, y)), STuple(tpe, tpe, STuple(tpe, tpe))))
-      roundTripTest(Constant[STuple](Colls.fromItems[Any](x, y, TupleColl(x, y, x)), STuple(tpe, tpe, STuple(tpe, tpe, tpe))))
-      roundTripTest(Constant[STuple](Colls.fromItems[Any](x, y, TupleColl(x, y, (x, y))), STuple(tpe, tpe, STuple(tpe, tpe, STuple(tpe, tpe)))))
+      roundTripTest(Constant[SType]((x, y).asWrappedType, STuple(tpe, tpe)), withVersion)
+      roundTripTest(Constant[SType](TupleColl(x, y, x).asWrappedType, STuple(tpe, tpe, tpe)), withVersion)
+      roundTripTest(Constant[SType](TupleColl(x, y, x, y).asWrappedType, STuple(tpe, tpe, tpe, tpe)), withVersion)
+      roundTripTest(Constant[STuple](Colls.fromItems[Any](x, y, (x, y)), STuple(tpe, tpe, STuple(tpe, tpe))), withVersion)
+      roundTripTest(Constant[STuple](Colls.fromItems[Any](x, y, TupleColl(x, y, x)), STuple(tpe, tpe, STuple(tpe, tpe, tpe))), withVersion)
+      roundTripTest(Constant[STuple](Colls.fromItems[Any](x, y, TupleColl(x, y, (x, y))), STuple(tpe, tpe, STuple(tpe, tpe, STuple(tpe, tpe)))), withVersion)
     }
   }
 
@@ -71,6 +84,7 @@ class ConstantSerializerSpecification extends TableSerializationSpecification {
     forAll { x: SigmaBoolean => roundTripTest(Constant[SSigmaProp.type](x.toSigmaProp, SSigmaProp)) }
     forAll { x: ErgoBox => roundTripTest(Constant[SBox.type](x, SBox)) }
     forAll { x: AvlTree => roundTripTest(Constant[SAvlTree.type](x, SAvlTree)) }
+    forAll { x: Header => roundTripTest(Constant[SHeader.type](x, SHeader), Some(VersionContext.V6SoftForkVersion)) }
     forAll { x: Array[Byte] => roundTripTest(Constant[SByteArray](x.toColl, SByteArray)) }
     forAll { t: SPredefType => testCollection(t) }
     forAll { t: SPredefType => testTuples(t) }
@@ -88,6 +102,7 @@ class ConstantSerializerSpecification extends TableSerializationSpecification {
     testCollection(SUnit)
     testCollection(SBox)
     testCollection(SAvlTree)
+    testCollection(SHeader)
   }
 
   private def caseObjectValue(v: SValue) = (v, Array[Byte](v.opCode))
diff --git a/interpreter/shared/src/test/scala/sigma/serialization/DataSerializerSpecification.scala b/interpreter/shared/src/test/scala/sigma/serialization/DataSerializerSpecification.scala
index 2d9da3a87e..fe6f62dbe0 100644
--- a/interpreter/shared/src/test/scala/sigma/serialization/DataSerializerSpecification.scala
+++ b/interpreter/shared/src/test/scala/sigma/serialization/DataSerializerSpecification.scala
@@ -3,10 +3,10 @@ package sigma.serialization
 import java.math.BigInteger
 import org.ergoplatform.ErgoBox
 import org.scalacheck.Arbitrary._
-import sigma.data.{DataValueComparer, OptionType, RType, SigmaBoolean, TupleColl}
+import sigma.data.{CBigInt, CHeader, DataValueComparer, OptionType, RType, SigmaBoolean, TupleColl}
 import sigma.ast.SCollection.SByteArray
 import sigmastate.eval._
-import sigma.{AvlTree, Colls, Evaluation, VersionContext}
+import sigma.{AvlTree, Colls, Evaluation, Header, VersionContext}
 import sigma.ast.SType.AnyOps
 import sigma.ast._
 import org.scalacheck.Gen
@@ -23,29 +23,41 @@ import scala.reflect.ClassTag
 
 class DataSerializerSpecification extends SerializationSpecification {
 
-  def roundtrip[T <: SType](obj: T#WrappedType, tpe: T) = {
-    val w = SigmaSerializer.startWriter()
-    DataSerializer.serialize(obj, tpe, w)
-    val bytes = w.toBytes
-    val r = SigmaSerializer.startReader(bytes)
-    val res = DataSerializer.deserialize(tpe, r)
-    res shouldBe obj
-
-    val es = CErgoTreeEvaluator.DefaultEvalSettings
-    val accumulator = new CostAccumulator(
-      initialCost = JitCost(0),
-      costLimit = Some(JitCost.fromBlockCost(es.scriptCostLimitInEvaluator)))
-    val evaluator = new CErgoTreeEvaluator(
-      context = null,
-      constants = ErgoTree.EmptyConstants,
-      coster = accumulator, DefaultProfiler, es)
-    val ok = DataValueComparer.equalDataValues(res, obj)(evaluator)
-    ok shouldBe true
-
-    val randomPrefix = arrayGen[Byte].sample.get
-    val r2 = SigmaSerializer.startReader(randomPrefix ++ bytes, randomPrefix.length)
-    val res2 = DataSerializer.deserialize(tpe, r2)
-    res2 shouldBe obj
+  def roundtrip[T <: SType](obj: T#WrappedType, tpe: T, withVersion: Option[Byte] = None) = {
+
+    def test() = {
+      val w = SigmaSerializer.startWriter()
+      DataSerializer.serialize(obj, tpe, w)
+      val bytes = w.toBytes
+      val r = SigmaSerializer.startReader(bytes)
+      val res = DataSerializer.deserialize(tpe, r)
+      res shouldBe obj
+
+      val es = CErgoTreeEvaluator.DefaultEvalSettings
+      val accumulator = new CostAccumulator(
+        initialCost = JitCost(0),
+        costLimit = Some(JitCost.fromBlockCost(es.scriptCostLimitInEvaluator)))
+      val evaluator = new CErgoTreeEvaluator(
+        context = null,
+        constants = ErgoTree.EmptyConstants,
+        coster = accumulator, DefaultProfiler, es)
+      val ok = DataValueComparer.equalDataValues(res, obj)(evaluator)
+      ok shouldBe true
+
+      val randomPrefix = arrayGen[Byte].sample.get
+      val r2 = SigmaSerializer.startReader(randomPrefix ++ bytes, randomPrefix.length)
+      val res2 = DataSerializer.deserialize(tpe, r2)
+      res2 shouldBe obj
+    }
+
+    withVersion match {
+      case Some(ver) =>
+        VersionContext.withVersions(ver, 1) {
+          test()
+        }
+      case None =>
+        test()
+    }
   }
 
   def testCollection[T <: SType](tpe: T) = {
@@ -53,25 +65,32 @@ class DataSerializerSpecification extends SerializationSpecification {
     implicit val tT = Evaluation.stypeToRType(tpe)
     implicit val tagT = tT.classTag
     implicit val tAny = sigma.AnyType
+
+    val withVersion = if (tpe == SHeader) {
+      Some(VersionContext.V6SoftForkVersion)
+    } else {
+      None
+    }
     forAll { xs: Array[T#WrappedType] =>
-      roundtrip[SCollection[T]](xs.toColl, SCollection(tpe))
-      roundtrip[SType](xs.toColl.map(x => (x, x)).asWrappedType, SCollection(STuple(tpe, tpe)))
+      roundtrip[SCollection[T]](xs.toColl, SCollection(tpe), withVersion)
+      roundtrip[SType](xs.toColl.map(x => (x, x)).asWrappedType, SCollection(STuple(tpe, tpe)), withVersion)
 
       val triples = xs.toColl.map(x => TupleColl(x, x, x)).asWrappedType
-      roundtrip(triples, SCollection(STuple(tpe, tpe, tpe)))
+      roundtrip(triples, SCollection(STuple(tpe, tpe, tpe)), withVersion)
 
       val quartets = xs.toColl.map(x => TupleColl(x, x, x, x)).asWrappedType
-      roundtrip(quartets, SCollection(STuple(tpe, tpe, tpe, tpe)))
+      roundtrip(quartets, SCollection(STuple(tpe, tpe, tpe, tpe)), withVersion)
 
       val nested = xs.toColl.map(x => Colls.fromItems[T#WrappedType](x, x))
-      roundtrip[SCollection[SCollection[T]]](nested, SCollection(SCollection(tpe)))
+      roundtrip[SCollection[SCollection[T]]](nested, SCollection(SCollection(tpe)), withVersion)
 
       roundtrip[SType](
         xs.toColl.map { x =>
           val arr = Colls.fromItems[T#WrappedType](x, x)
           (arr, arr)
         }.asWrappedType,
-        SCollection(STuple(SCollection(tpe), SCollection(tpe)))
+        SCollection(STuple(SCollection(tpe), SCollection(tpe))),
+        withVersion
       )
     }
   }
@@ -81,14 +100,19 @@ class DataSerializerSpecification extends SerializationSpecification {
     val tT = Evaluation.stypeToRType(tpe)
     @nowarn implicit val tag: ClassTag[T#WrappedType] = tT.classTag
     implicit val tAny       : RType[Any]              = sigma.AnyType
+    val withVersion = if (tpe == SHeader) {
+      Some(VersionContext.V6SoftForkVersion)
+    } else {
+      None
+    }
     forAll { in: (T#WrappedType, T#WrappedType) =>
       val (x,y) = (in._1, in._2)
-      roundtrip[SType]((x, y).asWrappedType, STuple(tpe, tpe))
-      roundtrip[SType](TupleColl(x, y, x).asWrappedType, STuple(tpe, tpe, tpe))
-      roundtrip[SType](TupleColl(x, y, x, y).asWrappedType, STuple(tpe, tpe, tpe, tpe))
-      roundtrip[STuple](Colls.fromItems[Any](x, y, (x, y)), STuple(tpe, tpe, STuple(tpe, tpe)))
-      roundtrip[STuple](Colls.fromItems[Any](x, y, TupleColl(x, y, x)), STuple(tpe, tpe, STuple(tpe, tpe, tpe)))
-      roundtrip[STuple](Colls.fromItems[Any](x, y, TupleColl(x, y, (x, y))), STuple(tpe, tpe, STuple(tpe, tpe, STuple(tpe, tpe))))
+      roundtrip[SType]((x, y).asWrappedType, STuple(tpe, tpe), withVersion)
+      roundtrip[SType](TupleColl(x, y, x).asWrappedType, STuple(tpe, tpe, tpe), withVersion)
+      roundtrip[SType](TupleColl(x, y, x, y).asWrappedType, STuple(tpe, tpe, tpe, tpe), withVersion)
+      roundtrip[STuple](Colls.fromItems[Any](x, y, (x, y)), STuple(tpe, tpe, STuple(tpe, tpe)), withVersion)
+      roundtrip[STuple](Colls.fromItems[Any](x, y, TupleColl(x, y, x)), STuple(tpe, tpe, STuple(tpe, tpe, tpe)), withVersion)
+      roundtrip[STuple](Colls.fromItems[Any](x, y, TupleColl(x, y, (x, y))), STuple(tpe, tpe, STuple(tpe, tpe, STuple(tpe, tpe))), withVersion)
     }
   }
 
@@ -129,6 +153,7 @@ class DataSerializerSpecification extends SerializationSpecification {
     forAll { x: ErgoBox => roundtrip[SBox.type](x, SBox) }
     forAll { x: AvlTree => roundtrip[SAvlTree.type](x, SAvlTree) }
     forAll { x: Array[Byte] => roundtrip[SByteArray](x.toColl, SByteArray) }
+    forAll { x: Header => roundtrip[SHeader.type](x, SHeader, Some(VersionContext.V6SoftForkVersion)) }
     forAll { t: SPredefType => testCollection(t) }
     forAll { t: SPredefType => testTuples(t) }
     forAll { t: SPredefType => testOption(t) }
@@ -159,6 +184,42 @@ class DataSerializerSpecification extends SerializationSpecification {
       t.isInstanceOf[SerializerException] &&
           t.getMessage.contains(s"BigInt value doesn't not fit into ${SBigInt.MaxSizeInBytes} bytes")
     })
+  }
 
+  property("nuanced versioned test for header roundtrip") {
+    VersionContext.withVersions(VersionContext.V6SoftForkVersion, 1) {
+      forAll { x: Header => roundtrip[SHeader.type](x, SHeader) }
+    }
+
+    an[SerializerException] should be thrownBy (
+      VersionContext.withVersions((VersionContext.V6SoftForkVersion - 1).toByte, 1) {
+        val h = headerGen.sample.get
+        roundtrip[SHeader.type](h, SHeader)
+      })
+  }
+
+  property("header vector") {
+    val header = CHeader(
+      0.toByte,
+      Helpers.decodeBytes("7a7fe5347f09017818010062000001807f86808000ff7f66ffb07f7ad27f3362"),
+      Helpers.decodeBytes("c1d70ad9b1ffc1fb9a715fff19807f2401017fcd8b73db017f1cff77727fff08"),
+      Helpers.decodeBytes("54d23dd080006bdb56800100356080935a80ffb77e90b800057f00661601807f17"),
+      Helpers.decodeBytes("5e7f1164ccd0990080c501fc0e0181cb387fc17f00ff00c7d5ff767f91ff5e68"),
+      -7421721754642387858L,
+      -4826493284887861030L,
+      10,
+      Helpers.decodeBytes("e580c88001ff6fc89c5501017f80e001ff0101fe48c153ff7f00666b80d780ab"),
+      Helpers.decodeGroupElement("03e7f2875298fddd933c2e0a38968fe85bdeeb70dd8b389559a1d36e2ff1b58fc5"),
+      Helpers.decodeGroupElement("034e2d3b5f9e409e3ae8a2e768340760362ca33764eda5855f7a43487f14883300"),
+      Helpers.decodeBytes("974651c9efff7f00"),
+      CBigInt(new BigInteger("478e827dfa1e4b57", 16)),
+      Helpers.decodeBytes("01ff13"),
+      Colls.emptyColl
+    )
+
+    VersionContext.withVersions(VersionContext.V6SoftForkVersion, 1) {
+      roundtrip[SHeader.type](header, SHeader)
+    }
   }
+
 }
diff --git a/interpreter/shared/src/test/scala/sigma/serialization/MethodCallSerializerSpecification.scala b/interpreter/shared/src/test/scala/sigma/serialization/MethodCallSerializerSpecification.scala
index 1db166c685..f93f0ccaf7 100644
--- a/interpreter/shared/src/test/scala/sigma/serialization/MethodCallSerializerSpecification.scala
+++ b/interpreter/shared/src/test/scala/sigma/serialization/MethodCallSerializerSpecification.scala
@@ -45,4 +45,27 @@ class MethodCallSerializerSpecification extends SerializationSpecification {
       }
       )
   }
+
+  property("MethodCall deserialization round trip for Header.checkPow") {
+    def code = {
+      val bi = HeaderConstant(headerGen.sample.get)
+      val expr = MethodCall(bi,
+        SHeaderMethods.checkPowMethod,
+        Vector(),
+        Map()
+      )
+      roundTripTest(expr)
+    }
+
+    VersionContext.withVersions(VersionContext.V6SoftForkVersion, 1) {
+      code
+    }
+
+    an[Exception] should be thrownBy (
+      VersionContext.withVersions((VersionContext.V6SoftForkVersion - 1).toByte, 1) {
+        code
+      }
+      )
+  }
+
 }
diff --git a/interpreter/shared/src/test/scala/sigma/serialization/SerializationSpecification.scala b/interpreter/shared/src/test/scala/sigma/serialization/SerializationSpecification.scala
index 30ae6af19b..aa7a8722ba 100644
--- a/interpreter/shared/src/test/scala/sigma/serialization/SerializationSpecification.scala
+++ b/interpreter/shared/src/test/scala/sigma/serialization/SerializationSpecification.scala
@@ -8,6 +8,7 @@ import org.scalacheck.Arbitrary._
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.propspec.AnyPropSpec
 import org.scalatestplus.scalacheck.{ScalaCheckDrivenPropertyChecks, ScalaCheckPropertyChecks}
+import sigma.VersionContext
 import sigma.ast.SType
 import sigma.ast._
 import sigmastate.helpers.NegativeTesting
@@ -26,10 +27,20 @@ trait SerializationSpecification extends AnyPropSpec
   with ValidationSpecification
   with NegativeTesting {
 
-  protected def roundTripTest[V <: Value[_ <: SType]](v: V): Assertion = {
-    val bytes = ValueSerializer.serialize(v)
-    predefinedBytesTest(v, bytes)
-    predefinedBytesTestNotFomZeroElement(bytes, v)
+  protected def roundTripTest[V <: Value[_ <: SType]](v: V, withVersion: Option[Byte] = None): Assertion = {
+    def test() = {
+      val bytes = ValueSerializer.serialize(v)
+      predefinedBytesTest(v, bytes)
+      predefinedBytesTestNotFomZeroElement(bytes, v)
+    }
+    withVersion match {
+      case Some(ver) =>
+        VersionContext.withVersions(ver, 0) {
+          test()
+        }
+      case None =>
+        test()
+    }
   }
 
   protected def predefinedBytesTest[V <: Value[_ <: SType]](v: V, bytes: Array[Byte]): Assertion = {
@@ -41,7 +52,7 @@ trait SerializationSpecification extends AnyPropSpec
     r.positionLimit shouldBe positionLimitBefore
   }
 
-  //check that pos and consumed are being implented correctly
+  //check that pos and consumed are being implemented correctly
   protected def predefinedBytesTestNotFomZeroElement[V <: Value[_ <: SType]](bytes: Array[Byte], v: V): Assertion = {
     val randomInt = Gen.chooseNum(1, 20).sample.get
     val randomBytes = Gen.listOfN(randomInt, arbByte.arbitrary).sample.get.toArray
diff --git a/interpreter/shared/src/test/scala/sigma/serialization/generators/ObjectGenerators.scala b/interpreter/shared/src/test/scala/sigma/serialization/generators/ObjectGenerators.scala
index d4971f88c2..c9fc8f2c93 100644
--- a/interpreter/shared/src/test/scala/sigma/serialization/generators/ObjectGenerators.scala
+++ b/interpreter/shared/src/test/scala/sigma/serialization/generators/ObjectGenerators.scala
@@ -8,7 +8,6 @@ import org.scalacheck.Arbitrary._
 import org.scalacheck.Gen.{choose, frequency}
 import org.scalacheck.util.Buildable
 import org.scalacheck.{Arbitrary, Gen}
-import sigma.data._
 import scorex.crypto.authds.{ADDigest, ADKey}
 import scorex.util.encode.{Base58, Base64}
 import scorex.util.{ModifierId, bytesToId}
@@ -27,6 +26,7 @@ import sigma.util.Extensions.EcpOps
 import sigma.validation.{ChangedRule, DisabledRule, EnabledRule, ReplacedRule, RuleStatus}
 import sigma.validation.ValidationRules.FirstRuleId
 import ErgoTree.ZeroHeader
+import sigma.data.{AvlTreeData, AvlTreeFlags, CAND, CBox, COR, CTHRESHOLD, Digest32Coll, ProveDHTuple, ProveDlog, RType, SigmaBoolean}
 import sigma.eval.Extensions.{EvalIterableOps, SigmaBooleanOps}
 import sigma.eval.SigmaDsl
 import sigma.interpreter.{ContextExtension, ProverResult}
@@ -311,6 +311,7 @@ trait ObjectGenerators extends TypeGenerators
     case SAvlTree => arbAvlTree
     case SAny => arbAnyVal
     case SUnit => arbUnit
+    case SHeader => arbHeader
     case opt: SOption[a] =>
       Arbitrary(frequency((5, None), (5, for (x <- wrappedTypeGen(opt.elemType)) yield Some(x))))
   }).asInstanceOf[Arbitrary[T#WrappedType]].arbitrary
@@ -694,7 +695,6 @@ trait ObjectGenerators extends TypeGenerators
   } yield ErgoTree.withSegregation(ZeroHeader, prop)
 
   def headerGen(stateRoot: AvlTree, parentId: Coll[Byte]): Gen[Header] = for {
-    id <- modifierIdBytesGen
     version <- arbByte.arbitrary
     adProofsRoot <- digest32Gen
     transactionRoot <- digest32Gen
@@ -707,8 +707,10 @@ trait ObjectGenerators extends TypeGenerators
     powNonce <- nonceBytesGen
     powDistance <- arbBigInt.arbitrary
     votes <- minerVotesGen
-  } yield CHeader(id, version, parentId, adProofsRoot, stateRoot, transactionRoot, timestamp, nBits,
-    height, extensionRoot, minerPk.toGroupElement, powOnetimePk.toGroupElement, powNonce, powDistance, votes)
+    unparsedBytes <- collOfRange(0, 32, arbByte.arbitrary)
+  } yield CHeader(version, parentId, adProofsRoot, stateRoot.digest, transactionRoot, timestamp, nBits,
+    height, extensionRoot, minerPk.toGroupElement, powOnetimePk.toGroupElement, powNonce, powDistance, votes,
+    if(version > HeaderVersion.Interpreter60Version){ unparsedBytes } else {Colls.emptyColl[Byte]})
 
   lazy val headerGen: Gen[Header] = for {
     stateRoot <- avlTreeGen
diff --git a/interpreter/shared/src/test/scala/sigma/serialization/generators/TypeGenerators.scala b/interpreter/shared/src/test/scala/sigma/serialization/generators/TypeGenerators.scala
index 81073c4849..70a215e831 100644
--- a/interpreter/shared/src/test/scala/sigma/serialization/generators/TypeGenerators.scala
+++ b/interpreter/shared/src/test/scala/sigma/serialization/generators/TypeGenerators.scala
@@ -16,12 +16,13 @@ trait TypeGenerators {
   implicit val boxTypeGen: Gen[SBox.type] = Gen.const(SBox)
   implicit val avlTreeTypeGen: Gen[SAvlTree.type] = Gen.const(SAvlTree)
   implicit val optionSigmaPropTypeGen: Gen[SOption[SSigmaProp.type]] = Gen.const(SOption(SSigmaProp))
+  implicit val headerTypeGen: Gen[SHeader.type] = Gen.const(SHeader)
 
   implicit val primTypeGen: Gen[SPrimType] =
     Gen.oneOf[SPrimType](SBoolean, SByte, SShort, SInt, SLong, SBigInt, SGroupElement, SSigmaProp, SUnit)
   implicit val arbPrimType: Arbitrary[SPrimType] = Arbitrary(primTypeGen)
   implicit val predefTypeGen: Gen[SPredefType] =
-    Gen.oneOf[SPredefType](SBoolean, SByte, SShort, SInt, SLong, SBigInt, SGroupElement, SSigmaProp, SUnit, SBox, SAvlTree)
+    Gen.oneOf[SPredefType](SBoolean, SByte, SShort, SInt, SLong, SBigInt, SGroupElement, SSigmaProp, SUnit, SBox, SAvlTree, SHeader)
   implicit val arbPredefType: Arbitrary[SPredefType] = Arbitrary(predefTypeGen)
 
   implicit def genToArbitrary[T: Gen]: Arbitrary[T] = Arbitrary(implicitly[Gen[T]])
diff --git a/interpreter/shared/src/test/scala/special/sigma/SigmaTestingData.scala b/interpreter/shared/src/test/scala/special/sigma/SigmaTestingData.scala
index f113a484ef..b8bf76cacf 100644
--- a/interpreter/shared/src/test/scala/special/sigma/SigmaTestingData.scala
+++ b/interpreter/shared/src/test/scala/special/sigma/SigmaTestingData.scala
@@ -12,7 +12,7 @@ import scorex.crypto.hash.{Blake2b256, Digest32}
 import scorex.util.ModifierId
 import sigma.ast._
 import sigma.Extensions.ArrayOps
-import sigmastate.eval.{CHeader, CPreHeader}
+import sigmastate.eval.CPreHeader
 import sigmastate.helpers.TestingCommons
 import sigma.serialization.ErgoTreeSerializer
 import sigma.serialization.generators.ObjectGenerators
@@ -240,17 +240,16 @@ trait SigmaTestingData extends TestingCommons with ObjectGenerators {
 
     def createAvlTreeData() = AvlTreeData(
       ErgoAlgos.decodeUnsafe("010180017f7f7b7f720c00007f7f7f0f01e857a626f37f1483d06af8077a008080").toColl,
-      AvlTreeFlags(false, true, false),
-      728138553,
-      Some(2147483647)
+      AvlTreeFlags(true, true, true),
+      32,
+      None
     )
 
     val h1_instances = new CloneSet(1000, CHeader(
-      Helpers.decodeBytes("957f008001808080ffe4ffffc8f3802401df40006aa05e017fa8d3f6004c804a"),
       0.toByte,
       Helpers.decodeBytes("0180dd805b0000ff5400b997fd7f0b9b00de00fb03c47e37806a8186b94f07ff"),
       Helpers.decodeBytes("01f07f60d100ffb970c3007f60ff7f24d4070bb8fffa7fca7f34c10001ffe39d"),
-      CAvlTree(createAvlTreeData()),
+      CAvlTree(createAvlTreeData()).digest,
       Helpers.decodeBytes("804101ff01000080a3ffbd006ac080098df132a7017f00649311ec0e00000100"),
       1L,
       -1L,
@@ -260,14 +259,15 @@ trait SigmaTestingData extends TestingCommons with ObjectGenerators {
       Helpers.decodeGroupElement("0361299207fa392231e23666f6945ae3e867b978e021d8d702872bde454e9abe9c"),
       Helpers.decodeBytes("7f4f09012a807f01"),
       CBigInt(new BigInteger("-e24990c47e15ed4d0178c44f1790cc72155d516c43c3e8684e75db3800a288", 16)),
-      Helpers.decodeBytes("7f0180")
+      Helpers.decodeBytes("7f0180"),
+      Colls.emptyColl[Byte]
     ))
 
     def create_h1(): Header = h1_instances.getNext
 
     val h1: Header = create_h1()
 
-    val h2: Header = create_h1().asInstanceOf[CHeader].copy(height = 2)
+    val h2: Header = new CHeader(h1.asInstanceOf[CHeader].wrappedValue.copy(height = 2))
 
     val dlog_instances = new CloneSet(1000, ProveDlog(
       SigmaDsl.toECPoint(create_ge1()).asInstanceOf[EcPointType]
diff --git a/sc/shared/src/main/scala/sigma/compiler/ir/GraphBuilding.scala b/sc/shared/src/main/scala/sigma/compiler/ir/GraphBuilding.scala
index 7c7b80d39a..7485895efb 100644
--- a/sc/shared/src/main/scala/sigma/compiler/ir/GraphBuilding.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/ir/GraphBuilding.scala
@@ -1,6 +1,7 @@
 package sigma.compiler.ir
 
 import org.ergoplatform._
+import sigma.ast.SType.tT
 import sigma.ast.TypeCodes.LastConstantCode
 import sigma.ast.Value.Typed
 import sigma.ast.syntax.{SValue, ValueOps}
@@ -13,7 +14,7 @@ import sigma.data.{CSigmaDslBuilder, ExactIntegral, ExactNumeric, ExactOrdering,
 import sigma.exceptions.GraphBuildingException
 import sigma.serialization.OpCodes
 import sigma.util.Extensions.ByteOps
-import sigma.{SigmaException, ast}
+import sigma.{SigmaException, VersionContext, ast}
 import sigmastate.interpreter.Interpreter.ScriptEnv
 
 import scala.collection.mutable.ArrayBuffer
@@ -928,7 +929,7 @@ trait GraphBuilding extends Base with DefRewriting { IR: IRContext =>
         sigmaDslBuilder.decodePoint(bytes)
 
       // fallback rule for MethodCall, should be the last case in the list
-      case sigma.ast.MethodCall(obj, method, args, _) =>
+      case sigma.ast.MethodCall(obj, method, args, typeSubst) =>
         val objV = eval(obj)
         val argsV = args.map(eval)
         (objV, method.objType) match {
@@ -1017,6 +1018,10 @@ trait GraphBuilding extends Base with DefRewriting { IR: IRContext =>
           case (box: Ref[Box]@unchecked, SBoxMethods) => method.name match {
             case SBoxMethods.tokensMethod.name =>
               box.tokens
+            case SBoxMethods.getRegMethodV6.name if VersionContext.current.isV6SoftForkActivated =>
+              val c1 = asRep[Int](argsV(0))
+              val c2 = stypeToElem(typeSubst.apply(tT))
+              box.getReg(c1)(c2)
             case _ => throwError
           }
           case (ctx: Ref[Context]@unchecked, SContextMethods) => method.name match {
@@ -1137,6 +1142,8 @@ trait GraphBuilding extends Base with DefRewriting { IR: IRContext =>
               h.powDistance
             case SHeaderMethods.votesMethod.name =>
               h.votes
+            case SHeaderMethods.checkPowMethod.name if VersionContext.current.isV6SoftForkActivated =>
+              h.checkPow
             case _ => throwError
           }
           case (g: Ref[SigmaDslBuilder]@unchecked, SGlobalMethods) => method.name match {
diff --git a/sc/shared/src/main/scala/sigma/compiler/ir/GraphIRReflection.scala b/sc/shared/src/main/scala/sigma/compiler/ir/GraphIRReflection.scala
index 69736a0224..d4512e1297 100644
--- a/sc/shared/src/main/scala/sigma/compiler/ir/GraphIRReflection.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/ir/GraphIRReflection.scala
@@ -407,6 +407,9 @@ object GraphIRReflection {
         },
         mkMethod(clazz, "powDistance", Array[Class[_]]()) { (obj, args) =>
           obj.asInstanceOf[ctx.Header].powDistance
+        },
+        mkMethod(clazz, "checkPow", Array[Class[_]]()) { (obj, args) =>
+          obj.asInstanceOf[ctx.Header].checkPow
         }
       )
     )
diff --git a/sc/shared/src/main/scala/sigma/compiler/ir/IRContext.scala b/sc/shared/src/main/scala/sigma/compiler/ir/IRContext.scala
index c60bc0882f..a22962f987 100644
--- a/sc/shared/src/main/scala/sigma/compiler/ir/IRContext.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/ir/IRContext.scala
@@ -153,7 +153,7 @@ trait IRContext
   override def invokeUnlifted(e: Elem[_], mc: MethodCall, dataEnv: DataEnv): Any = e match {
     case _: CollElem[_,_] => mc match {
       case CollMethods.map(_, f) =>
-        val newMC = mc.copy(args = mc.args :+ f.elem.eRange)(mc.resultType, mc.isAdapterCall)
+        val newMC = mc.copy(args = mc.args :+ f.elem.eRange)(mc.resultType, mc.isAdapterCall, mc.typeSubst)
         super.invokeUnlifted(e, newMC, dataEnv)
       case _ =>
         super.invokeUnlifted(e, mc, dataEnv)
diff --git a/sc/shared/src/main/scala/sigma/compiler/ir/MethodCalls.scala b/sc/shared/src/main/scala/sigma/compiler/ir/MethodCalls.scala
index 876f0e9d7e..089b76cae4 100644
--- a/sc/shared/src/main/scala/sigma/compiler/ir/MethodCalls.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/ir/MethodCalls.scala
@@ -1,6 +1,7 @@
 package sigma.compiler.ir
 
 import debox.{cfor, Buffer => DBuffer}
+import sigma.ast.{SType, STypeVar}
 import sigma.compiler.DelayInvokeException
 import sigma.reflection.RMethod
 import sigma.util.CollectionUtil.TraversableOps
@@ -26,7 +27,9 @@ trait MethodCalls extends Base { self: IRContext =>
     *                      given `method`.
     */
   case class MethodCall private[MethodCalls](receiver: Sym, method: RMethod, args: Seq[AnyRef], neverInvoke: Boolean)
-                                            (val resultType: Elem[Any], val isAdapterCall: Boolean = false) extends Def[Any] {
+                                            (val resultType: Elem[Any],
+                                             val isAdapterCall: Boolean = false,
+                                             val typeSubst: Map[STypeVar, SType]) extends Def[Any] {
 
     override def mirror(t: Transformer): Ref[Any] = {
       val len = args.length
@@ -99,9 +102,14 @@ trait MethodCalls extends Base { self: IRContext =>
   }
 
   /** Creates new MethodCall node and returns its node ref. */
-  def mkMethodCall(receiver: Sym, method: RMethod, args: Seq[AnyRef],
-                   neverInvoke: Boolean, isAdapterCall: Boolean, resultElem: Elem[_]): Sym = {
-    reifyObject(MethodCall(receiver, method, args, neverInvoke)(asElem[Any](resultElem), isAdapterCall))
+  def mkMethodCall(receiver: Sym,
+                   method: RMethod,
+                   args: Seq[AnyRef],
+                   neverInvoke: Boolean,
+                   isAdapterCall: Boolean,
+                   resultElem: Elem[_],
+                   typeSubst: Map[STypeVar, SType] = Map.empty): Sym = {
+    reifyObject(MethodCall(receiver, method, args, neverInvoke)(asElem[Any](resultElem), isAdapterCall, typeSubst))
   }
 
   @tailrec
diff --git a/sc/shared/src/main/scala/sigma/compiler/ir/TreeBuilding.scala b/sc/shared/src/main/scala/sigma/compiler/ir/TreeBuilding.scala
index 725e3b1d19..7b73999253 100644
--- a/sc/shared/src/main/scala/sigma/compiler/ir/TreeBuilding.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/ir/TreeBuilding.scala
@@ -290,13 +290,10 @@ trait TreeBuilding extends Base { IR: IRContext =>
         mkExtractAmount(box.asBox)
       case BoxM.propositionBytes(In(box)) =>
         mkExtractScriptBytes(box.asBox)
-      case BoxM.getReg(In(box), regId, _) =>
+      case BoxM.getReg(In(box), regId, _) if regId.isConst =>
         val tpe = elemToSType(s.elem).asOption
-        if (regId.isConst)
-          mkExtractRegisterAs(box.asBox, ErgoBox.allRegisters(valueFromRep(regId)), tpe)
-        else
-          error(s"Non constant expressions (${regId.node}) are not supported in getReg")
-      case BoxM.creationInfo(In(box)) =>
+        mkExtractRegisterAs(box.asBox, ErgoBox.allRegisters(valueFromRep(regId)), tpe)
+     case BoxM.creationInfo(In(box)) =>
         mkExtractCreationInfo(box.asBox)
       case BoxM.id(In(box)) =>
         mkExtractId(box.asBox)
@@ -399,13 +396,14 @@ trait TreeBuilding extends Base { IR: IRContext =>
         mkMultiplyGroup(obj.asGroupElement, arg.asGroupElement)
 
       // Fallback MethodCall rule: should be the last in this list of cases
-      case Def(MethodCall(objSym, m, argSyms, _)) =>
+      case Def(mc @ MethodCall(objSym, m, argSyms, _)) =>
         val obj = recurse[SType](objSym)
         val args = argSyms.collect { case argSym: Sym => recurse[SType](argSym) }
         MethodsContainer.getMethod(obj.tpe, m.getName) match {
           case Some(method) =>
-            val specMethod = method.specializeFor(obj.tpe, args.map(_.tpe))
-            builder.mkMethodCall(obj, specMethod, args.toIndexedSeq, Map())
+            val typeSubst = mc.typeSubst
+            val specMethod = method.specializeFor(obj.tpe, args.map(_.tpe)).withConcreteTypes(typeSubst)
+            builder.mkMethodCall(obj, specMethod, args.toIndexedSeq, typeSubst)
           case None =>
             error(s"Cannot find method ${m.getName} in object $obj")
         }
diff --git a/sc/shared/src/main/scala/sigma/compiler/ir/wrappers/sigma/SigmaDslUnit.scala b/sc/shared/src/main/scala/sigma/compiler/ir/wrappers/sigma/SigmaDslUnit.scala
index 2a6a341686..f38748bbe4 100644
--- a/sc/shared/src/main/scala/sigma/compiler/ir/wrappers/sigma/SigmaDslUnit.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/ir/wrappers/sigma/SigmaDslUnit.scala
@@ -78,6 +78,7 @@ import scalan._
       def powNonce: Ref[Coll[Byte]];
       def powDistance: Ref[BigInt];
       def votes: Ref[Coll[Byte]]
+      def checkPow: Ref[Boolean]
     };
     trait Context extends Def[Context] {
       def OUTPUTS: Ref[Coll[Box]];
diff --git a/sc/shared/src/main/scala/sigma/compiler/ir/wrappers/sigma/impl/SigmaDslImpl.scala b/sc/shared/src/main/scala/sigma/compiler/ir/wrappers/sigma/impl/SigmaDslImpl.scala
index c113cb7de3..5c366d5b7c 100644
--- a/sc/shared/src/main/scala/sigma/compiler/ir/wrappers/sigma/impl/SigmaDslImpl.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/ir/wrappers/sigma/impl/SigmaDslImpl.scala
@@ -8,6 +8,8 @@ import sigma.compiler.ir.wrappers.sigma.impl.SigmaDslDefs
 import scala.collection.compat.immutable.ArraySeq
 
 package impl {
+  import sigma.Evaluation
+  import sigma.ast.SType.tT
   import sigma.compiler.ir.meta.ModuleInfo
   import sigma.compiler.ir.wrappers.sigma.SigmaDsl
   import sigma.compiler.ir.{Base, GraphIRReflection, IRContext}
@@ -620,10 +622,11 @@ object Box extends EntityObject("Box") {
     }
 
     override def getReg[T](i: Ref[Int])(implicit cT: Elem[T]): Ref[WOption[T]] = {
+      val st = Evaluation.rtypeToSType(cT.sourceType)
       asRep[WOption[T]](mkMethodCall(self,
         BoxClass.getMethod("getReg", classOf[Sym], classOf[Elem[_]]),
         Array[AnyRef](i, cT),
-        true, false, element[WOption[T]]))
+        true, false, element[WOption[T]], Map(tT -> st) ))
     }
 
     override def tokens: Ref[Coll[(Coll[Byte], Long)]] = {
@@ -695,10 +698,11 @@ object Box extends EntityObject("Box") {
     }
 
     def getReg[T](i: Ref[Int])(implicit cT: Elem[T]): Ref[WOption[T]] = {
+      val st = Evaluation.rtypeToSType(cT.sourceType)
       asRep[WOption[T]](mkMethodCall(source,
         BoxClass.getMethod("getReg", classOf[Sym], classOf[Elem[_]]),
         Array[AnyRef](i, cT),
-        true, true, element[WOption[T]]))
+        true, true, element[WOption[T]], Map(tT -> st)))
     }
 
     def tokens: Ref[Coll[(Coll[Byte], Long)]] = {
@@ -1368,6 +1372,13 @@ object Header extends EntityObject("Header") {
         ArraySeq.empty,
         true, false, element[Coll[Byte]]))
     }
+
+    override def checkPow: Ref[Boolean] = {
+      asRep[Boolean](mkMethodCall(self,
+        HeaderClass.getMethod("checkPow"),
+        ArraySeq.empty,
+        true, false, element[Boolean]))
+    }
   }
 
   implicit object LiftableHeader
@@ -1492,6 +1503,13 @@ object Header extends EntityObject("Header") {
         ArraySeq.empty,
         true, true, element[Coll[Byte]]))
     }
+
+    def checkPow: Ref[Boolean] = {
+      asRep[Boolean](mkMethodCall(source,
+        HeaderClass.getMethod("checkPow"),
+        ArraySeq.empty,
+        true, true, element[Boolean]))
+    }
   }
 
   // entityUnref: single unref method for each type family
@@ -1509,7 +1527,7 @@ object Header extends EntityObject("Header") {
     override protected def collectMethods: Map[RMethod, MethodDesc] = {
       super.collectMethods ++
         Elem.declaredMethods(RClass(classOf[Header]), RClass(classOf[SHeader]), Set(
-        "id", "version", "parentId", "ADProofsRoot", "stateRoot", "transactionsRoot", "timestamp", "nBits", "height", "extensionRoot", "minerPk", "powOnetimePk", "powNonce", "powDistance", "votes"
+        "id", "version", "parentId", "ADProofsRoot", "stateRoot", "transactionsRoot", "timestamp", "nBits", "height", "extensionRoot", "minerPk", "powOnetimePk", "powNonce", "powDistance", "votes", "checkPow"
         ))
     }
   }
diff --git a/sc/shared/src/main/scala/sigma/compiler/phases/SigmaTyper.scala b/sc/shared/src/main/scala/sigma/compiler/phases/SigmaTyper.scala
index ac30a6cd0a..5f5e430e47 100644
--- a/sc/shared/src/main/scala/sigma/compiler/phases/SigmaTyper.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/phases/SigmaTyper.scala
@@ -136,7 +136,7 @@ class SigmaTyper(val builder: SigmaBuilder,
     case Apply(ApplyTypes(sel @ Select(obj, n, _), Seq(rangeTpe)), args) =>
       val newObj = assignType(env, obj)
       val newArgs = args.map(assignType(env, _))
-      obj.tpe match {
+      newObj.tpe match {
         case p: SProduct =>
           MethodsContainer.getMethod(p, n) match {
             case Some(method: SMethod) =>
@@ -160,10 +160,10 @@ class SigmaTyper(val builder: SigmaBuilder,
             case Some(method) =>
               error(s"Don't know how to handle method $method in obj $p", sel.sourceContext)
             case None =>
-              throw new MethodNotFound(s"Cannot find method '$n' in in the object $obj of Product type $p", obj.sourceContext.toOption)
+              throw new MethodNotFound(s"Cannot find method '$n' in in the object $newObj of Product type $p", newObj.sourceContext.toOption)
           }
         case _ =>
-          error(s"Cannot get field '$n' in in the object $obj of non-product type ${obj.tpe}", sel.sourceContext)
+          error(s"Cannot get field '$n' in in the object $newObj of non-product type ${newObj.tpe}", sel.sourceContext)
       }
 
     case app @ Apply(sel @ Select(obj, n, _), args) =>
diff --git a/sc/shared/src/test/scala/sigma/LanguageSpecificationV5.scala b/sc/shared/src/test/scala/sigma/LanguageSpecificationV5.scala
index af4f93d861..0d9a032a16 100644
--- a/sc/shared/src/test/scala/sigma/LanguageSpecificationV5.scala
+++ b/sc/shared/src/test/scala/sigma/LanguageSpecificationV5.scala
@@ -4292,7 +4292,7 @@ class LanguageSpecificationV5 extends LanguageSpecificationBase { suite =>
   property("Header properties equivalence") {
     verifyCases(
       Seq((h1, Expected(Success(
-        Helpers.decodeBytes("957f008001808080ffe4ffffc8f3802401df40006aa05e017fa8d3f6004c804a")),
+        Helpers.decodeBytes("cea31f0e0a794b103f65f8296a22ac8ff214e1bc75442186b90df4844c978e81")),
         cost = 1766, methodCostDetails(SHeaderMethods.idMethod, 10), 1766, Seq.fill(4)(2002)))),
       existingPropTest("id", { (x: Header) => x.id }))
 
@@ -4430,18 +4430,10 @@ class LanguageSpecificationV5 extends LanguageSpecificationBase { suite =>
     )
 
     val header = CHeader(
-      Helpers.decodeBytes("1c597f88969600d2fffffdc47f00d8ffc555a9e85001000001c505ff80ff8f7f"),
       0.toByte,
       Helpers.decodeBytes("7a7fe5347f09017818010062000001807f86808000ff7f66ffb07f7ad27f3362"),
       Helpers.decodeBytes("c1d70ad9b1ffc1fb9a715fff19807f2401017fcd8b73db017f1cff77727fff08"),
-      CAvlTree(
-        AvlTreeData(
-          ErgoAlgos.decodeUnsafe("54d23dd080006bdb56800100356080935a80ffb77e90b800057f00661601807f17").toColl,
-          AvlTreeFlags(true, true, false),
-          2147483647,
-          None
-        )
-      ),
+      Helpers.decodeBytes("54d23dd080006bdb56800100356080935a80ffb77e90b800057f00661601807f17"),
       Helpers.decodeBytes("5e7f1164ccd0990080c501fc0e0181cb387fc17f00ff00c7d5ff767f91ff5e68"),
       -7421721754642387858L,
       -4826493284887861030L,
@@ -4451,7 +4443,8 @@ class LanguageSpecificationV5 extends LanguageSpecificationBase { suite =>
       Helpers.decodeGroupElement("034e2d3b5f9e409e3ae8a2e768340760362ca33764eda5855f7a43487f14883300"),
       Helpers.decodeBytes("974651c9efff7f00"),
       CBigInt(new BigInteger("478e827dfa1e4b57", 16)),
-      Helpers.decodeBytes("01ff13")
+      Helpers.decodeBytes("01ff13"),
+      Colls.emptyColl
     )
 
     val ctx = CContext(
@@ -4459,7 +4452,7 @@ class LanguageSpecificationV5 extends LanguageSpecificationBase { suite =>
       headers = Coll[Header](header),
       preHeader = CPreHeader(
         0.toByte,
-        Helpers.decodeBytes("1c597f88969600d2fffffdc47f00d8ffc555a9e85001000001c505ff80ff8f7f"),
+        header.id,
         -755484979487531112L,
         9223372036854775807L,
         11,
diff --git a/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala b/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
index 382c47403c..cd851c69b7 100644
--- a/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
+++ b/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
@@ -1,10 +1,15 @@
 package sigma
 
+import org.ergoplatform.ErgoBox
+import org.ergoplatform.ErgoBox.Token
+import scorex.util.ModifierId
+import scorex.util.encode.Base16
+import org.ergoplatform.ErgoHeader
 import sigma.ast.ErgoTree.ZeroHeader
 import sigma.ast.SCollection.SByteArray
 import sigma.ast.syntax.TrueSigmaProp
 import sigma.ast._
-import sigma.data.{CBigInt, ExactNumeric}
+import sigma.data.{CBigInt, CHeader, CBox, ExactNumeric}
 import sigma.eval.{CostDetails, SigmaDsl, TracedCost}
 import sigma.util.Extensions.{BooleanOps, ByteOps, IntOps, LongOps}
 import sigmastate.exceptions.MethodNotFound
@@ -265,9 +270,13 @@ class LanguageSpecificationV6 extends LanguageSpecificationBase { suite =>
   }
 
   property("Box properties equivalence (new features)") {
-    // TODO v6.0: related to https://github.com/ScorexFoundation/sigmastate-interpreter/issues/416
-    val getReg = newFeature((x: Box) => x.getReg[Int](1).get,
-      "{ (x: Box) => x.getReg[Int](1).get }",
+    // related to https://github.com/ScorexFoundation/sigmastate-interpreter/issues/416
+    def getReg = newFeature((x: Box) => x.getReg[Long](0).get,
+      "{ (x: Box) => x.getReg[Long](0).get }",
+      FuncValue(
+        Array((1, SBox)),
+        OptionGet(ExtractRegisterAs(ValUse(1, SBox), ErgoBox.R0, SOption(SLong)))
+      ),
       sinceVersion = VersionContext.V6SoftForkVersion)
 
     if (activatedVersionInTests < VersionContext.V6SoftForkVersion) {
@@ -277,6 +286,16 @@ class LanguageSpecificationV6 extends LanguageSpecificationBase { suite =>
       forAll { box: Box =>
         Seq(getReg).foreach(_.checkEquality(box))
       }
+    } else {
+      val value = 10L
+      val box = CBox(new ErgoBox(value, TrueTree, Colls.emptyColl[Token], Map.empty,
+                                  ModifierId @@ Base16.encode(Array.fill(32)(0)), 0, 0))
+      verifyCases(
+        Seq(
+          box -> new Expected(ExpectedResult(Success(value), None))
+        ),
+        getReg
+      )
     }
   }
 
@@ -463,4 +482,35 @@ class LanguageSpecificationV6 extends LanguageSpecificationBase { suite =>
     tree.root shouldBe t2.root
   }
 
+  property("Header new methods") {
+
+    def checkPoW = {
+      newFeature(
+        { (x: Header) => x.checkPow},
+        "{ (x: Header) => x.checkPow }",
+        FuncValue(
+          Array((1, SHeader)),
+          MethodCall.typed[Value[SBoolean.type]](
+            ValUse(1, SHeader),
+            SHeaderMethods.checkPowMethod,
+            IndexedSeq(),
+            Map()
+          )
+        ),
+        sinceVersion = VersionContext.V6SoftForkVersion
+      )
+    }
+
+    // bytes of real mainnet block header at height 614,440
+    val headerBytes = "02ac2101807f0000ca01ff0119db227f202201007f62000177a080005d440896d05d3f80dcff7f5e7f59007294c180808d0158d1ff6ba10000f901c7f0ef87dcfff17fffacb6ff7f7f1180d2ff7f1e24ffffe1ff937f807f0797b9ff6ebdae007e5c8c00b8403d3701557181c8df800001b6d5009e2201c6ff807d71808c00019780f087adb3fcdbc0b3441480887f80007f4b01cf7f013ff1ffff564a0000b9a54f00770e807f41ff88c00240000080c0250000000003bedaee069ff4829500b3c07c4d5fe6b3ea3d3bf76c5c28c1d4dcdb1bed0ade0c0000000000003105"
+    val header1 = new CHeader(ErgoHeader.sigmaSerializer.fromBytes(Base16.decode(headerBytes).get))
+
+    verifyCases(
+      Seq(
+        header1 -> new Expected(ExpectedResult(Success(true), None))
+      ),
+      checkPoW
+    )
+  }
+
 }
diff --git a/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala b/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
index 58873449b4..4410786fd4 100644
--- a/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
+++ b/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
@@ -872,10 +872,14 @@ class SigmaDslTesting extends AnyPropSpec
     extends Feature[A, B] {
 
     override def isSupportedIn(vc: VersionContext): Boolean =
-      vc.activatedVersion >= sinceVersion && vc.ergoTreeVersion >= sinceVersion
+      vc.activatedVersion >= sinceVersion
 
     override def scalaFunc: A => B = { x =>
-      sys.error(s"Semantic Scala function is not defined for old implementation: $this")
+      if (isSupportedIn(VersionContext.current)) {
+        scalaFuncNew(x)
+      } else {
+        sys.error(s"Semantic Scala function is not defined for old implementation: $this")
+      }
     }
     implicit val cs = compilerSettingsInTests
 
@@ -925,8 +929,14 @@ class SigmaDslTesting extends AnyPropSpec
                             printTestCases: Boolean,
                             failOnTestVectors: Boolean): Unit = {
       val funcRes = checkEquality(input, printTestCases)
-      funcRes.isFailure shouldBe true
-      Try(scalaFunc(input)) shouldBe expected.value
+      if(!isSupportedIn(VersionContext.current)) {
+        funcRes.isFailure shouldBe true
+      }
+      if(isSupportedIn(VersionContext.current)) {
+        Try(scalaFunc(input)) shouldBe expected.value
+      } else {
+        Try(scalaFunc(input)).isFailure shouldBe true
+      }
     }
   }
 
diff --git a/sc/shared/src/test/scala/sigmastate/ErgoTreeSpecification.scala b/sc/shared/src/test/scala/sigmastate/ErgoTreeSpecification.scala
index 7539bd5e48..c3c20422e9 100644
--- a/sc/shared/src/test/scala/sigmastate/ErgoTreeSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/ErgoTreeSpecification.scala
@@ -21,14 +21,14 @@ import sigma.compiler.CompilerSettings
 import sigma.eval.EvalSettings
 import sigma.exceptions.{CostLimitException, InterpreterException}
 import sigma.serialization.ErgoTreeSerializer.DefaultSerializer
-import sigmastate.Plus
+import sigmastate.{CrossVersionProps, Plus}
 import sigmastate.utils.Helpers.TryOps
 
 
 /** Regression tests with ErgoTree related test vectors.
   * This test vectors verify various constants which are consensus critical and should not change.
   */
-class ErgoTreeSpecification extends SigmaDslTesting with ContractsTestkit {
+class ErgoTreeSpecification extends SigmaDslTesting with ContractsTestkit with CrossVersionProps {
 
   property("Value.sourceContext") {
     val srcCtx = SourceContext.fromParserIndex(0, "")
@@ -316,7 +316,7 @@ class ErgoTreeSpecification extends SigmaDslTesting with ContractsTestkit {
   // NOTE, the type code constants are checked above
   // The methodId codes as checked here, they MUST be PRESERVED.
   // The following table should be made dependent on HF activation
-  val methods = Table(
+  def methods = Table(
     ("typeId",        "methods",               "CanHaveMethods"),
     (SBoolean.typeId, Seq.empty[MInfo], true),
     (SByte.typeId,    Seq.empty[MInfo], false),
@@ -367,9 +367,12 @@ class ErgoTreeSpecification extends SigmaDslTesting with ContractsTestkit {
         MInfo(4, BytesWithoutRefMethod),
         MInfo(5, IdMethod),
         MInfo(6, creationInfoMethod),
-        MInfo(7, getRegMethod),
         MInfo(8, tokensMethod)
-      ) ++ registers(idOfs = 8)
+      ) ++ (if (VersionContext.current.isV6SoftForkActivated) {
+        Seq(MInfo(7, getRegMethodV6))
+      } else {
+        Seq(MInfo(7, getRegMethodV5))
+      }) ++ registers(idOfs = 8)
         .zipWithIndex
         .map { case (m,i) => MInfo((8 + i + 1).toByte, m) }, true)
     },
diff --git a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
index 1012e9a189..4ba6b1a9f7 100644
--- a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
@@ -6,18 +6,23 @@ import sigma.ast._
 import sigma.ast.syntax._
 import sigmastate.interpreter._
 import Interpreter._
-import sigma.ast.syntax._
 import org.ergoplatform._
 import org.scalatest.BeforeAndAfterAll
-import scorex.util.encode.Base58
+import scorex.util.encode.{Base16, Base58}
+import sigma.Colls
+import sigma.VersionContext.V6SoftForkVersion
 import sigma.VersionContext
-import sigma.crypto.CryptoConstants
-import sigma.data.{AvlTreeData, CAND, ProveDlog, SigmaBoolean, TrivialProp}
+import sigma.data.{CAND, CAvlTree, CHeader, ProveDlog, SigmaBoolean, TrivialProp}
+import sigma.interpreter.ContextExtension
 import sigma.util.Extensions.IntOps
 import sigmastate.helpers.{CompilerTestingCommons, ErgoLikeContextTesting, ErgoLikeTestInterpreter, ErgoLikeTestProvingInterpreter}
 import sigmastate.helpers.TestingHelpers._
-import sigma.serialization.ValueSerializer
+import sigma.serialization.{GroupElementSerializer, SigmaSerializer, ValueSerializer}
+import sigmastate.eval.CPreHeader
+import sigmastate.helpers.ErgoLikeContextTesting.noBoxes
+import sigmastate.interpreter.CErgoTreeEvaluator.DefaultEvalSettings
 import sigmastate.utils.Helpers._
+import sigma.util.Extensions._
 
 import scala.util.Random
 
@@ -30,12 +35,29 @@ class TestingInterpreterSpecification extends CompilerTestingCommons
 
   lazy val verifier = new ErgoLikeTestInterpreter
   
-  def testingContext(h: Int) =
-    ErgoLikeContextTesting(h,
-      AvlTreeData.dummy, ErgoLikeContextTesting.dummyPubkey, IndexedSeq(fakeSelf),
-      ErgoLikeTransaction(IndexedSeq.empty, IndexedSeq.empty),
-      fakeSelf, activatedVersionInTests)
-        .withErgoTreeVersion(ergoTreeVersionInTests)
+  def testingContext(h: Int = 614401) = {
+    // bytes of real mainnet block header at height 614,440
+    val headerBytes = "02ac2101807f0000ca01ff0119db227f202201007f62000177a080005d440896d05d3f80dcff7f5e7f59007294c180808d0158d1ff6ba10000f901c7f0ef87dcfff17fffacb6ff7f7f1180d2ff7f1e24ffffe1ff937f807f0797b9ff6ebdae007e5c8c00b8403d3701557181c8df800001b6d5009e2201c6ff807d71808c00019780f087adb3fcdbc0b3441480887f80007f4b01cf7f013ff1ffff564a0000b9a54f00770e807f41ff88c00240000080c0250000000003bedaee069ff4829500b3c07c4d5fe6b3ea3d3bf76c5c28c1d4dcdb1bed0ade0c0000000000003105"
+    val header1 = new CHeader(ErgoHeader.sigmaSerializer.fromBytes(Base16.decode(headerBytes).get))
+
+    val boxesToSpend = IndexedSeq(fakeSelf)
+
+    val preHeader = CPreHeader(activatedVersionInTests,
+      parentId = header1.id,
+      timestamp = 3,
+      nBits = 0,
+      height = h,
+      minerPk = GroupElementSerializer.parse(SigmaSerializer.startReader(ErgoLikeContextTesting.dummyPubkey)).toGroupElement,
+      votes = Colls.emptyColl[Byte]
+    )
+
+    new ErgoLikeContext(
+      header1.stateRoot.asInstanceOf[CAvlTree].treeData, Colls.fromArray(Array(header1)),
+      preHeader, noBoxes,
+      boxesToSpend, ErgoLikeTransaction(IndexedSeq.empty, IndexedSeq.empty),
+      boxesToSpend.indexOf(fakeSelf), ContextExtension.empty, vs, DefaultEvalSettings.scriptCostLimitInEvaluator,
+      initCost = 0L, activatedVersionInTests).withErgoTreeVersion(ergoTreeVersionInTests)
+  }
 
   property("Reduction to crypto #1") {
     forAll() { i: Int =>
@@ -117,7 +139,7 @@ class TestingInterpreterSpecification extends CompilerTestingCommons
 
     val dk1 = prover.dlogSecrets(0).publicImage
     val dk2 = prover.dlogSecrets(1).publicImage
-    val ctx = testingContext(99)
+    val ctx = testingContext()
     val env = Map(
       "dk1" -> dk1,
       "dk2" -> dk2,
@@ -125,7 +147,9 @@ class TestingInterpreterSpecification extends CompilerTestingCommons
       "bytes2" -> Array[Byte](4, 5, 6),
       "box1" -> testBox(10, TrueTree, 0, Seq(), Map(
           reg1 -> IntArrayConstant(Array[Int](1, 2, 3)),
-          reg2 -> BoolArrayConstant(Array[Boolean](true, false, true)))))
+          reg2 -> BoolArrayConstant(Array[Boolean](true, false, true))
+      ))
+    )
     val prop = mkTestErgoTree(compile(env, code)(IR).asBoolValue.toSigmaProp)
     val challenge = Array.fill(32)(Random.nextInt(100).toByte)
     val proof1 = prover.prove(prop, ctx, challenge).get.proof
@@ -378,6 +402,24 @@ class TestingInterpreterSpecification extends CompilerTestingCommons
     verifier.verify(prop3, env, proof, challenge).map(_._1).getOrElse(false) shouldBe false
   }
 
+  property("blake2b - test vector") {
+    testEval(
+      """ {
+        |     val input = fromBase16("68656c6c6f20776f726c64")
+        |     val output = fromBase16("256c83b297114d201b30179f3f0ef0cace9783622da5974326b436178aeef610")
+        |     blake2b256(input) == output
+        | }""".stripMargin)
+  }
+
+  property("blake2b - test vector #2") {
+    testEval(
+      """ {
+        |     val input = fromBase16("02ac2101807f0000ca01ff0119db227f202201007f62000177a080005d440896d05d3f80dcff7f5e7f59007294c180808d0158d1ff6ba10000f901c7f0ef87dcfff17fffacb6ff7f7f1180d2ff7f1e24ffffe1ff937f807f0797b9ff6ebdae007e5c8c00b8403d3701557181c8df800001b6d5009e2201c6ff807d71808c00019780d085adb3fcdbc0b3441480887f80007f4b01cf7f013ff1ffff564a0000b9a54f00770e807f41ff88c00240000080c02500000000")
+        |     val output = fromBase16("bdb84cda5b105c3eb522857b50a0882f88ed5bb3cc8cf3325a1edf7eeb6a0954")
+        |     blake2b256(input) == output
+        | }""".stripMargin)
+  }
+
   property("passing a lambda argument") {
     // single expression
     testEval(
@@ -412,6 +454,29 @@ class TestingInterpreterSpecification extends CompilerTestingCommons
     testEval(s"""deserialize[Coll[Byte]]("$str")(0) == 2""")
   }
 
+  property("header.id") {
+    testEval(
+      """ {
+        |     val h = CONTEXT.headers(0)
+        |     val id = h.id
+        |     id.size == 32
+        | }""".stripMargin)
+  }
+
+  property("checkPow") {
+    val source = """ {
+                   |     val h = CONTEXT.headers(0)
+                   |      h.checkPow
+                   | }
+                   | """.stripMargin
+
+    if (activatedVersionInTests < V6SoftForkVersion) {
+      an [Exception] should be thrownBy testEval(source)
+    } else {
+      testEval(source)
+    }
+  }
+
   override protected def afterAll(): Unit = {
   }
 
diff --git a/sc/shared/src/test/scala/sigmastate/TypesSpecification.scala b/sc/shared/src/test/scala/sigmastate/TypesSpecification.scala
index 9a4c5ce1b8..6d13863f26 100644
--- a/sc/shared/src/test/scala/sigmastate/TypesSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/TypesSpecification.scala
@@ -13,8 +13,6 @@ class TypesSpecification extends SigmaTestingData {
       implicit val tWrapped = wrappedTypeGen(t)
       forAll { x: SPredefType#WrappedType =>
         isValueOfType(x, t) shouldBe true
-        // since forall t. SHeader != t
-        isValueOfType(x, SHeader) shouldBe false
       }
     }
   }
diff --git a/sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala b/sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala
index 40b6caca4d..d80e39273f 100644
--- a/sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala
@@ -3,7 +3,9 @@ package sigmastate.utxo
 import org.ergoplatform.ErgoBox.{AdditionalRegisters, R6, R8}
 import org.ergoplatform._
 import scorex.util.encode.Base16
+import org.scalatest.Assertion
 import sigma.Extensions.ArrayOps
+import sigma.VersionContext
 import sigma.ast.SCollection.SByteArray
 import sigma.ast.SType.AnyOps
 import sigma.data.{AvlTreeData, CAnyValue, CSigmaDslBuilder}
@@ -765,4 +767,45 @@ class BasicOpsSpecification extends CompilerTestingCommons
     test("subst", env, ext, hostScript, null)
   }
 
+  property("Box.getReg") {
+    def getRegTest(): Assertion = {
+      test("Box.getReg", env, ext,
+        """{
+          |   val x = SELF
+          |   x.getReg[Long](0).get == SELF.value &&
+          |   x.getReg[Coll[(Coll[Byte], Long)]](2).get == SELF.tokens &&
+          |   x.getReg[Int](9).isEmpty
+          |}""".stripMargin,
+        null
+      )
+    }
+
+    if (VersionContext.current.isV6SoftForkActivated) {
+      getRegTest()
+    } else {
+      an[Exception] should be thrownBy getRegTest()
+    }
+  }
+
+  property("Box.getReg - computable index") {
+    val ext: Seq[VarBinding] = Seq(
+      (intVar1, IntConstant(0))
+    )
+    def getRegTest(): Assertion = {
+      test("Box.getReg", env, ext,
+        """{
+          |   val x = SELF.getReg[Long](getVar[Int](1).get).get
+          |   x == SELF.value
+          |}""".stripMargin,
+        null
+      )
+    }
+
+    if (VersionContext.current.isV6SoftForkActivated) {
+      getRegTest()
+    } else {
+      an[Exception] should be thrownBy getRegTest()
+    }
+  }
+
 }
diff --git a/sdk/js/src/main/scala/org/ergoplatform/sdk/js/Header.scala b/sdk/js/src/main/scala/org/ergoplatform/sdk/js/Header.scala
index ef53e13dbd..2220c9827a 100644
--- a/sdk/js/src/main/scala/org/ergoplatform/sdk/js/Header.scala
+++ b/sdk/js/src/main/scala/org/ergoplatform/sdk/js/Header.scala
@@ -12,7 +12,7 @@ import scala.scalajs.js.annotation.JSExportTopLevel
 class Header(
     /** Hex representation of ModifierId of this Header */
     val id: String,
-    /** Block version, to be increased on every soft and hardfork. */
+    /** Block version, to be increased on every soft- or hard-fork. */
     val version: Byte,
     /** Hex representation of ModifierId of the parent block */
     val parentId: String,
@@ -48,5 +48,7 @@ class Header(
     val powDistance: js.BigInt,
 
     /** Miner votes for changing system parameters. */
-    val votes: String
+    val votes: String,
+
+    val unparsedBytes: String
 ) extends js.Object
diff --git a/sdk/js/src/main/scala/org/ergoplatform/sdk/js/Isos.scala b/sdk/js/src/main/scala/org/ergoplatform/sdk/js/Isos.scala
index 0f50a52686..84f2b21da8 100644
--- a/sdk/js/src/main/scala/org/ergoplatform/sdk/js/Isos.scala
+++ b/sdk/js/src/main/scala/org/ergoplatform/sdk/js/Isos.scala
@@ -7,9 +7,10 @@ import sigma.ast.{Constant, SType}
 import sigma.data.Iso
 import sigma.data.Iso.{isoStringToArray, isoStringToColl}
 import sigma.data.js.{Isos => DataIsos}
+import sigma.data.CHeader
 import sigma.interpreter.{ContextExtension, ProverResult}
 import sigma.js.AvlTree
-import sigmastate.eval.{CHeader, CPreHeader}
+import sigmastate.eval.CPreHeader
 import sigmastate.fleetSdkCommon.distEsmTypesBoxesMod.Box
 import sigmastate.fleetSdkCommon.distEsmTypesRegistersMod.NonMandatoryRegisters
 import sigmastate.fleetSdkCommon.distEsmTypesTokenMod.TokenAmount
@@ -27,11 +28,10 @@ object Isos {
   implicit val isoHeader: Iso[Header, sigma.Header] = new Iso[Header, sigma.Header] {
     override def to(a: Header): sigma.Header = {
       CHeader(
-        id = isoStringToColl.to(a.id),
         version = a.version,
         parentId = isoStringToColl.to(a.parentId),
         ADProofsRoot = isoStringToColl.to(a.ADProofsRoot),
-        stateRoot = AvlTree.isoAvlTree.to(a.stateRoot),
+        stateRootDigest = AvlTree.isoAvlTree.to(a.stateRoot).digest,
         transactionsRoot = isoStringToColl.to(a.transactionsRoot),
         timestamp = sigma.js.Isos.isoBigIntToLong.to(a.timestamp),
         nBits = sigma.js.Isos.isoBigIntToLong.to(a.nBits),
@@ -41,7 +41,8 @@ object Isos {
         powOnetimePk = DataIsos.isoGroupElement.to(a.powOnetimePk),
         powNonce = isoStringToColl.to(a.powNonce),
         powDistance = sigma.js.Isos.isoBigInt.to(a.powDistance),
-        votes = isoStringToColl.to(a.votes)
+        votes = isoStringToColl.to(a.votes),
+        unparsedBytes = isoStringToColl.to(a.unparsedBytes)
       )
     }
     override def from(b: sigma.Header): Header = {
@@ -61,7 +62,8 @@ object Isos {
         powOnetimePk = DataIsos.isoGroupElement.from(header.powOnetimePk),
         powNonce = isoStringToColl.from(header.powNonce),
         powDistance = sigma.js.Isos.isoBigInt.from(header.powDistance),
-        votes = isoStringToColl.from(header.votes)
+        votes = isoStringToColl.from(header.votes),
+        unparsedBytes = isoStringToColl.from(header.unparsedBytes)
       )
     }
   }
diff --git a/sdk/js/src/test/scala/org/ergoplatform/sdk/js/IsosSpec.scala b/sdk/js/src/test/scala/org/ergoplatform/sdk/js/IsosSpec.scala
index a040731b20..31b8a84c2b 100644
--- a/sdk/js/src/test/scala/org/ergoplatform/sdk/js/IsosSpec.scala
+++ b/sdk/js/src/test/scala/org/ergoplatform/sdk/js/IsosSpec.scala
@@ -1,8 +1,9 @@
 package org.ergoplatform.sdk.js
 
+import io.circe.parser.parse
 import org.ergoplatform.ErgoBox.{AdditionalRegisters, BoxId, TokenId}
 import org.ergoplatform._
-import org.ergoplatform.sdk.ExtendedInputBox
+import org.ergoplatform.sdk.{ExtendedInputBox, JsonCodecs}
 import org.ergoplatform.sdk.wallet.protocol.context.BlockchainStateContext
 import org.scalacheck.Arbitrary
 import sigma.ast.{Constant, SType}
@@ -11,6 +12,7 @@ import sigma.interpreter.{ContextExtension, ProverResult}
 import sigma.js.AvlTree
 import sigma.{Coll, GroupElement}
 import sigma.data.js.{Isos => DataIsos}
+
 import scala.scalajs.js
 
 class IsosSpec extends IsosSpecBase with sdk.generators.ObjectGenerators {
diff --git a/sdk/shared/src/main/scala/org/ergoplatform/sdk/DataJsonEncoder.scala b/sdk/shared/src/main/scala/org/ergoplatform/sdk/DataJsonEncoder.scala
index fc95b77e61..6c0c866baf 100644
--- a/sdk/shared/src/main/scala/org/ergoplatform/sdk/DataJsonEncoder.scala
+++ b/sdk/shared/src/main/scala/org/ergoplatform/sdk/DataJsonEncoder.scala
@@ -122,6 +122,10 @@ object DataJsonEncoder {
       val w = SigmaSerializer.startWriter()
       DataSerializer.serialize(v, tpe, w)
       encodeBytes(w.toBytes)
+    case SHeader =>
+      val w = SigmaSerializer.startWriter()
+      DataSerializer.serialize(v, tpe, w)
+      encodeBytes(w.toBytes)
     case SAvlTree =>
       val w = SigmaSerializer.startWriter()
       DataSerializer.serialize(v, tpe, w)
@@ -203,6 +207,10 @@ object DataJsonEncoder {
         val str = decodeBytes(json)
         val r = SigmaSerializer.startReader(str)
         DataSerializer.deserialize(SSigmaProp, r)
+      case SHeader => // for Sigma < 6.0 , exception will be thrown by DataSerializer
+        val str = decodeBytes(json)
+        val r = SigmaSerializer.startReader(str)
+        DataSerializer.deserialize(SHeader, r)
       case SBox =>
         val value = decodeData(json.hcursor.downField(s"value").focus.get, SLong)
         val tree = ErgoTreeSerializer.DefaultSerializer.deserializeErgoTree(decodeBytes(json.hcursor.downField(s"ergoTree").focus.get))
diff --git a/sdk/shared/src/main/scala/org/ergoplatform/sdk/JsonCodecs.scala b/sdk/shared/src/main/scala/org/ergoplatform/sdk/JsonCodecs.scala
index ae14fd831a..98e8011bcc 100644
--- a/sdk/shared/src/main/scala/org/ergoplatform/sdk/JsonCodecs.scala
+++ b/sdk/shared/src/main/scala/org/ergoplatform/sdk/JsonCodecs.scala
@@ -12,7 +12,7 @@ import scorex.crypto.hash.Digest32
 import scorex.util.ModifierId
 import sigma.Extensions.ArrayOps
 import sigma.ast.{ErgoTree, EvaluatedValue, SType}
-import sigma.data.{AvlTreeData, AvlTreeFlags, CBigInt, Digest32Coll, WrapperOf}
+import sigma.data.{AvlTreeData, AvlTreeFlags, CBigInt, CHeader, Digest32Coll, WrapperOf}
 import sigma.eval.Extensions.EvalIterableOps
 import sigma.eval.SigmaDsl
 import sigma.interpreter.{ContextExtension, ProverResult}
@@ -125,13 +125,18 @@ trait JsonCodecs {
       "powOnetimePk" -> h.powOnetimePk.getEncoded.asJson,
       "powNonce" -> h.powNonce.asJson,
       "powDistance" -> h.powDistance.asJson,
-      "votes" -> h.votes.asJson
+      "votes" -> h.votes.asJson,
+      "unparsedBytes" -> h.unparsedBytes.asJson
     ).asJson
   })
 
+  /**
+    * JSON decoder for Header instance. Field "unparsedBytes" is optional for now, to preserve compatibility
+    * with clients using older JSON decoders (before node 5.0.23). Better to add an (empty) field anyway if possible.
+    * This field could become mandatory in future.
+    */
   implicit val headerDecoder: Decoder[Header] = Decoder.instance({ cursor =>
     for {
-      id <- cursor.downField("id").as[Coll[Byte]]
       version <- cursor.downField("version").as[Byte]
       parentId <- cursor.downField("parentId").as[Coll[Byte]]
       adProofsRoot <- cursor.downField("adProofsRoot").as[Coll[Byte]]
@@ -146,8 +151,10 @@ trait JsonCodecs {
       powNonce <- cursor.downField("powNonce").as[Coll[Byte]]
       powDistance <- cursor.downField("powDistance").as[sigma.BigInt]
       votes <- cursor.downField("votes").as[Coll[Byte]]
-    } yield new CHeader(id, version, parentId, adProofsRoot, stateRoot, transactionsRoot, timestamp, nBits,
-      height, extensionRoot, SigmaDsl.decodePoint(minerPk), SigmaDsl.decodePoint(powOnetimePk), powNonce, powDistance, votes)
+      unparsedBytes <- cursor.downField("unparsedBytes").as[Option[Coll[Byte]]]
+    } yield CHeader(version, parentId, adProofsRoot, stateRoot.digest, transactionsRoot, timestamp, nBits,
+      height, extensionRoot, SigmaDsl.decodePoint(minerPk), SigmaDsl.decodePoint(powOnetimePk), powNonce, powDistance,
+      votes, unparsedBytes.getOrElse(Colls.emptyColl))
   })
 
   implicit val preHeaderEncoder: Encoder[PreHeader] = Encoder.instance({ v: PreHeader =>
diff --git a/sdk/shared/src/test/scala/org/ergoplatform/sdk/DataJsonEncoderSpecification.scala b/sdk/shared/src/test/scala/org/ergoplatform/sdk/DataJsonEncoderSpecification.scala
index c3f7b43af4..5835f399cb 100644
--- a/sdk/shared/src/test/scala/org/ergoplatform/sdk/DataJsonEncoderSpecification.scala
+++ b/sdk/shared/src/test/scala/org/ergoplatform/sdk/DataJsonEncoderSpecification.scala
@@ -13,7 +13,7 @@ import sigma.serialization.SerializerException
 import sigma.util.Extensions.{BigIntegerOps, EcpOps, SigmaBooleanOps}
 import sigma.Extensions.ArrayOps
 import sigma.eval.SigmaDsl
-import sigma.{AvlTree, Box, Colls, Evaluation}
+import sigma.{AvlTree, Box, Colls, Evaluation, Header, VersionContext}
 import sigma.serialization.SerializationSpecification
 
 import scala.annotation.nowarn
@@ -22,29 +22,48 @@ import scala.reflect.ClassTag
 class DataJsonEncoderSpecification extends SerializationSpecification {
   object JsonCodecs extends JsonCodecs
 
-  def roundtrip[T <: SType](obj: T#WrappedType, tpe: T) = {
-    val json = DataJsonEncoder.encode(obj, tpe)
-    val res = DataJsonEncoder.decode(json)
-    res shouldBe obj
+  def roundtrip[T <: SType](obj: T#WrappedType, tpe: T, withVersion: Option[Byte] = None) = {
+    def test() = {
+      val json = DataJsonEncoder.encode(obj, tpe)
+      val res = DataJsonEncoder.decode(json)
+      res shouldBe obj
+    }
+
+    withVersion match {
+      case Some(ver) =>
+        VersionContext.withVersions(ver, 0) {
+          test()
+        }
+      case None =>
+        test()
+    }
   }
 
   def testCollection[T <: SType](tpe: T) = {
     implicit val wWrapped = wrappedTypeGen(tpe)
     implicit val tT = Evaluation.stypeToRType(tpe)
     implicit val tagT = tT.classTag
+
+    val withVersion = if (tpe == SHeader) {
+      Some(VersionContext.V6SoftForkVersion)
+    } else {
+      None
+    }
+
     forAll { xs: Array[T#WrappedType] =>
-      roundtrip[SCollection[T]](xs.toColl, SCollection(tpe))
-      roundtrip[SType](xs.toColl.map(x => (x, x)).asWrappedType, SCollection(STuple(tpe, tpe)))
+      roundtrip[SCollection[T]](xs.toColl, SCollection(tpe), withVersion)
+      roundtrip[SType](xs.toColl.map(x => (x, x)).asWrappedType, SCollection(STuple(tpe, tpe)), withVersion)
 
       val nested = xs.toColl.map(x => Colls.fromItems[T#WrappedType](x, x))
-      roundtrip[SCollection[SCollection[T]]](nested, SCollection(SCollection(tpe)))
+      roundtrip[SCollection[SCollection[T]]](nested, SCollection(SCollection(tpe)), withVersion)
 
       roundtrip[SType](
         xs.toColl.map { x =>
           val arr = Colls.fromItems[T#WrappedType](x, x)
           (arr, arr)
         }.asWrappedType,
-        SCollection(STuple(SCollection(tpe), SCollection(tpe)))
+        SCollection(STuple(SCollection(tpe), SCollection(tpe))),
+        withVersion
       )
     }
   }
@@ -54,11 +73,18 @@ class DataJsonEncoderSpecification extends SerializationSpecification {
     val tT = Evaluation.stypeToRType(tpe)
     @nowarn implicit val tag     : ClassTag[T#WrappedType] = tT.classTag
     @nowarn implicit val tAny    : RType[Any]              = sigma.AnyType
+
+    val withVersion = if (tpe == SHeader) {
+      Some(VersionContext.V6SoftForkVersion)
+    } else {
+      None
+    }
+
     forAll { in: (T#WrappedType, T#WrappedType) =>
       val (x,y) = (in._1, in._2)
-      roundtrip[SType]((x, y).asWrappedType, STuple(tpe, tpe))
-      roundtrip[SType](((x, y), (x, y)).asWrappedType, STuple(STuple(tpe, tpe), STuple(tpe, tpe)))
-      roundtrip[SType](((x, y), ((x, y), (x, y))).asWrappedType, STuple(STuple(tpe, tpe), STuple(STuple(tpe, tpe), STuple(tpe, tpe))))
+      roundtrip[SType]((x, y).asWrappedType, STuple(tpe, tpe), withVersion)
+      roundtrip[SType](((x, y), (x, y)).asWrappedType, STuple(STuple(tpe, tpe), STuple(tpe, tpe)), withVersion)
+      roundtrip[SType](((x, y), ((x, y), (x, y))).asWrappedType, STuple(STuple(tpe, tpe), STuple(STuple(tpe, tpe), STuple(tpe, tpe))), withVersion)
     }
   }
 
@@ -98,6 +124,7 @@ class DataJsonEncoderSpecification extends SerializationSpecification {
     forAll { x: AvlTree => roundtrip[SAvlTree.type](x, SAvlTree) }
     forAll { x: Array[Byte] => roundtrip[SByteArray](x.toColl, SByteArray) }
     forAll { x: Box => roundtrip[SBox.type](x, SBox) }
+    forAll { x: Header => roundtrip[SHeader.type](x, SHeader, Some(VersionContext.V6SoftForkVersion)) }
     forAll { x: Option[Byte] => roundtrip[SOption[SByte.type]](x, SOption[SByte.type]) }
     testCollection(SOption[SLong.type])
     testTuples(SOption[SLong.type])
@@ -187,25 +214,44 @@ class DataJsonEncoderSpecification extends SerializationSpecification {
     val tT = Evaluation.stypeToRType(tpe)
     @nowarn implicit val tag = tT.classTag
     @nowarn implicit val tAny = sigma.AnyType
-    forAll { x: T#WrappedType =>
-      an[SerializerException] should be thrownBy {
-        DataJsonEncoder.encode(TupleColl(x, x, x).asWrappedType, STuple(tpe, tpe, tpe))
-      }
 
-      // supported case
-      DataJsonEncoder.encode(SigmaDsl.Colls.fromItems(TupleColl(x, x)).asWrappedType, SCollection(STuple(tpe, tpe)))
 
-      // not supported case
-      an[SerializerException] should be thrownBy {
-        DataJsonEncoder.encode(SigmaDsl.Colls.fromItems(TupleColl(x, x, x)).asWrappedType, SCollection(STuple(tpe, tpe, tpe)))
+    def test() = {
+      forAll { x: T#WrappedType =>
+        an[SerializerException] should be thrownBy {
+          DataJsonEncoder.encode(TupleColl(x, x, x).asWrappedType, STuple(tpe, tpe, tpe))
+        }
+
+        // supported case
+        DataJsonEncoder.encode(SigmaDsl.Colls.fromItems(TupleColl(x, x)).asWrappedType, SCollection(STuple(tpe, tpe)))
+
+        // not supported case
+        an[SerializerException] should be thrownBy {
+          DataJsonEncoder.encode(SigmaDsl.Colls.fromItems(TupleColl(x, x, x)).asWrappedType, SCollection(STuple(tpe, tpe, tpe)))
+        }
       }
     }
+
+    if (tpe == SHeader)  {
+      VersionContext.withVersions(VersionContext.V6SoftForkVersion, 0) {
+        test()
+      }
+    } else {
+      test()
+    }
   }
 
   property("AnyValue") {
     forAll { t: SPredefType =>
-      testAnyValue(t)
-      testAnyValue(SOption(t))
+      if (t == SHeader) {
+        VersionContext.withVersions(VersionContext.V6SoftForkVersion, 1) {
+          testAnyValue(t)
+          testAnyValue(SOption(t))
+        }
+      } else {
+        testAnyValue(t)
+        testAnyValue(SOption(t))
+      }
     }
   }
 

From b068b107a038afb46743016d3492a6501343e3bf Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Tue, 3 Sep 2024 13:18:54 +0300
Subject: [PATCH 2/2] Serialize SFunc in TypeSerializer

---
 .../src/main/scala/sigma/ast/SType.scala      |  3 +-
 .../src/main/scala/sigma/ast/STypeParam.scala | 14 +---
 .../src/main/scala/sigma/ast/TypeCodes.scala  |  6 +-
 .../sigma/serialization/TypeSerializer.scala  | 29 ++++++++
 .../MethodCallSerializerSpecification.scala   | 22 ------
 .../generators/ObjectGenerators.scala         |  2 +-
 .../sigmastate/helpers/SigmaPPrint.scala      |  2 +
 .../scala/sigma/LanguageSpecificationV5.scala | 24 -------
 .../scala/sigma/LanguageSpecificationV6.scala | 72 +++++++++++++++++++
 .../test/scala/sigma/SigmaDslTesting.scala    | 11 ++-
 .../utxo/BasicOpsSpecification.scala          | 26 +++++++
 11 files changed, 145 insertions(+), 66 deletions(-)

diff --git a/core/shared/src/main/scala/sigma/ast/SType.scala b/core/shared/src/main/scala/sigma/ast/SType.scala
index 717439bcbb..46a639e37c 100644
--- a/core/shared/src/main/scala/sigma/ast/SType.scala
+++ b/core/shared/src/main/scala/sigma/ast/SType.scala
@@ -587,7 +587,7 @@ case class SFunc(tDom: IndexedSeq[SType],  tRange: SType, tpeParams: Seq[STypePa
 }
 
 object SFunc {
-  final val FuncTypeCode: TypeCode = TypeCodes.FirstFuncType
+  final val FuncTypeCode: TypeCode = TypeCodes.FuncType
   def apply(tDom: SType, tRange: SType): SFunc = SFunc(Array(tDom), tRange) // HOTSPOT:
   val identity = { x: Any => x }
 }
@@ -654,7 +654,6 @@ object SOption extends STypeCompanion {
   def apply[T <: SType](implicit elemType: T, ov: Overloaded1): SOption[T] = SOption(elemType)
 }
 
-
 /** Base class for descriptors of `Coll[T]` ErgoTree type for some elemType T. */
 trait SCollection[T <: SType] extends SProduct with SGenericType {
   def elemType: T
diff --git a/core/shared/src/main/scala/sigma/ast/STypeParam.scala b/core/shared/src/main/scala/sigma/ast/STypeParam.scala
index 56d89d01f8..08349ae024 100644
--- a/core/shared/src/main/scala/sigma/ast/STypeParam.scala
+++ b/core/shared/src/main/scala/sigma/ast/STypeParam.scala
@@ -2,18 +2,10 @@ package sigma.ast
 
 /** Represents a type parameter in a type system.
   *
-  * @param ident       The identifier for this type parameter.
-  * @param upperBound  The upper bound of this type parameter, if exists.
-  * @param lowerBound  The lower bound of this type parameter, if exists.
-  * @note Type parameters with bounds are currently not supported.
+  * @param ident       The identifier for this type parameter
   */
-case class STypeParam(
-    ident: STypeVar,
-    upperBound: Option[SType] = None,
-    lowerBound: Option[SType] = None) {
-  assert(upperBound.isEmpty && lowerBound.isEmpty, s"Type parameters with bounds are not supported, but found $this")
-
-  override def toString = ident.toString + upperBound.fold("")(u => s" <: $u") + lowerBound.fold("")(l => s" >: $l")
+case class STypeParam(ident: STypeVar) {
+  override def toString = ident.toString
 }
 
 object STypeParam {
diff --git a/core/shared/src/main/scala/sigma/ast/TypeCodes.scala b/core/shared/src/main/scala/sigma/ast/TypeCodes.scala
index 1b7b6121d6..68670449db 100644
--- a/core/shared/src/main/scala/sigma/ast/TypeCodes.scala
+++ b/core/shared/src/main/scala/sigma/ast/TypeCodes.scala
@@ -14,10 +14,8 @@ object TypeCodes {
 
   val LastDataType : TypeCode = TypeCode @@ 111.toByte
 
-  /** SFunc types occupy remaining space of byte values [FirstFuncType .. 255] */
-  val FirstFuncType: TypeCode = TypeCode @@ (LastDataType + 1).toByte
-
-  val LastFuncType : TypeCode = TypeCode @@ 255.toByte
+  /** SFunc type */
+  val FuncType: TypeCode = TypeCode @@ (LastDataType + 1).toByte
 
   /** We use optimized encoding of constant values to save space in serialization.
     * Since Box registers are stored as Constant nodes we save 1 byte for each register.
diff --git a/core/shared/src/main/scala/sigma/serialization/TypeSerializer.scala b/core/shared/src/main/scala/sigma/serialization/TypeSerializer.scala
index 9c84de0944..c21a3458c0 100644
--- a/core/shared/src/main/scala/sigma/serialization/TypeSerializer.scala
+++ b/core/shared/src/main/scala/sigma/serialization/TypeSerializer.scala
@@ -1,6 +1,7 @@
 package sigma.serialization
 
 import debox.cfor
+import sigma.VersionContext
 import sigma.ast.SCollectionType.{CollectionTypeCode, NestedCollectionTypeCode}
 import sigma.ast._
 import sigma.serialization.{CoreByteReader, CoreByteWriter, InvalidTypePrefix}
@@ -101,6 +102,17 @@ class TypeSerializer {
         // `Tuple` type with more than 4 items `(Int, Byte, Box, Boolean, Int)`
         serializeTuple(tup, w)
     }
+    case SFunc(tDom, tRange, tpeParams) =>
+      w.put(SFunc.FuncTypeCode)
+      w.putUByte(tDom.length)
+      tDom.foreach { st =>
+        serialize(st, w)
+      }
+      serialize(tRange, w)
+      w.putUByte(tpeParams.length)
+      tpeParams.foreach { tp =>
+        serialize(tp.ident, w)
+      }
     case typeIdent: STypeVar => {
       w.put(typeIdent.typeCode)
       val bytes = typeIdent.name.getBytes(StandardCharsets.UTF_8)
@@ -189,7 +201,24 @@ class TypeSerializer {
         case SHeader.typeCode => SHeader
         case SPreHeader.typeCode => SPreHeader
         case SGlobal.typeCode => SGlobal
+        case SFunc.FuncTypeCode if VersionContext.current.isV6SoftForkActivated =>
+          val tdLength = r.getUByte()
+
+          val tDom = (1 to tdLength).map { _ =>
+            deserialize(r)
+          }
+          val tRange = deserialize(r)
+          val tpeParamsLength = r.getUByte()
+          val tpeParams = (1 to tpeParamsLength).map { _ =>
+            val ident = deserialize(r)
+            require(ident.isInstanceOf[STypeVar])
+            STypeParam(ident.asInstanceOf[STypeVar])
+          }
+          SFunc(tDom, tRange, tpeParams)
+        // todo: serialize tParams
         case _ =>
+          // todo: 6.0: replace 1008 check with identical behavior but other opcode, to activate
+          //  ReplacedRule(1008 -> new opcode) during 6.0 activation
           CheckTypeCode(c.toByte)
           NoType
       }
diff --git a/interpreter/shared/src/test/scala/sigma/serialization/MethodCallSerializerSpecification.scala b/interpreter/shared/src/test/scala/sigma/serialization/MethodCallSerializerSpecification.scala
index f93f0ccaf7..da88a944d4 100644
--- a/interpreter/shared/src/test/scala/sigma/serialization/MethodCallSerializerSpecification.scala
+++ b/interpreter/shared/src/test/scala/sigma/serialization/MethodCallSerializerSpecification.scala
@@ -24,28 +24,6 @@ class MethodCallSerializerSpecification extends SerializationSpecification {
     roundTripTest(expr)
   }
 
-  property("MethodCall deserialization round trip for BigInt.nbits") {
-    def code = {
-      val bi = BigIntConstant(5)
-      val expr = MethodCall(bi,
-        SBigIntMethods.ToNBits,
-        Vector(),
-        Map()
-      )
-      roundTripTest(expr)
-    }
-
-    VersionContext.withVersions(VersionContext.V6SoftForkVersion, 1) {
-      code
-    }
-
-    an[ValidationException] should be thrownBy (
-      VersionContext.withVersions((VersionContext.V6SoftForkVersion - 1).toByte, 1) {
-        code
-      }
-      )
-  }
-
   property("MethodCall deserialization round trip for Header.checkPow") {
     def code = {
       val bi = HeaderConstant(headerGen.sample.get)
diff --git a/interpreter/shared/src/test/scala/sigma/serialization/generators/ObjectGenerators.scala b/interpreter/shared/src/test/scala/sigma/serialization/generators/ObjectGenerators.scala
index c9fc8f2c93..db6cd87330 100644
--- a/interpreter/shared/src/test/scala/sigma/serialization/generators/ObjectGenerators.scala
+++ b/interpreter/shared/src/test/scala/sigma/serialization/generators/ObjectGenerators.scala
@@ -26,7 +26,7 @@ import sigma.util.Extensions.EcpOps
 import sigma.validation.{ChangedRule, DisabledRule, EnabledRule, ReplacedRule, RuleStatus}
 import sigma.validation.ValidationRules.FirstRuleId
 import ErgoTree.ZeroHeader
-import sigma.data.{AvlTreeData, AvlTreeFlags, CAND, CBox, COR, CTHRESHOLD, Digest32Coll, ProveDHTuple, ProveDlog, RType, SigmaBoolean}
+import sigma.data.{AvlTreeData, AvlTreeFlags, CAND, CBox, CHeader, COR, CTHRESHOLD, Digest32Coll, ProveDHTuple, ProveDlog, RType, SigmaBoolean}
 import sigma.eval.Extensions.{EvalIterableOps, SigmaBooleanOps}
 import sigma.eval.SigmaDsl
 import sigma.interpreter.{ContextExtension, ProverResult}
diff --git a/parsers/shared/src/test/scala/sigmastate/helpers/SigmaPPrint.scala b/parsers/shared/src/test/scala/sigmastate/helpers/SigmaPPrint.scala
index 24aaeddefd..11381e1ac3 100644
--- a/parsers/shared/src/test/scala/sigmastate/helpers/SigmaPPrint.scala
+++ b/parsers/shared/src/test/scala/sigmastate/helpers/SigmaPPrint.scala
@@ -52,6 +52,8 @@ object SigmaPPrint extends PPrinter {
       s"SOption[${typeName(ot.elemType)}]"
     case _: STuple =>
       "STuple"
+    case _: SFunc =>
+      s"SFunc"
     case _ =>
       sys.error(s"Cannot get typeName($tpe)")
   }
diff --git a/sc/shared/src/test/scala/sigma/LanguageSpecificationV5.scala b/sc/shared/src/test/scala/sigma/LanguageSpecificationV5.scala
index 0d9a032a16..2c532c88d9 100644
--- a/sc/shared/src/test/scala/sigma/LanguageSpecificationV5.scala
+++ b/sc/shared/src/test/scala/sigma/LanguageSpecificationV5.scala
@@ -9820,30 +9820,6 @@ class LanguageSpecificationV5 extends LanguageSpecificationBase { suite =>
     }
   }
 
-  property("higher order lambdas") {
-    val f = existingFeature(
-      { (xs: Coll[Int]) =>
-        val inc = { (x: Int) => x + 1 }
-
-        def apply(in: (Int => Int, Int)) = in._1(in._2)
-
-        xs.map { (x: Int) => apply((inc, x)) }
-      },
-      """{(xs: Coll[Int]) =>
-       |   val inc = { (x: Int) => x + 1 }
-       |   def apply(in: (Int => Int, Int)) = in._1(in._2)
-       |   xs.map { (x: Int) => apply((inc, x)) }
-       | }
-       |""".stripMargin
-    )
-
-    // TODO v6.0: Add support of SFunc in TypeSerializer (see https://github.com/ScorexFoundation/sigmastate-interpreter/issues/847)
-    assertExceptionThrown(
-      f.verifyCase(Coll[Int](), Expected(Success(Coll[Int]()), 0)),
-      exceptionLike[MatchError]("(SInt$) => SInt$ (of class sigma.ast.SFunc)")
-    )
-  }
-
   override protected def afterAll(): Unit = {
     printDebug(CErgoTreeEvaluator.DefaultProfiler.generateReport)
     printDebug("==========================================================")
diff --git a/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala b/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
index 007bedfd20..f9aca8d607 100644
--- a/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
+++ b/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
@@ -11,6 +11,7 @@ import sigma.ast.syntax.TrueSigmaProp
 import sigma.ast._
 import sigma.data.{CBigInt, CHeader, CBox, ExactNumeric}
 import sigma.eval.{CostDetails, SigmaDsl, TracedCost}
+import sigma.serialization.ValueCodes.OpCode
 import sigma.util.Extensions.{BooleanOps, ByteOps, IntOps, LongOps}
 import sigmastate.exceptions.MethodNotFound
 import sigmastate.utils.Helpers
@@ -513,4 +514,75 @@ class LanguageSpecificationV6 extends LanguageSpecificationBase { suite =>
     )
   }
 
+  property("higher order lambdas") {
+    val f = newFeature[Coll[Int], Coll[Int]](
+      { (xs: Coll[Int]) =>
+        val inc = { (x: Int) => x + 1 }
+
+        def apply(in: (Int => Int, Int)) = in._1(in._2)
+
+        xs.map { (x: Int) => apply((inc, x)) }
+      },
+      """{(xs: Coll[Int]) =>
+        |   val inc = { (x: Int) => x + 1 }
+        |   def apply(in: (Int => Int, Int)) = in._1(in._2)
+        |   xs.map { (x: Int) => apply((inc, x)) }
+        | }
+        |""".stripMargin,
+      FuncValue(
+        Array((1, SCollectionType(SInt))),
+        MapCollection(
+          ValUse(1, SCollectionType(SInt)),
+          FuncValue(
+            Array((3, SInt)),
+            Apply(
+              FuncValue(
+                Array((5, SPair(SFunc(Array(SInt), SInt, List()), SInt))),
+                Apply(
+                  SelectField.typed[Value[SFunc]](
+                    ValUse(5, SPair(SFunc(Array(SInt), SInt, List()), SInt)),
+                    1.toByte
+                  ),
+                  Array(
+                    SelectField.typed[Value[SInt.type]](
+                      ValUse(5, SPair(SFunc(Array(SInt), SInt, List()), SInt)),
+                      2.toByte
+                    )
+                  )
+                )
+              ),
+              Array(
+                Tuple(
+                  Vector(
+                    FuncValue(
+                      Array((5, SInt)),
+                      ArithOp(ValUse(5, SInt), IntConstant(1), OpCode @@ (-102.toByte))
+                    ),
+                    ValUse(3, SInt)
+                  )
+                )
+              )
+            )
+          )
+        )
+      ),
+    sinceVersion = VersionContext.V6SoftForkVersion
+    )
+
+    verifyCases(
+      Seq(
+        Coll(1, 2) -> Expected(
+          Success(Coll(2, 3)),
+          cost = 1793,
+          expectedDetails = CostDetails.ZeroCost
+        )
+      ),
+      f,
+      preGeneratedSamples = Some(Seq(
+        Coll(Int.MinValue, Int.MaxValue - 1),
+        Coll(0, 1, 2, 3, 100, 1000)
+      ))
+    )
+  }
+
 }
diff --git a/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala b/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
index 4410786fd4..d334ac4653 100644
--- a/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
+++ b/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
@@ -261,6 +261,7 @@ class SigmaDslTesting extends AnyPropSpec
             s"""Should succeed with the same value or fail with the same exception, but was:
               |First result: $b1
               |Second result: $b2
+              |Input: $x
               |Root cause: $cause
               |""".stripMargin)
       }
@@ -715,11 +716,17 @@ class SigmaDslTesting extends AnyPropSpec
     override def checkEquality(input: A, logInputOutput: Boolean = false): Try[(B, CostDetails)] = {
       // check the old implementation against Scala semantic function
       var oldRes: Try[(B, CostDetails)] = null
-      if (ergoTreeVersionInTests < VersionContext.JitActivationVersion)
         oldRes = VersionContext.withVersions(activatedVersionInTests, ergoTreeVersionInTests) {
           try checkEq(scalaFunc)(oldF)(input)
           catch {
-            case e: TestFailedException => throw e
+            case e: TestFailedException =>
+              if(activatedVersionInTests < changedInVersion) {
+                throw e
+              } else {
+                // old ergoscript may succeed in new version while old scalafunc may fail,
+                // see e.g. "Option.getOrElse with lazy default" test
+                Failure(e)
+              }
             case t: Throwable =>
               Failure(t)
           }
diff --git a/sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala b/sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala
index d80e39273f..f9d4d21235 100644
--- a/sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala
@@ -458,6 +458,32 @@ class BasicOpsSpecification extends CompilerTestingCommons
       rootCause(_).isInstanceOf[NoSuchElementException])
   }
 
+  property("higher order lambdas") {
+    def holTest() = test("HOL", env, ext,
+      """
+        | {
+        |   val c = Coll(Coll(1))
+        |   def fn(xs: Coll[Int]) = {
+        |     val inc = { (x: Int) => x + 1 }
+        |     def apply(in: (Int => Int, Int)) = in._1(in._2)
+        |     val ys = xs.map { (x: Int) => apply((inc, x)) }
+        |     ys.size == xs.size && ys != xs
+        |   }
+        |
+        |   c.exists(fn)
+        | }
+        |""".stripMargin,
+      null,
+      true
+    )
+
+    if(VersionContext.current.isV6SoftForkActivated) {
+      holTest()
+    } else {
+      an[Exception] shouldBe thrownBy(holTest())
+    }
+  }
+
   property("OptionGetOrElse") {
     test("OptGet1", env, ext,
       "{ SELF.R5[Int].getOrElse(3) == 1 }",