From 361c7a4400b19bec95ab98549f7911c2990a4c8f Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Wed, 5 Jun 2024 14:13:23 +0300
Subject: [PATCH 01/14] merging with i969, removing BouncyCastle dep from
 Autolykos2PowValidation

---
 .../src/main/scala/sigma/SigmaDsl.scala       |  10 ++
 .../scala/org/ergoplatform/ErgoHeader.scala   | 159 ++++++++++++++++++
 .../org/ergoplatform/HeaderWithoutPow.scala   |   8 +-
 .../sigma/pow/Autolykos2PowValidation.scala   |   6 +-
 .../sigma/compiler/ir/GraphBuilding.scala     |   2 +-
 .../TestingInterpreterSpecification.scala     |   4 -
 6 files changed, 179 insertions(+), 10 deletions(-)
 create mode 100644 data/shared/src/main/scala/org/ergoplatform/ErgoHeader.scala

diff --git a/core/shared/src/main/scala/sigma/SigmaDsl.scala b/core/shared/src/main/scala/sigma/SigmaDsl.scala
index a2894515a2..1e5b5405eb 100644
--- a/core/shared/src/main/scala/sigma/SigmaDsl.scala
+++ b/core/shared/src/main/scala/sigma/SigmaDsl.scala
@@ -460,10 +460,20 @@ 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 bytes without proof of work, needed for working to get the proof on
+    */
   def serializeWithoutPoW: Coll[Byte]
 
+  /**
+    * @return result of header's proof-of-work validation
+    */
   def checkPow: Boolean
 
 }
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..b937bef7a3
--- /dev/null
+++ b/data/shared/src/main/scala/org/ergoplatform/ErgoHeader.scala
@@ -0,0 +1,159 @@
+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}
+
+
+/**
+  * 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.
+  */
+case class AutolykosSolution(pk: EcPointType,
+                             w: EcPointType,
+                             n: Array[Byte],
+                             d: BigInt) {
+
+    val encodedPk: Array[Byte] = GroupElementSerializer.toBytes(pk)
+
+}
+
+
+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)))
+            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)
+            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
index d29cc6cbd8..4eba9b708e 100644
--- a/data/shared/src/main/scala/org/ergoplatform/HeaderWithoutPow.scala
+++ b/data/shared/src/main/scala/org/ergoplatform/HeaderWithoutPow.scala
@@ -6,8 +6,6 @@ import scorex.util.{ModifierId, bytesToId, idToBytes}
 import sigma.serialization.{SigmaByteReader, SigmaByteWriter, SigmaSerializer}
 import scorex.util.Extensions._
 
-//todo: unify with Ergo node codebase
-
 /**
   * Header without proof-of-work puzzle solution, see Header class description for details.
   */
@@ -21,7 +19,11 @@ class HeaderWithoutPow(val version:  Byte, // 1 byte
                        val height: Int,
                        val extensionRoot: Digest32,
                        val votes: Array[Byte], //3 bytes
-                       val unparsedBytes: Array[Byte])
+                       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)
+}
 
 object HeaderWithoutPow {
 
diff --git a/data/shared/src/main/scala/sigma/pow/Autolykos2PowValidation.scala b/data/shared/src/main/scala/sigma/pow/Autolykos2PowValidation.scala
index a27dc864d1..c2166493e6 100644
--- a/data/shared/src/main/scala/sigma/pow/Autolykos2PowValidation.scala
+++ b/data/shared/src/main/scala/sigma/pow/Autolykos2PowValidation.scala
@@ -1,13 +1,15 @@
 package sigma.pow
 
 
-import org.bouncycastle.util.BigIntegers
 import scorex.crypto.hash.Blake2b256
 import scorex.utils.{Bytes, Ints, Longs}
 import sigma.Header
-import sigma.crypto.{BcDlogGroup, CryptoConstants}
+import sigma.crypto.{BcDlogGroup, BigIntegers, CryptoConstants}
 import sigma.util.NBitsUtils
 
+/**
+  * Functions used to validate Autolykos2 Proof-of-Work
+  */
 object Autolykos2PowValidation {
 
   type Height = Int
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 fc2efd2970..f9fc2b2545 100644
--- a/sc/shared/src/main/scala/sigma/compiler/ir/GraphBuilding.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/ir/GraphBuilding.scala
@@ -13,7 +13,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
diff --git a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
index 4948f70c23..23d623f077 100644
--- a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
@@ -13,7 +13,6 @@ import org.scalatest.BeforeAndAfterAll
 import scorex.util.encode.Base58
 import sigma.Colls
 import sigma.VersionContext.V6SoftForkVersion
-import sigma.crypto.CryptoConstants
 import sigma.data.{CAND, CAvlTree, ProveDlog, SigmaBoolean, TrivialProp}
 import sigma.interpreter.ContextExtension
 import sigma.util.Extensions.IntOps
@@ -439,9 +438,6 @@ class TestingInterpreterSpecification extends CompilerTestingCommons
   }
 
   property("checkPow") {
-
-    //todo: check invalid header
-
     val source = """ {
                    |     val h = CONTEXT.headers(0)
                    |      h.checkPow

From 15de2e2d7004e00b2e6de4e79ee7fac9b057d9b7 Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Wed, 5 Jun 2024 19:31:56 +0300
Subject: [PATCH 02/14] merging i969

---
 .../shared/src/main/scala/sigma/data}/CHeader.scala            | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
 rename {interpreter/shared/src/main/scala/sigmastate/eval => data/shared/src/main/scala/sigma/data}/CHeader.scala (96%)

diff --git a/interpreter/shared/src/main/scala/sigmastate/eval/CHeader.scala b/data/shared/src/main/scala/sigma/data/CHeader.scala
similarity index 96%
rename from interpreter/shared/src/main/scala/sigmastate/eval/CHeader.scala
rename to data/shared/src/main/scala/sigma/data/CHeader.scala
index 3bd0dd62f9..46f6f9b7b5 100644
--- a/interpreter/shared/src/main/scala/sigmastate/eval/CHeader.scala
+++ b/data/shared/src/main/scala/sigma/data/CHeader.scala
@@ -1,10 +1,9 @@
-package sigmastate.eval
+package sigma.data
 
 import org.ergoplatform.{HeaderWithoutPow, HeaderWithoutPowSerializer}
 import scorex.crypto.authds.ADDigest
 import scorex.crypto.hash.Digest32
 import scorex.util.bytesToId
-import sigma.data.SigmaConstants
 import sigma.pow.Autolykos2PowValidation
 import sigma.{AvlTree, BigInt, Coll, Colls, GroupElement, Header}
 

From 17f5eb6fdd3aa706e51fb6c31c59b2af0994beea Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Wed, 5 Jun 2024 19:36:19 +0300
Subject: [PATCH 03/14] CHeader from i969

---
 .../src/main/scala/sigma/data/CHeader.scala   | 135 +++++++++++++++---
 .../sigma/serialization/DataSerializer.scala  |  14 +-
 .../ConstantSerializerSpecification.scala     |  41 ++++--
 .../DataSerializerSpecification.scala         | 135 +++++++++++++-----
 .../SerializationSpecification.scala          |  21 ++-
 .../generators/ObjectGenerators.scala         |   7 +-
 .../generators/TypeGenerators.scala           |   3 +-
 .../special/sigma/SigmaTestingData.scala      |  13 +-
 .../scala/sigma/SigmaDslSpecification.scala   |  20 +--
 .../scala/sigmastate/TypesSpecification.scala |   2 -
 .../scala/org/ergoplatform/sdk/js/Isos.scala  |   6 +-
 .../ergoplatform/sdk/DataJsonEncoder.scala    |   8 ++
 .../org/ergoplatform/sdk/JsonCodecs.scala     |   5 +-
 .../sdk/DataJsonEncoderSpecification.scala    |  92 +++++++++---
 14 files changed, 368 insertions(+), 134 deletions(-)

diff --git a/data/shared/src/main/scala/sigma/data/CHeader.scala b/data/shared/src/main/scala/sigma/data/CHeader.scala
index 46f6f9b7b5..4e1cec2413 100644
--- a/data/shared/src/main/scala/sigma/data/CHeader.scala
+++ b/data/shared/src/main/scala/sigma/data/CHeader.scala
@@ -1,9 +1,9 @@
 package sigma.data
 
-import org.ergoplatform.{HeaderWithoutPow, HeaderWithoutPowSerializer}
+import org.ergoplatform.{AutolykosSolution, ErgoHeader, HeaderWithoutPow, HeaderWithoutPowSerializer}
 import scorex.crypto.authds.ADDigest
 import scorex.crypto.hash.Digest32
-import scorex.util.bytesToId
+import scorex.util.{bytesToId, idToBytes}
 import sigma.pow.Autolykos2PowValidation
 import sigma.{AvlTree, BigInt, Coll, Colls, GroupElement, Header}
 
@@ -11,24 +11,60 @@ import sigma.{AvlTree, BigInt, Coll, Colls, GroupElement, Header}
   *
   * @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],
-    unparsedBytes: Coll[Byte]
-) extends Header {
+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] = {
     val headerWithoutPow = HeaderWithoutPow(version, bytesToId(parentId.toArray), Digest32 @@ ADProofsRoot.toArray,
@@ -41,12 +77,69 @@ case class CHeader(
     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 = 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
-}
\ No newline at end of file
+
+}
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/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/SerializationSpecification.scala b/interpreter/shared/src/test/scala/sigma/serialization/SerializationSpecification.scala
index 30ae6af19b..dc8eef7319 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, 1) {
+          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 e625923413..bd77766830 100644
--- a/interpreter/shared/src/test/scala/sigma/serialization/generators/ObjectGenerators.scala
+++ b/interpreter/shared/src/test/scala/sigma/serialization/generators/ObjectGenerators.scala
@@ -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
@@ -708,8 +708,9 @@ trait ObjectGenerators extends TypeGenerators
     powDistance <- arbBigInt.arbitrary
     votes <- minerVotesGen
     unparsedBytes <- collOfRange(0, 32, arbByte.arbitrary)
-  } yield CHeader(id, version, parentId, adProofsRoot, stateRoot, transactionRoot, timestamp, nBits,
-    height, extensionRoot, minerPk.toGroupElement, powOnetimePk.toGroupElement, powNonce, powDistance, votes, unparsedBytes)
+  } 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 6b8c833931..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,
@@ -268,7 +267,7 @@ trait SigmaTestingData extends TestingCommons with ObjectGenerators {
 
     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/test/scala/sigma/SigmaDslSpecification.scala b/sc/shared/src/test/scala/sigma/SigmaDslSpecification.scala
index 1977537cbf..c4d1db777d 100644
--- a/sc/shared/src/test/scala/sigma/SigmaDslSpecification.scala
+++ b/sc/shared/src/test/scala/sigma/SigmaDslSpecification.scala
@@ -41,11 +41,11 @@ import scala.util.{Failure, Success}
 /** This suite tests every method of every SigmaDsl type to be equivalent to
   * the evaluation of the corresponding ErgoScript operation.
   *
-  * The properties of this suite excercise two interpreters: the current (aka `old`
+  * The properties of this suite exercise two interpreters: the current (aka `old`
   * interpreter) and the new interpreter for a next soft-fork. After the soft-fork is
   * released, the new interpreter becomes current at which point the `old` and `new`
   * interpreters in this suite should be equivalent. This change is reflected in this
-  * suite by commiting changes in expected values.
+  * suite by committing changes in expected values.
   * The `old` and `new` interpreters are compared like the following:
   * 1) for existingFeature the interpreters should be equivalent
   * 2) for changedFeature the test cases contain different expected values
@@ -53,7 +53,7 @@ import scala.util.{Failure, Success}
   * against expected values.
   *
   * This suite can be used for Cost profiling, i.e. measurements of operations times and
-  * comparing them with cost parameteres of the operations.
+  * comparing them with cost parameters of the operations.
   *
   * The following settings should be specified for profiling:
   * isMeasureOperationTime = true
@@ -4516,7 +4516,7 @@ class SigmaDslSpecification extends SigmaDslTesting
   property("Header properties equivalence") {
     verifyCases(
       Seq((h1, Expected(Success(
-        Helpers.decodeBytes("957f008001808080ffe4ffffc8f3802401df40006aa05e017fa8d3f6004c804a")),
+        Helpers.decodeBytes("cea31f0e0a794b103f65f8296a22ac8ff214e1bc75442186b90df4844c978e81")),
         cost = 1766, methodCostDetails(SHeaderMethods.idMethod, 10), 1766))),
       existingPropTest("id", { (x: Header) => x.id }))
 
@@ -4654,18 +4654,10 @@ class SigmaDslSpecification extends SigmaDslTesting
     )
 
     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,
@@ -4684,7 +4676,7 @@ class SigmaDslSpecification extends SigmaDslTesting
       headers = Coll[Header](header),
       preHeader = CPreHeader(
         0.toByte,
-        Helpers.decodeBytes("1c597f88969600d2fffffdc47f00d8ffc555a9e85001000001c505ff80ff8f7f"),
+        header.id,
         -755484979487531112L,
         9223372036854775807L,
         11,
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/sdk/js/src/main/scala/org/ergoplatform/sdk/js/Isos.scala b/sdk/js/src/main/scala/org/ergoplatform/sdk/js/Isos.scala
index 91be0ca61c..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),
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 c2fc1c0c8c..1c7a4156f4 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}
@@ -132,7 +132,6 @@ trait JsonCodecs {
 
   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]]
@@ -148,7 +147,7 @@ trait JsonCodecs {
       powDistance <- cursor.downField("powDistance").as[sigma.BigInt]
       votes <- cursor.downField("votes").as[Coll[Byte]]
       unparsedBytes <- cursor.downField("unparsedBytes").as[Option[Coll[Byte]]]
-    } yield new CHeader(id, version, parentId, adProofsRoot, stateRoot, transactionsRoot, timestamp, nBits,
+    } 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))
   })
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..33e9546000 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, 1) {
+          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, 1) {
+        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 fd8d6ebe872ae2c384a71e53f4bc6f587f269f84 Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Wed, 5 Jun 2024 19:58:55 +0300
Subject: [PATCH 04/14] checkPow cost

---
 data/shared/src/main/scala/sigma/ast/methods.scala          | 6 +++---
 .../scala/sigmastate/interpreter/CErgoTreeEvaluator.scala   | 6 ++----
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/data/shared/src/main/scala/sigma/ast/methods.scala b/data/shared/src/main/scala/sigma/ast/methods.scala
index e58fa35adb..1208e36f7f 100644
--- a/data/shared/src/main/scala/sigma/ast/methods.scala
+++ b/data/shared/src/main/scala/sigma/ast/methods.scala
@@ -10,7 +10,6 @@ import sigma.ast.syntax.{SValue, ValueOps}
 import sigma.data.OverloadHack.Overloaded1
 import sigma.data.{DataValueComparer, KeyValueColl, Nullable, RType, SigmaConstants}
 import sigma.eval.{CostDetails, ErgoTreeEvaluator, TracedCost}
-import sigma.pow.Autolykos2PowValidation
 import sigma.reflection.RClass
 import sigma.serialization.CoreByteWriter.ArgInfo
 import sigma.utils.SparseArrayContainer
@@ -1457,10 +1456,11 @@ 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)))
 
+  // 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, GroupGenerator.costKind) // todo: cost
+    this, "checkPow", SFunc(Array(SHeader), SBoolean), 16, FixedCost(JitCost(700)))
     .withIRInfo(MethodCallIrBuilder)
-    .withInfo(Xor, "Byte-wise XOR of two collections of bytes") // todo: desc
+    .withInfo("Validate headers' proof-of-work")
 
   def checkPow_eval(mc: MethodCall, G: SigmaDslBuilder, header: Header)
                  (implicit E: ErgoTreeEvaluator): Boolean = {
diff --git a/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala b/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala
index 59c9af09ef..1c58e00a97 100644
--- a/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala
+++ b/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala
@@ -10,11 +10,11 @@ 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 sigma.pow.Autolykos2PowValidation
 import sigmastate.interpreter.CErgoTreeEvaluator.fixedCostOp
 
 import scala.collection.compat.immutable.ArraySeq
@@ -219,9 +219,7 @@ class CErgoTreeEvaluator(
   }
 
   override def checkPow_eval(mc: MethodCall, header: Header): Boolean = {
-    VersionContext.checkVersions(context.activatedScriptVersion, context.currentErgoTreeVersion)
-    // todo: consider cost
-    val checkPowCostInfo = OperationCostInfo(FixedCost(JitCost(10)), NamedDesc("Header.checkPow"))
+    val checkPowCostInfo = OperationCostInfo(checkPowMethod.costKind.asInstanceOf[FixedCost], NamedDesc("Header.checkPow"))
     fixedCostOp(checkPowCostInfo){
       header.checkPow
     }(this)

From 928d8cb38b8aaf0aa36546294c56392ebac71c3f Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Wed, 5 Jun 2024 22:31:31 +0300
Subject: [PATCH 05/14] LangSpec.md update

---
 docs/LangSpec.md | 4 ++++
 1 file changed, 4 insertions(+)

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]
 

From 01ede1c36047b9fa0797e39964523b7dea74e7b8 Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Mon, 10 Jun 2024 18:26:38 +0300
Subject: [PATCH 06/14] MethodCallSerializerSpecification fix

---
 .../sigma/serialization/MethodCallSerializerSpecification.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/shared/src/test/scala/sigma/serialization/MethodCallSerializerSpecification.scala b/interpreter/shared/src/test/scala/sigma/serialization/MethodCallSerializerSpecification.scala
index c65b86930c..f93f0ccaf7 100644
--- a/interpreter/shared/src/test/scala/sigma/serialization/MethodCallSerializerSpecification.scala
+++ b/interpreter/shared/src/test/scala/sigma/serialization/MethodCallSerializerSpecification.scala
@@ -61,7 +61,7 @@ class MethodCallSerializerSpecification extends SerializationSpecification {
       code
     }
 
-    an[ValidationException] should be thrownBy (
+    an[Exception] should be thrownBy (
       VersionContext.withVersions((VersionContext.V6SoftForkVersion - 1).toByte, 1) {
         code
       }

From 40d5e54447b57e187770437fedbad5acb9d3589c Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Mon, 10 Jun 2024 22:07:19 +0300
Subject: [PATCH 07/14] relaxed check in check pow test before activation

---
 data/shared/src/main/scala/sigma/ast/methods.scala              | 2 +-
 .../test/scala/sigmastate/TestingInterpreterSpecification.scala | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/data/shared/src/main/scala/sigma/ast/methods.scala b/data/shared/src/main/scala/sigma/ast/methods.scala
index 1208e36f7f..71ac0a1e1f 100644
--- a/data/shared/src/main/scala/sigma/ast/methods.scala
+++ b/data/shared/src/main/scala/sigma/ast/methods.scala
@@ -1460,7 +1460,7 @@ case object SHeaderMethods extends MonoTypeMethods {
   lazy val checkPowMethod = SMethod(
     this, "checkPow", SFunc(Array(SHeader), SBoolean), 16, FixedCost(JitCost(700)))
     .withIRInfo(MethodCallIrBuilder)
-    .withInfo("Validate headers' proof-of-work")
+    .withInfo("Validate header's proof-of-work")
 
   def checkPow_eval(mc: MethodCall, G: SigmaDslBuilder, header: Header)
                  (implicit E: ErgoTreeEvaluator): Boolean = {
diff --git a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
index 23d623f077..2c048aad8b 100644
--- a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
@@ -445,7 +445,7 @@ class TestingInterpreterSpecification extends CompilerTestingCommons
                    | """.stripMargin
 
     if (activatedVersionInTests < V6SoftForkVersion) {
-      an [sigmastate.exceptions.MethodNotFound] should be thrownBy testEval(source)
+      an [Exception] should be thrownBy testEval(source)
     } else {
       testEval(source)
     }

From e501a8bbcaff2142266e279b4254e4f0aa904130 Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Fri, 26 Jul 2024 18:23:19 +0300
Subject: [PATCH 08/14] polishing, LSV6 test

---
 .../src/main/scala/sigma/ast/methods.scala    | 19 ++++++------
 .../scala/sigma/eval/ErgoTreeEvaluator.scala  |  1 +
 .../interpreter/CErgoTreeEvaluator.scala      |  1 +
 .../scala/sigma/LanguageSpecificationV6.scala | 30 ++++++++++++++++++-
 4 files changed, 41 insertions(+), 10 deletions(-)

diff --git a/data/shared/src/main/scala/sigma/ast/methods.scala b/data/shared/src/main/scala/sigma/ast/methods.scala
index 71ac0a1e1f..487665aa2c 100644
--- a/data/shared/src/main/scala/sigma/ast/methods.scala
+++ b/data/shared/src/main/scala/sigma/ast/methods.scala
@@ -1467,18 +1467,19 @@ case object SHeaderMethods extends MonoTypeMethods {
     E.checkPow_eval(mc, header)
   }
 
+  private lazy val v5Methods = super.getMethods() ++ Seq(
+    idMethod, versionMethod, parentIdMethod, ADProofsRootMethod, stateRootMethod, transactionsRootMethod,
+    timestampMethod, nBitsMethod, heightMethod, extensionRootMethod, minerPkMethod, powOnetimePkMethod,
+    powNonceMethod, powDistanceMethod, votesMethod)
+
+  // 6.0 : checkPow method added
+  private lazy val v6Methods = v5Methods ++ Seq(checkPowMethod)
+
   protected override def getMethods() = {
     if (VersionContext.current.isV6SoftForkActivated) {
-      // 6.0 : checkPow method added
-      super.getMethods() ++ Seq(
-        idMethod, versionMethod, parentIdMethod, ADProofsRootMethod, stateRootMethod, transactionsRootMethod,
-        timestampMethod, nBitsMethod, heightMethod, extensionRootMethod, minerPkMethod, powOnetimePkMethod,
-        powNonceMethod, powDistanceMethod, votesMethod, checkPowMethod)
+      v6Methods
     } else {
-      super.getMethods() ++ Seq(
-        idMethod, versionMethod, parentIdMethod, ADProofsRootMethod, stateRootMethod, transactionsRootMethod,
-        timestampMethod, nBitsMethod, heightMethod, extensionRootMethod, minerPkMethod, powOnetimePkMethod,
-        powNonceMethod, powDistanceMethod, votesMethod)
+      v5Methods
     }
   }
 }
diff --git a/data/shared/src/main/scala/sigma/eval/ErgoTreeEvaluator.scala b/data/shared/src/main/scala/sigma/eval/ErgoTreeEvaluator.scala
index 610be08c9c..b95c034bd2 100644
--- a/data/shared/src/main/scala/sigma/eval/ErgoTreeEvaluator.scala
+++ b/data/shared/src/main/scala/sigma/eval/ErgoTreeEvaluator.scala
@@ -139,6 +139,7 @@ abstract class ErgoTreeEvaluator {
       mc: MethodCall, tree: AvlTree,
       operations: Coll[Coll[Byte]], proof: Coll[Byte]): Option[AvlTree]
 
+  /** Implements evaluation of Header.checkPow method call ErgoTree node. */
   def checkPow_eval(mc: MethodCall, header: Header): Boolean
 
 }
diff --git a/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala b/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala
index 1c58e00a97..c0759f4a5c 100644
--- a/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala
+++ b/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala
@@ -218,6 +218,7 @@ class CErgoTreeEvaluator(
     }
   }
 
+  /** Implements evaluation of Header.checkPow method call ErgoTree node. */
   override def checkPow_eval(mc: MethodCall, header: Header): Boolean = {
     val checkPowCostInfo = OperationCostInfo(checkPowMethod.costKind.asInstanceOf[FixedCost], NamedDesc("Header.checkPow"))
     fixedCostOp(checkPowCostInfo){
diff --git a/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala b/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
index 3b3de407b5..62425f747e 100644
--- a/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
+++ b/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
@@ -1,6 +1,6 @@
 package sigma
 
-import sigma.ast.{Apply, Downcast, FixedCost, FixedCostItem, FuncValue, GetVar, JitCost, OptionGet, SBigInt, SByte, SInt, SLong, SShort, ValUse}
+import sigma.ast.{Apply, Downcast, FixedCost, FixedCostItem, FuncValue, GetVar, JitCost, MethodCall, OptionGet, SBigInt, SBoolean, SByte, SHeader, SHeaderMethods, SInt, SLong, SShort, ValUse, Value}
 import sigma.data.{CBigInt, ExactNumeric}
 import sigma.eval.SigmaDsl
 import sigma.util.Extensions.{BooleanOps, ByteOps, IntOps, LongOps}
@@ -338,6 +338,34 @@ class LanguageSpecificationV6 extends LanguageSpecificationBase { suite =>
     }
   }
 
+  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.getMethodByName("checkPow"),
+          IndexedSeq(),
+          Map()
+        )
+      ),
+      sinceVersion = VersionContext.V6SoftForkVersion)
+
+    if (VersionContext.current.isV6SoftForkActivated) {
+      forAll { x: Header =>
+        Seq(checkPoW).map(_.checkEquality(x))
+      }
+    } else {
+      an[Exception] shouldBe thrownBy {
+        forAll { x: Header =>
+          Seq(checkPoW).map(_.checkEquality(x))
+        }
+      }
+    }
+
+  }
+
   // TODO v6.0: implement Option.fold (see https://github.com/ScorexFoundation/sigmastate-interpreter/issues/479)
   property("Option new methods") {
     val n = ExactNumeric.LongIsExactNumeric

From 89f2df66040ef3067f8174c08527f900bebf0dd9 Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Wed, 31 Jul 2024 13:34:25 +0300
Subject: [PATCH 09/14] checkPoW added to collectMethods

---
 .../sigma/compiler/ir/wrappers/sigma/impl/SigmaDslImpl.scala    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 8d1b3aa1f5..e73d3bbeec 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
@@ -1523,7 +1523,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"
         ))
     }
   }

From ba878b8820e157af17921a4e600499bc8f478f1c Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Wed, 31 Jul 2024 22:51:26 +0300
Subject: [PATCH 10/14] fixing GraphIRReflection for checkPow, test for
 isoHeader for known vector

---
 .gitignore                                    |  1 +
 .../src/main/scala/sigma/ast/methods.scala    |  2 +-
 .../sigma/compiler/ir/GraphIRReflection.scala |  3 ++
 .../org/ergoplatform/sdk/js/Header.scala      |  2 +-
 .../org/ergoplatform/sdk/js/IsosSpec.scala    | 45 ++++++++++++++++++-
 5 files changed, 50 insertions(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index df18ce8ab1..5fe37e6b74 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,7 @@
 *.gz
 
 *.log
+yarn.lock
 docs/spec/out/
 test-out/
 flamegraphs/
diff --git a/data/shared/src/main/scala/sigma/ast/methods.scala b/data/shared/src/main/scala/sigma/ast/methods.scala
index 487665aa2c..c299d9f53a 100644
--- a/data/shared/src/main/scala/sigma/ast/methods.scala
+++ b/data/shared/src/main/scala/sigma/ast/methods.scala
@@ -1460,7 +1460,7 @@ case object SHeaderMethods extends MonoTypeMethods {
   lazy val checkPowMethod = SMethod(
     this, "checkPow", SFunc(Array(SHeader), SBoolean), 16, FixedCost(JitCost(700)))
     .withIRInfo(MethodCallIrBuilder)
-    .withInfo("Validate header's proof-of-work")
+    .withInfo(MethodCall, "Validate header's proof-of-work")
 
   def checkPow_eval(mc: MethodCall, G: SigmaDslBuilder, header: Header)
                  (implicit E: ErgoTreeEvaluator): Boolean = {
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/sdk/js/src/main/scala/org/ergoplatform/sdk/js/Header.scala b/sdk/js/src/main/scala/org/ergoplatform/sdk/js/Header.scala
index ec3767c1cd..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,
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..da44cf14ef 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 {
@@ -59,6 +61,47 @@ class IsosSpec extends IsosSpecBase with sdk.generators.ObjectGenerators {
     }
   }
 
+  property("Iso.isoHeader - test vector") {
+    // valid header from Ergo blockchain
+    val headerJson =
+      """
+        |{
+        |  "extensionId" : "00cce45975d87414e8bdd8146bc88815be59cd9fe37a125b5021101e05675a18",
+        |  "votes" : "000000",
+        |  "timestamp" : 4928911477310178288,
+        |  "size" : 223,
+        |  "unparsedBytes" : "",
+        |  "stateRoot" : {
+        |      "digest" : "5c8c00b8403d3701557181c8df800001b6d5009e2201c6ff807d71808c00019780",
+        |      "treeFlags" : "0",
+        |      "keyLength" : "32"
+        |  },
+        |  "height" : 614400,
+        |  "nBits" : 37748736,
+        |  "version" : 2,
+        |  "id" : "5603a937ec1988220fc44fb5022fb82d5565b961f005ebb55d85bd5a9e6f801f",
+        |  "adProofsRoot" : "5d3f80dcff7f5e7f59007294c180808d0158d1ff6ba10000f901c7f0ef87dcff",
+        |  "transactionsRoot" : "f17fffacb6ff7f7f1180d2ff7f1e24ffffe1ff937f807f0797b9ff6ebdae007e",
+        |  "extensionRoot" : "1480887f80007f4b01cf7f013ff1ffff564a0000b9a54f00770e807f41ff88c0",
+        |  "minerPk" : "03bedaee069ff4829500b3c07c4d5fe6b3ea3d3bf76c5c28c1d4dcdb1bed0ade0c",
+        |  "powOnetimePk" : "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+        |  "powNonce" : "0000000000003105",
+        |  "powDistance" : 0,
+        |  "adProofsId" : "dec129290a763f4de41f04e87e2b661dd59758af6bdd00dd51f5d97c3a8cb9b5",
+        |  "transactionsId" : "eba1dd82cf51147232e09c1f72b37c554c30f63274d5093bff36849a83472a42",
+        |  "parentId" : "ac2101807f0000ca01ff0119db227f202201007f62000177a080005d440896d0"
+        |}
+        |""".stripMargin
+
+    object JsonCodecs extends JsonCodecs
+    val c = JsonCodecs.headerDecoder.decodeJson(parse(headerJson).toOption.get).toOption.get
+
+    roundtrip(Isos.isoHeader)(c)
+
+    val jh = Isos.isoHeader.from(c)
+    Isos.isoHeader.to(jh).serializeWithoutPoW shouldBe c.serializeWithoutPoW
+  }
+
   property("Iso.isoPreHeader") {
     forAll { (c: sigma.PreHeader) =>
       roundtrip(Isos.isoPreHeader)(c)

From b41d16c5df0dcd9e7981985a783eb8a95b2d35f2 Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Wed, 31 Jul 2024 23:35:36 +0300
Subject: [PATCH 11/14] test vectors for Blake2b256 and Long -> BigInt

---
 .../org/ergoplatform/HeaderWithoutPow.scala   |  6 ++++++
 .../TestingInterpreterSpecification.scala     | 19 ++++++++++++++++++-
 .../org/ergoplatform/sdk/js/IsosSpec.scala    |  6 ++++++
 3 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/data/shared/src/main/scala/org/ergoplatform/HeaderWithoutPow.scala b/data/shared/src/main/scala/org/ergoplatform/HeaderWithoutPow.scala
index 4eba9b708e..21a10a5036 100644
--- a/data/shared/src/main/scala/org/ergoplatform/HeaderWithoutPow.scala
+++ b/data/shared/src/main/scala/org/ergoplatform/HeaderWithoutPow.scala
@@ -23,6 +23,12 @@ class HeaderWithoutPow(val version:  Byte, // 1 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 {
diff --git a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
index 13af8bd6b3..9e004aef30 100644
--- a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
@@ -14,7 +14,6 @@ import scorex.util.encode.Base58
 import sigma.Colls
 import sigma.VersionContext.V6SoftForkVersion
 import sigma.VersionContext
-import sigma.crypto.CryptoConstants
 import sigma.data.{CAND, CAvlTree, ProveDlog, SigmaBoolean, TrivialProp}
 import sigma.interpreter.ContextExtension
 import sigma.util.Extensions.IntOps
@@ -436,6 +435,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(
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 da44cf14ef..f6a78b410e 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
@@ -156,6 +156,12 @@ class IsosSpec extends IsosSpecBase with sdk.generators.ObjectGenerators {
     }
   }
 
+  property("Iso.isoBigIntToLong - test vector") {
+    val l = 4928911477310178288L
+    val js =  sigma.js.Isos.isoBigIntToLong.from(l)
+    l.toString shouldBe js.toString()
+  }
+
   property("Iso.isoAmount") {
     forAll { (c: Long) =>
       roundtrip(DataIsos.isoAmount)(c)

From c2788b44b0cc6fddced779345c6c2085b4fa0001 Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Thu, 1 Aug 2024 13:58:29 +0300
Subject: [PATCH 12/14] fixing checkPow test in JS

---
 .../src/main/scala/sigma/data/CHeader.scala   |  5 +-
 .../TestingInterpreterSpecification.scala     | 43 ++---------------
 .../org/ergoplatform/sdk/js/IsosSpec.scala    | 47 -------------------
 3 files changed, 6 insertions(+), 89 deletions(-)

diff --git a/data/shared/src/main/scala/sigma/data/CHeader.scala b/data/shared/src/main/scala/sigma/data/CHeader.scala
index 8add26c277..aa5a5756d2 100644
--- a/data/shared/src/main/scala/sigma/data/CHeader.scala
+++ b/data/shared/src/main/scala/sigma/data/CHeader.scala
@@ -67,10 +67,7 @@ class CHeader(val ergoHeader: ErgoHeader) extends Header with WrapperOf[ErgoHead
   override def wrappedValue: ErgoHeader = ergoHeader
 
   override def serializeWithoutPoW: Coll[Byte] = {
-    val headerWithoutPow = HeaderWithoutPow(version, bytesToId(parentId.toArray), Digest32 @@ ADProofsRoot.toArray,
-      ADDigest @@ stateRoot.digest.toArray, Digest32 @@ transactionsRoot.toArray, timestamp,
-      nBits, height, Digest32 @@ extensionRoot.toArray, votes.toArray, unparsedBytes.toArray)
-    Colls.fromArray(HeaderWithoutPowSerializer.toBytes(headerWithoutPow))
+    Colls.fromArray(HeaderWithoutPowSerializer.toBytes(ergoHeader))
   }
 
   override def checkPow: Boolean = {
diff --git a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
index 9e004aef30..4ba6b1a9f7 100644
--- a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
@@ -6,15 +6,13 @@ import sigma.ast._
 import sigma.ast.syntax._
 import sigmastate.interpreter._
 import Interpreter._
-import io.circe.parser.parse
 import org.ergoplatform._
-import org.ergoplatform.sdk.JsonCodecs
 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.data.{CAND, CAvlTree, 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}
@@ -38,40 +36,9 @@ class TestingInterpreterSpecification extends CompilerTestingCommons
   lazy val verifier = new ErgoLikeTestInterpreter
   
   def testingContext(h: Int = 614401) = {
-
-    // valid header from Ergo blockchain
-    val headerJson =
-      """
-        |{
-        |  "extensionId" : "00cce45975d87414e8bdd8146bc88815be59cd9fe37a125b5021101e05675a18",
-        |  "votes" : "000000",
-        |  "timestamp" : 4928911477310178288,
-        |  "size" : 223,
-        |  "unparsedBytes" : "",
-        |  "stateRoot" : {
-        |      "digest" : "5c8c00b8403d3701557181c8df800001b6d5009e2201c6ff807d71808c00019780",
-        |      "treeFlags" : "0",
-        |      "keyLength" : "32"
-        |  },
-        |  "height" : 614400,
-        |  "nBits" : 37748736,
-        |  "version" : 2,
-        |  "id" : "5603a937ec1988220fc44fb5022fb82d5565b961f005ebb55d85bd5a9e6f801f",
-        |  "adProofsRoot" : "5d3f80dcff7f5e7f59007294c180808d0158d1ff6ba10000f901c7f0ef87dcff",
-        |  "transactionsRoot" : "f17fffacb6ff7f7f1180d2ff7f1e24ffffe1ff937f807f0797b9ff6ebdae007e",
-        |  "extensionRoot" : "1480887f80007f4b01cf7f013ff1ffff564a0000b9a54f00770e807f41ff88c0",
-        |  "minerPk" : "03bedaee069ff4829500b3c07c4d5fe6b3ea3d3bf76c5c28c1d4dcdb1bed0ade0c",
-        |  "powOnetimePk" : "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
-        |  "powNonce" : "0000000000003105",
-        |  "powDistance" : 0,
-        |  "adProofsId" : "dec129290a763f4de41f04e87e2b661dd59758af6bdd00dd51f5d97c3a8cb9b5",
-        |  "transactionsId" : "eba1dd82cf51147232e09c1f72b37c554c30f63274d5093bff36849a83472a42",
-        |  "parentId" : "ac2101807f0000ca01ff0119db227f202201007f62000177a080005d440896d0"
-        |}
-        |""".stripMargin
-
-    object JsonCodecs extends JsonCodecs
-    val header1 = JsonCodecs.headerDecoder.decodeJson(parse(headerJson).toOption.get).toOption.get
+    // 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)
 
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 f6a78b410e..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
@@ -61,47 +61,6 @@ class IsosSpec extends IsosSpecBase with sdk.generators.ObjectGenerators {
     }
   }
 
-  property("Iso.isoHeader - test vector") {
-    // valid header from Ergo blockchain
-    val headerJson =
-      """
-        |{
-        |  "extensionId" : "00cce45975d87414e8bdd8146bc88815be59cd9fe37a125b5021101e05675a18",
-        |  "votes" : "000000",
-        |  "timestamp" : 4928911477310178288,
-        |  "size" : 223,
-        |  "unparsedBytes" : "",
-        |  "stateRoot" : {
-        |      "digest" : "5c8c00b8403d3701557181c8df800001b6d5009e2201c6ff807d71808c00019780",
-        |      "treeFlags" : "0",
-        |      "keyLength" : "32"
-        |  },
-        |  "height" : 614400,
-        |  "nBits" : 37748736,
-        |  "version" : 2,
-        |  "id" : "5603a937ec1988220fc44fb5022fb82d5565b961f005ebb55d85bd5a9e6f801f",
-        |  "adProofsRoot" : "5d3f80dcff7f5e7f59007294c180808d0158d1ff6ba10000f901c7f0ef87dcff",
-        |  "transactionsRoot" : "f17fffacb6ff7f7f1180d2ff7f1e24ffffe1ff937f807f0797b9ff6ebdae007e",
-        |  "extensionRoot" : "1480887f80007f4b01cf7f013ff1ffff564a0000b9a54f00770e807f41ff88c0",
-        |  "minerPk" : "03bedaee069ff4829500b3c07c4d5fe6b3ea3d3bf76c5c28c1d4dcdb1bed0ade0c",
-        |  "powOnetimePk" : "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
-        |  "powNonce" : "0000000000003105",
-        |  "powDistance" : 0,
-        |  "adProofsId" : "dec129290a763f4de41f04e87e2b661dd59758af6bdd00dd51f5d97c3a8cb9b5",
-        |  "transactionsId" : "eba1dd82cf51147232e09c1f72b37c554c30f63274d5093bff36849a83472a42",
-        |  "parentId" : "ac2101807f0000ca01ff0119db227f202201007f62000177a080005d440896d0"
-        |}
-        |""".stripMargin
-
-    object JsonCodecs extends JsonCodecs
-    val c = JsonCodecs.headerDecoder.decodeJson(parse(headerJson).toOption.get).toOption.get
-
-    roundtrip(Isos.isoHeader)(c)
-
-    val jh = Isos.isoHeader.from(c)
-    Isos.isoHeader.to(jh).serializeWithoutPoW shouldBe c.serializeWithoutPoW
-  }
-
   property("Iso.isoPreHeader") {
     forAll { (c: sigma.PreHeader) =>
       roundtrip(Isos.isoPreHeader)(c)
@@ -156,12 +115,6 @@ class IsosSpec extends IsosSpecBase with sdk.generators.ObjectGenerators {
     }
   }
 
-  property("Iso.isoBigIntToLong - test vector") {
-    val l = 4928911477310178288L
-    val js =  sigma.js.Isos.isoBigIntToLong.from(l)
-    l.toString shouldBe js.toString()
-  }
-
   property("Iso.isoAmount") {
     forAll { (c: Long) =>
       roundtrip(DataIsos.isoAmount)(c)

From e7fde10e26f8af36bf3de134b00aa2f5d0dce029 Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Tue, 6 Aug 2024 23:49:32 +0300
Subject: [PATCH 13/14] versioned execution depending on tree version,
 newFeature test

---
 .../src/main/scala/sigma/ast/SMethod.scala    | 15 ++++-
 .../src/main/scala/sigma/ast/methods.scala    |  8 +--
 .../src/main/scala/sigma/ast/values.scala     |  3 +
 .../scala/sigma/eval/ErgoTreeEvaluator.scala  |  4 --
 .../interpreter/CErgoTreeEvaluator.scala      |  8 ---
 .../scala/sigma/LanguageSpecificationV6.scala | 63 ++++++++++---------
 .../test/scala/sigma/SigmaDslTesting.scala    | 16 ++++-
 .../TestingInterpreterSpecification.scala     |  6 +-
 8 files changed, 70 insertions(+), 53 deletions(-)

diff --git a/data/shared/src/main/scala/sigma/ast/SMethod.scala b/data/shared/src/main/scala/sigma/ast/SMethod.scala
index 5a17038c54..600701506e 100644
--- a/data/shared/src/main/scala/sigma/ast/SMethod.scala
+++ b/data/shared/src/main/scala/sigma/ast/SMethod.scala
@@ -75,7 +75,8 @@ case class SMethod(
     irInfo: MethodIRInfo,
     docInfo: Option[OperationInfo],
     costFunc: Option[MethodCostFunc],
-    userDefinedInvoke: Option[SMethod.InvokeHandler]
+    userDefinedInvoke: Option[SMethod.InvokeHandler],
+    sinceVersion: Byte
 ) {
 
   /** Operation descriptor of this method. */
@@ -314,7 +315,17 @@ object SMethod {
   ): SMethod = {
     SMethod(
       objType, name, stype, methodId, costKind, explicitTypeArgs,
-      MethodIRInfo(None, None, None), None, None, None)
+      MethodIRInfo(None, None, None), None, None, None, 0)
+  }
+
+  /** Convenience factory method. */
+  def apply(objType: MethodsContainer, name: String, stype: SFunc,
+            methodId: Byte,
+            costKind: CostKind,
+            sinceVersion: Byte): SMethod = {
+    SMethod(
+      objType, name, stype, methodId, costKind, Nil,
+      MethodIRInfo(None, None, None), None, None, None, sinceVersion)
   }
 
 
diff --git a/data/shared/src/main/scala/sigma/ast/methods.scala b/data/shared/src/main/scala/sigma/ast/methods.scala
index c299d9f53a..62164f0f24 100644
--- a/data/shared/src/main/scala/sigma/ast/methods.scala
+++ b/data/shared/src/main/scala/sigma/ast/methods.scala
@@ -1458,15 +1458,11 @@ case object SHeaderMethods extends MonoTypeMethods {
 
   // 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)))
+    this, "checkPow", SFunc(Array(SHeader), SBoolean), 16, FixedCost(JitCost(700)),
+    sinceVersion = VersionContext.V6SoftForkVersion)
     .withIRInfo(MethodCallIrBuilder)
     .withInfo(MethodCall, "Validate header's proof-of-work")
 
-  def checkPow_eval(mc: MethodCall, G: SigmaDslBuilder, header: Header)
-                 (implicit E: ErgoTreeEvaluator): Boolean = {
-    E.checkPow_eval(mc, header)
-  }
-
   private lazy val v5Methods = super.getMethods() ++ Seq(
     idMethod, versionMethod, parentIdMethod, ADProofsRootMethod, stateRootMethod, transactionsRootMethod,
     timestampMethod, nBitsMethod, heightMethod, extensionRootMethod, minerPkMethod, powOnetimePkMethod,
diff --git a/data/shared/src/main/scala/sigma/ast/values.scala b/data/shared/src/main/scala/sigma/ast/values.scala
index 87c661a00a..5a372e6c3c 100644
--- a/data/shared/src/main/scala/sigma/ast/values.scala
+++ b/data/shared/src/main/scala/sigma/ast/values.scala
@@ -1313,6 +1313,9 @@ case class MethodCall(
     addCost(MethodCall.costKind) // MethodCall overhead
     method.costKind match {
       case fixed: FixedCost =>
+        if (method.sinceVersion > 0 && E.context.currentErgoTreeVersion < method.sinceVersion) {
+          syntax.error(s"Method ${method.name} is not supported in tree version ${E.context.currentErgoTreeVersion}")
+        }
         val extra    = method.extraDescriptors
         val extraLen = extra.length
         val len      = args.length
diff --git a/data/shared/src/main/scala/sigma/eval/ErgoTreeEvaluator.scala b/data/shared/src/main/scala/sigma/eval/ErgoTreeEvaluator.scala
index b95c034bd2..6df82125df 100644
--- a/data/shared/src/main/scala/sigma/eval/ErgoTreeEvaluator.scala
+++ b/data/shared/src/main/scala/sigma/eval/ErgoTreeEvaluator.scala
@@ -138,10 +138,6 @@ abstract class ErgoTreeEvaluator {
   def remove_eval(
       mc: MethodCall, tree: AvlTree,
       operations: Coll[Coll[Byte]], proof: Coll[Byte]): Option[AvlTree]
-
-  /** Implements evaluation of Header.checkPow method call ErgoTree node. */
-  def checkPow_eval(mc: MethodCall, header: Header): Boolean
-
 }
 
 object ErgoTreeEvaluator {
diff --git a/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala b/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala
index c0759f4a5c..a72510f641 100644
--- a/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala
+++ b/interpreter/shared/src/main/scala/sigmastate/interpreter/CErgoTreeEvaluator.scala
@@ -218,14 +218,6 @@ class CErgoTreeEvaluator(
     }
   }
 
-  /** Implements evaluation of Header.checkPow method call ErgoTree node. */
-  override def checkPow_eval(mc: MethodCall, header: Header): Boolean = {
-    val checkPowCostInfo = OperationCostInfo(checkPowMethod.costKind.asInstanceOf[FixedCost], NamedDesc("Header.checkPow"))
-    fixedCostOp(checkPowCostInfo){
-      header.checkPow
-    }(this)
-  }
-
   /** Evaluates the given expression in the given data environment. */
   def eval(env: DataEnv, exp: SValue): Any = {
     VersionContext.checkVersions(context.activatedScriptVersion, context.currentErgoTreeVersion)
diff --git a/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala b/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
index 97ebc575c7..61859a81cc 100644
--- a/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
+++ b/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
@@ -1,10 +1,12 @@
 package sigma
 
+import org.ergoplatform.ErgoHeader
+import scorex.util.encode.Base16
 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, ExactNumeric}
 import sigma.eval.{CostDetails, SigmaDsl, TracedCost}
 import sigma.util.Extensions.{BooleanOps, ByteOps, IntOps, LongOps}
 import sigmastate.exceptions.MethodNotFound
@@ -331,34 +333,6 @@ class LanguageSpecificationV6 extends LanguageSpecificationBase { suite =>
     }
   }
 
-  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.getMethodByName("checkPow"),
-          IndexedSeq(),
-          Map()
-        )
-      ),
-      sinceVersion = VersionContext.V6SoftForkVersion)
-
-    if (VersionContext.current.isV6SoftForkActivated) {
-      forAll { x: Header =>
-        Seq(checkPoW).map(_.checkEquality(x))
-      }
-    } else {
-      an[Exception] shouldBe thrownBy {
-        forAll { x: Header =>
-          Seq(checkPoW).map(_.checkEquality(x))
-        }
-      }
-    }
-
-  }
-
   // TODO v6.0: implement Option.fold (see https://github.com/ScorexFoundation/sigmastate-interpreter/issues/479)
   property("Option new methods") {
     val n = ExactNumeric.LongIsExactNumeric
@@ -491,4 +465,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..fa1402030b 100644
--- a/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
+++ b/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
@@ -875,7 +875,11 @@ class SigmaDslTesting extends AnyPropSpec
       vc.activatedVersion >= sinceVersion && vc.ergoTreeVersion >= 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/TestingInterpreterSpecification.scala b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
index 4ba6b1a9f7..1ab6031109 100644
--- a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
@@ -473,7 +473,11 @@ class TestingInterpreterSpecification extends CompilerTestingCommons
     if (activatedVersionInTests < V6SoftForkVersion) {
       an [Exception] should be thrownBy testEval(source)
     } else {
-      testEval(source)
+      if(ergoTreeVersionInTests >= V6SoftForkVersion) {
+        testEval(source)
+      } else {
+        an [Exception] should be thrownBy testEval(source)
+      }
     }
   }
 

From ea0890b126a77f2e8cd0a35d999424d1e495581d Mon Sep 17 00:00:00 2001
From: Alexander Chepurnoy <alex.chepurnoy@iohk.io>
Date: Mon, 12 Aug 2024 14:04:14 +0300
Subject: [PATCH 14/14] tree versioning removed, scaladoc

---
 .../src/main/scala/sigma/ast/SMethod.scala    | 15 ++----------
 .../src/main/scala/sigma/ast/methods.scala    |  3 +--
 .../src/main/scala/sigma/ast/values.scala     |  3 ---
 .../sigma/pow/Autolykos2PowValidation.scala   | 23 ++++++++++++-------
 .../test/scala/sigma/SigmaDslTesting.scala    |  2 +-
 .../TestingInterpreterSpecification.scala     |  6 +----
 6 files changed, 20 insertions(+), 32 deletions(-)

diff --git a/data/shared/src/main/scala/sigma/ast/SMethod.scala b/data/shared/src/main/scala/sigma/ast/SMethod.scala
index 600701506e..5a17038c54 100644
--- a/data/shared/src/main/scala/sigma/ast/SMethod.scala
+++ b/data/shared/src/main/scala/sigma/ast/SMethod.scala
@@ -75,8 +75,7 @@ case class SMethod(
     irInfo: MethodIRInfo,
     docInfo: Option[OperationInfo],
     costFunc: Option[MethodCostFunc],
-    userDefinedInvoke: Option[SMethod.InvokeHandler],
-    sinceVersion: Byte
+    userDefinedInvoke: Option[SMethod.InvokeHandler]
 ) {
 
   /** Operation descriptor of this method. */
@@ -315,17 +314,7 @@ object SMethod {
   ): SMethod = {
     SMethod(
       objType, name, stype, methodId, costKind, explicitTypeArgs,
-      MethodIRInfo(None, None, None), None, None, None, 0)
-  }
-
-  /** Convenience factory method. */
-  def apply(objType: MethodsContainer, name: String, stype: SFunc,
-            methodId: Byte,
-            costKind: CostKind,
-            sinceVersion: Byte): SMethod = {
-    SMethod(
-      objType, name, stype, methodId, costKind, Nil,
-      MethodIRInfo(None, None, None), None, None, None, sinceVersion)
+      MethodIRInfo(None, None, None), None, None, None)
   }
 
 
diff --git a/data/shared/src/main/scala/sigma/ast/methods.scala b/data/shared/src/main/scala/sigma/ast/methods.scala
index 62164f0f24..969effd57d 100644
--- a/data/shared/src/main/scala/sigma/ast/methods.scala
+++ b/data/shared/src/main/scala/sigma/ast/methods.scala
@@ -1458,8 +1458,7 @@ case object SHeaderMethods extends MonoTypeMethods {
 
   // 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)),
-    sinceVersion = VersionContext.V6SoftForkVersion)
+    this, "checkPow", SFunc(Array(SHeader), SBoolean), 16, FixedCost(JitCost(700)))
     .withIRInfo(MethodCallIrBuilder)
     .withInfo(MethodCall, "Validate header's proof-of-work")
 
diff --git a/data/shared/src/main/scala/sigma/ast/values.scala b/data/shared/src/main/scala/sigma/ast/values.scala
index 5a372e6c3c..87c661a00a 100644
--- a/data/shared/src/main/scala/sigma/ast/values.scala
+++ b/data/shared/src/main/scala/sigma/ast/values.scala
@@ -1313,9 +1313,6 @@ case class MethodCall(
     addCost(MethodCall.costKind) // MethodCall overhead
     method.costKind match {
       case fixed: FixedCost =>
-        if (method.sinceVersion > 0 && E.context.currentErgoTreeVersion < method.sinceVersion) {
-          syntax.error(s"Method ${method.name} is not supported in tree version ${E.context.currentErgoTreeVersion}")
-        }
         val extra    = method.extraDescriptors
         val extraLen = extra.length
         val len      = args.length
diff --git a/data/shared/src/main/scala/sigma/pow/Autolykos2PowValidation.scala b/data/shared/src/main/scala/sigma/pow/Autolykos2PowValidation.scala
index c2166493e6..23cf722194 100644
--- a/data/shared/src/main/scala/sigma/pow/Autolykos2PowValidation.scala
+++ b/data/shared/src/main/scala/sigma/pow/Autolykos2PowValidation.scala
@@ -8,21 +8,28 @@ import sigma.crypto.{BcDlogGroup, BigIntegers, CryptoConstants}
 import sigma.util.NBitsUtils
 
 /**
-  * Functions used to validate Autolykos2 Proof-of-Work
+  * Functions used to validate Autolykos2 Proof-of-Work.
   */
 object Autolykos2PowValidation {
 
   type Height = Int
 
-  val k = 32
-
-  val NStart = 26
+  /**
+    * k value for k-sum problem Autolykos is based on (find k numbers in table on N size)
+    */
+  private val k = 32
 
-  val group: BcDlogGroup = CryptoConstants.dlogGroup
+  /**
+    * 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
-  val q: BigInt = group.order
+  /**
+    * 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
diff --git a/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala b/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
index fa1402030b..4410786fd4 100644
--- a/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
+++ b/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
@@ -872,7 +872,7 @@ 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 =>
       if (isSupportedIn(VersionContext.current)) {
diff --git a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
index 1ab6031109..4ba6b1a9f7 100644
--- a/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/TestingInterpreterSpecification.scala
@@ -473,11 +473,7 @@ class TestingInterpreterSpecification extends CompilerTestingCommons
     if (activatedVersionInTests < V6SoftForkVersion) {
       an [Exception] should be thrownBy testEval(source)
     } else {
-      if(ergoTreeVersionInTests >= V6SoftForkVersion) {
-        testEval(source)
-      } else {
-        an [Exception] should be thrownBy testEval(source)
-      }
+      testEval(source)
     }
   }