diff --git a/.gitignore b/.gitignore
index 3570923b1d..b67ecf6995 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,7 +8,6 @@
 *.fdb_latexmk
 *.gz
 
-
 yarn.lock
 *.log
 yarn.lock
diff --git a/core/shared/src/main/scala/sigma/SigmaDsl.scala b/core/shared/src/main/scala/sigma/SigmaDsl.scala
index 0c87e1c955..92250ac615 100644
--- a/core/shared/src/main/scala/sigma/SigmaDsl.scala
+++ b/core/shared/src/main/scala/sigma/SigmaDsl.scala
@@ -746,6 +746,17 @@ trait Context {
     */
   def getVar[T](id: Byte)(implicit cT: RType[T]): Option[T]
 
+  /**
+    * A variant of `getVar` to extract a context variable by id and type from any input
+    *
+    * @param inputIndex - input index
+    * @param id - context variable id
+    * @tparam T - expected type of the variable
+    * @return Some(value) if the variable is defined in the context AND has the given type.
+    *         None otherwise
+    */
+  def getVarFromInput[T](inputIndex: Short, id: Byte)(implicit cT: RType[T]): Option[T]
+
   def vars: Coll[AnyValue]
 
   /** Maximum version of ErgoTree currently activated on the network.
diff --git a/core/shared/src/main/scala/sigma/data/CollsOverArrays.scala b/core/shared/src/main/scala/sigma/data/CollsOverArrays.scala
index eb4c1e4931..2d6a4a5cdf 100644
--- a/core/shared/src/main/scala/sigma/data/CollsOverArrays.scala
+++ b/core/shared/src/main/scala/sigma/data/CollsOverArrays.scala
@@ -1,6 +1,8 @@
 package sigma.data
 
 import debox.{Buffer, cfor}
+import sigma.Evaluation.stypeToRType
+import sigma.data.CollOverArray.equalsPairCollWithCollOverArray
 import sigma.data.RType._
 import sigma.util.{CollectionUtil, MaxArrayLength, safeConcatArrays_v5}
 import sigma.{Coll, CollBuilder, PairColl, VersionContext, requireSameLength}
@@ -12,7 +14,9 @@ class CollOverArray[@specialized A](val toArray: Array[A], val builder: CollBuil
     s"Cannot create collection with size ${toArray.length} greater than $MaxArrayLength")
 
   override def tItem: RType[A] = tA
+
   @inline def length: Int = toArray.length
+
   @inline def apply(i: Int): A = toArray.apply(i)
 
   override def isEmpty: Boolean = length == 0
@@ -29,8 +33,11 @@ class CollOverArray[@specialized A](val toArray: Array[A], val builder: CollBuil
   }
 
   def foreach(f: A => Unit): Unit = toArray.foreach(f)
+
   def exists(p: A => Boolean): Boolean = toArray.exists(p)
+
   def forall(p: A => Boolean): Boolean = toArray.forall(p)
+
   def filter(p: A => Boolean): Coll[A] = builder.fromArray(toArray.filter(p))
 
   def foldLeft[B](zero: B, op: ((B, A)) => B): B = toArray.foldLeft(zero)((b, a) => op((b, a)))
@@ -117,12 +124,14 @@ class CollOverArray[@specialized A](val toArray: Array[A], val builder: CollBuil
   override def unionSet(that: Coll[A]): Coll[A] = {
     val set = debox.Set.ofSize[A](this.length)
     val res = Buffer.ofSize[A](this.length)
+
     @inline def addItemToSet(x: A) = {
       if (!set(x)) {
         set.add(x)
         res += x
       }
     }
+
     def addToSet(arr: Array[A]) = {
       val limit = arr.length
       cfor(0)(_ < limit, _ + 1) { i =>
@@ -139,14 +148,42 @@ class CollOverArray[@specialized A](val toArray: Array[A], val builder: CollBuil
 
   override def equals(obj: scala.Any): Boolean = (this eq obj.asInstanceOf[AnyRef]) || (obj match {
     case obj: CollOverArray[_] if obj.tItem == this.tItem =>
-      java.util.Objects.deepEquals(obj.toArray, toArray)
+      java.util.Objects.deepEquals(obj.toArray, this.toArray)
+    case obj: PairColl[Any, Any] if obj.tItem == this.tItem =>
+      if (VersionContext.current.isV6SoftForkActivated) {
+        equalsPairCollWithCollOverArray(obj, this.asInstanceOf[CollOverArray[Any]])
+      } else {
+        false
+      }
     case _ => false
   })
 
-  override def hashCode() = CollectionUtil.deepHashCode(toArray)
+  override def hashCode(): Int = CollectionUtil.deepHashCode(toArray)
+}
+
+object CollOverArray {
+
+  // comparing PairColl and CollOverArray instances
+  private[data] def equalsPairCollWithCollOverArray(pc: PairColl[Any, Any], coa: CollOverArray[Any]): Boolean = {
+    val ls = pc.ls
+    val rs = pc.rs
+    val ts = coa.toArray
+    if (ts.length == ls.length && ts.isInstanceOf[Array[(Any, Any)]]) {
+      val ta = ts.asInstanceOf[Array[(Any, Any)]]
+      var eq = true
+      cfor(0)(_ < ta.length && eq, _ + 1) { i =>
+        eq = java.util.Objects.deepEquals(ta(i)._1, ls(i)) && java.util.Objects.deepEquals(ta(i)._2, rs(i))
+      }
+      eq
+    } else {
+      false
+    }
+  }
+  
 }
 
-private[sigma] class CollOverArrayBuilder extends CollBuilder { builder =>
+private[sigma] class CollOverArrayBuilder extends CollBuilder {
+  builder =>
 
   @inline override def pairColl[@specialized A, @specialized B](as: Coll[A], bs: Coll[B]): PairColl[A, B] = {
     if (VersionContext.current.isJitActivated) {
@@ -170,12 +207,12 @@ private[sigma] class CollOverArrayBuilder extends CollBuilder { builder =>
     }
   }
 
-  private def fromBoxedPairs[A, B](seq: Seq[(A, B)])(implicit tA: RType[A], tB: RType[B]): PairColl[A,B] = {
+  private def fromBoxedPairs[A, B](seq: Seq[(A, B)])(implicit tA: RType[A], tB: RType[B]): PairColl[A, B] = {
     val len = seq.length
     val resA = Array.ofDim[A](len)(tA.classTag)
     val resB = Array.ofDim[B](len)(tB.classTag)
     cfor(0)(_ < len, _ + 1) { i =>
-      val item = seq.apply(i).asInstanceOf[(A,B)]
+      val item = seq.apply(i).asInstanceOf[(A, B)]
       resA(i) = item._1
       resB(i) = item._2
     }
@@ -183,7 +220,7 @@ private[sigma] class CollOverArrayBuilder extends CollBuilder { builder =>
   }
 
   override def fromItems[T](items: T*)(implicit cT: RType[T]): Coll[T] = cT match {
-    case pt: PairType[a,b] =>
+    case pt: PairType[a, b] =>
       val tA = pt.tFst
       val tB = pt.tSnd
       fromBoxedPairs(items)(tA, tB)
@@ -192,16 +229,16 @@ private[sigma] class CollOverArrayBuilder extends CollBuilder { builder =>
   }
 
   override def fromArray[@specialized T: RType](arr: Array[T]): Coll[T] = RType[T] match {
-    case pt: PairType[a,b] =>
+    case pt: PairType[a, b] =>
       val tA = pt.tFst
       val tB = pt.tSnd
-      fromBoxedPairs[a,b](arr.asInstanceOf[Array[(a,b)]])(tA, tB)
+      fromBoxedPairs[a, b](arr.asInstanceOf[Array[(a, b)]])(tA, tB)
     case _ =>
       new CollOverArray(arr, builder)
   }
 
   override def replicate[@specialized T: RType](n: Int, v: T): Coll[T] = RType[T] match {
-    case pt: PairType[a,b] =>
+    case pt: PairType[a, b] =>
       val tA = pt.tFst
       val tB = pt.tSnd
       val tuple = v.asInstanceOf[(a, b)]
@@ -210,8 +247,8 @@ private[sigma] class CollOverArrayBuilder extends CollBuilder { builder =>
       fromArray(Array.fill(n)(v))
   }
 
-  override def unzip[@specialized A, @specialized B](xs: Coll[(A,B)]): (Coll[A], Coll[B]) = xs match {
-    case pa: PairColl[_,_] => (pa.ls, pa.rs)
+  override def unzip[@specialized A, @specialized B](xs: Coll[(A, B)]): (Coll[A], Coll[B]) = xs match {
+    case pa: PairColl[_, _] => (pa.ls, pa.rs)
     case _ =>
       val limit = xs.length
       implicit val tA = xs.tItem.tFst
@@ -230,7 +267,7 @@ private[sigma] class CollOverArrayBuilder extends CollBuilder { builder =>
     left.zip(right).map { case (l, r) => (l ^ r).toByte }
 
   override def emptyColl[T](implicit cT: RType[T]): Coll[T] = cT match {
-    case pt: PairType[a,b] =>
+    case pt: PairType[a, b] =>
       val ls = emptyColl(pt.tFst)
       val rs = emptyColl(pt.tSnd)
       pairColl(ls, rs).asInstanceOf[Coll[T]]
@@ -239,15 +276,24 @@ private[sigma] class CollOverArrayBuilder extends CollBuilder { builder =>
   }
 }
 
-class PairOfCols[@specialized L, @specialized R](val ls: Coll[L], val rs: Coll[R]) extends PairColl[L,R] {
+class PairOfCols[@specialized L, @specialized R](val ls: Coll[L], val rs: Coll[R]) extends PairColl[L, R] {
 
-  override def equals(that: scala.Any) = (this eq that.asInstanceOf[AnyRef]) || (that match {
-    case that: PairColl[_,_] if that.tItem == this.tItem => ls == that.ls && rs == that.rs
+  override def equals(that: scala.Any): Boolean = (this eq that.asInstanceOf[AnyRef]) || (that match {
+    case that: PairColl[_, _] if that.tItem == this.tItem =>
+      ls == that.ls && rs == that.rs
+    case that: CollOverArray[Any] if that.tItem == this.tItem =>
+      if (VersionContext.current.isV6SoftForkActivated) {
+        equalsPairCollWithCollOverArray(this.asInstanceOf[PairColl[Any, Any]], that)
+      } else {
+        false
+      }
     case _ => false
   })
 
   override def hashCode() = ls.hashCode() * 41 + rs.hashCode()
+
   @inline implicit def tL: RType[L] = ls.tItem
+
   @inline implicit def tR: RType[R] = rs.tItem
 
   override lazy val tItem: RType[(L, R)] = {
@@ -255,8 +301,11 @@ class PairOfCols[@specialized L, @specialized R](val ls: Coll[L], val rs: Coll[R
   }
 
   override def builder: CollBuilder = ls.builder
+
   override def toArray: Array[(L, R)] = ls.toArray.zip(rs.toArray)
+
   @inline override def length: Int = if (ls.length <= rs.length) ls.length else rs.length
+
   @inline override def apply(i: Int): (L, R) = (ls(i), rs(i))
 
   override def isEmpty: Boolean = length == 0
@@ -304,7 +353,7 @@ class PairOfCols[@specialized L, @specialized R](val ls: Coll[L], val rs: Coll[R
     true
   }
 
-  override def filter(p: ((L, R)) => Boolean): Coll[(L,R)] = {
+  override def filter(p: ((L, R)) => Boolean): Coll[(L, R)] = {
     val len = ls.length
     val resL: Buffer[L] = Buffer.empty[L](ls.tItem.classTag)
     val resR: Buffer[R] = Buffer.empty[R](rs.tItem.classTag)
@@ -333,9 +382,9 @@ class PairOfCols[@specialized L, @specialized R](val ls: Coll[L], val rs: Coll[R
     state
   }
 
-  override def slice(from: Int, until: Int): PairColl[L,R] = builder.pairColl(ls.slice(from, until), rs.slice(from, until))
+  override def slice(from: Int, until: Int): PairColl[L, R] = builder.pairColl(ls.slice(from, until), rs.slice(from, until))
 
-  def append(other: Coll[(L, R)]): Coll[(L,R)] = {
+  def append(other: Coll[(L, R)]): Coll[(L, R)] = {
     val arrs = builder.unzip(other)
     builder.pairColl(ls.append(arrs._1), rs.append(arrs._2))
   }
@@ -352,7 +401,7 @@ class PairOfCols[@specialized L, @specialized R](val ls: Coll[L], val rs: Coll[R
     }
   }
 
-  def zip[@specialized B](ys: Coll[B]): PairColl[(L,R), B] = builder.pairColl(this, ys)
+  def zip[@specialized B](ys: Coll[B]): PairColl[(L, R), B] = builder.pairColl(this, ys)
 
   def startsWith(ys: Coll[(L, R)]): Boolean = ys match {
     case yp: PairOfCols[L, R] => ls.startsWith(yp.ls) && rs.startsWith(yp.rs)
@@ -408,18 +457,20 @@ class PairOfCols[@specialized L, @specialized R](val ls: Coll[L], val rs: Coll[R
   }
 
   override def unionSet(that: Coll[(L, R)]): Coll[(L, R)] = {
-    val set = new java.util.HashSet[(L,R)](32)
+    val set = new java.util.HashSet[(L, R)](32)
     implicit val ctL = ls.tItem.classTag
     implicit val ctR = rs.tItem.classTag
     val resL = Buffer.empty[L]
     val resR = Buffer.empty[R]
-    def addToSet(item: (L,R)) = {
+
+    def addToSet(item: (L, R)) = {
       if (!set.contains(item)) {
         set.add(item)
         resL += item._1
         resR += item._2
       }
     }
+
     var i = 0
     val thisLen = math.min(ls.length, rs.length)
     while (i < thisLen) {
diff --git a/core/shared/src/main/scala/sigma/reflection/ReflectionData.scala b/core/shared/src/main/scala/sigma/reflection/ReflectionData.scala
index 48388d7d4b..12e1d0eaa2 100644
--- a/core/shared/src/main/scala/sigma/reflection/ReflectionData.scala
+++ b/core/shared/src/main/scala/sigma/reflection/ReflectionData.scala
@@ -317,6 +317,9 @@ object ReflectionData {
         mkMethod(clazz, "getVar", Array[Class[_]](classOf[Byte], classOf[RType[_]])) { (obj, args) =>
           obj.asInstanceOf[Context].getVar(args(0).asInstanceOf[Byte])(args(1).asInstanceOf[RType[_]])
         },
+        mkMethod(clazz, "getVarFromInput", Array[Class[_]](classOf[Short], classOf[Byte], classOf[RType[_]])) { (obj, args) =>
+          obj.asInstanceOf[Context].getVarFromInput(args(0).asInstanceOf[Short], args(1).asInstanceOf[Byte])(args(2).asInstanceOf[RType[_]])
+        },
         mkMethod(clazz, "headers", Array[Class[_]]()) { (obj, _) =>
           obj.asInstanceOf[Context].headers
         }
diff --git a/data/shared/src/main/scala/sigma/ast/SMethod.scala b/data/shared/src/main/scala/sigma/ast/SMethod.scala
index 11e656b1be..e5481cee5b 100644
--- a/data/shared/src/main/scala/sigma/ast/SMethod.scala
+++ b/data/shared/src/main/scala/sigma/ast/SMethod.scala
@@ -302,6 +302,18 @@ object SMethod {
           (implicit cT: ClassTag[T], cA1: ClassTag[A1], cA2: ClassTag[A2]): RMethod =
     RClass(cT.runtimeClass).getMethod(methodName, cA1.runtimeClass, cA2.runtimeClass)
 
+  /** Return [[Method]] descriptor for the given `methodName` on the given `cT` type.
+    * @param methodName the name of the method to lookup
+    * @param cT the class where to search the methodName
+    * @param cA1 the class of the method's first argument
+    * @param cA2 the class of the method's second argument
+    * @param cA3 the class of the method's third argument
+    */
+  def javaMethodOf[T, A1, A2, A3]
+      (methodName: String)
+          (implicit cT: ClassTag[T], cA1: ClassTag[A1], cA2: ClassTag[A2], cA3: ClassTag[A3]): RMethod =
+    RClass(cT.runtimeClass).getMethod(methodName, cA1.runtimeClass, cA2.runtimeClass, cA3.runtimeClass)
+
   /** Default fallback method call recognizer which builds MethodCall ErgoTree nodes. */
   val MethodCallIrBuilder: PartialFunction[(SigmaBuilder, SValue, SMethod, Seq[SValue], STypeSubst), SValue] = {
     case (builder, obj, method, args, tparamSubst) =>
diff --git a/data/shared/src/main/scala/sigma/ast/SigmaPredef.scala b/data/shared/src/main/scala/sigma/ast/SigmaPredef.scala
index f018db0bbd..e976babbf2 100644
--- a/data/shared/src/main/scala/sigma/ast/SigmaPredef.scala
+++ b/data/shared/src/main/scala/sigma/ast/SigmaPredef.scala
@@ -146,6 +146,18 @@ object SigmaPredef {
         Seq(ArgInfo("varId", "\\lst{Byte} identifier of context variable")))
     )
 
+    val GetVarFromInputFunc = PredefinedFunc("getVarFromInput",
+      Lambda(Array(paramT), Array("inputId" -> SShort, "varId" -> SByte), SOption(tT), None),
+      PredefFuncInfo(
+        { case (Ident(_, SFunc(_, SOption(rtpe), _)), Seq(inputId: Constant[SNumericType]@unchecked, varId: Constant[SNumericType]@unchecked)) =>
+          mkMethodCall(Context, SContextMethods.getVarFromInputMethod, IndexedSeq(SShort.downcast(inputId.value.asInstanceOf[AnyVal]), SByte.downcast(varId.value.asInstanceOf[AnyVal])), Map(tT -> rtpe))
+        }),
+      OperationInfo(MethodCall,
+        "Get context variable with given \\lst{varId} and type.",
+        Seq(ArgInfo("inputId", "\\lst{Byte} index of input to read context variable from"),
+            ArgInfo("varId", "\\lst{Byte} identifier of context variable")))
+    )
+
     def PKFunc(networkPrefix: NetworkPrefix) = PredefinedFunc("PK",
       Lambda(Array("input" -> SString), SSigmaProp, None),
       PredefFuncInfo(
@@ -485,6 +497,7 @@ object SigmaPredef {
       ExecuteFromVarFunc,
       ExecuteFromSelfRegFunc,
       SerializeFunc,
+      GetVarFromInputFunc,
       FromBigEndianBytesFunc
     ).map(f => f.name -> f).toMap
 
diff --git a/data/shared/src/main/scala/sigma/ast/methods.scala b/data/shared/src/main/scala/sigma/ast/methods.scala
index ef8fdd3b6f..f3517ae496 100644
--- a/data/shared/src/main/scala/sigma/ast/methods.scala
+++ b/data/shared/src/main/scala/sigma/ast/methods.scala
@@ -1827,16 +1827,52 @@ case object SContextMethods extends MonoTypeMethods {
   lazy val selfBoxIndexMethod = propertyCall("selfBoxIndex", SInt, 8, FixedCost(JitCost(20)))
   lazy val lastBlockUtxoRootHashMethod = property("LastBlockUtxoRootHash", SAvlTree, 9, LastBlockUtxoRootHash)
   lazy val minerPubKeyMethod = property("minerPubKey", SByteArray, 10, MinerPubkey)
-  lazy val getVarMethod = SMethod(
+
+  lazy val getVarV5Method = SMethod(
     this, "getVar", SFunc(ContextFuncDom, SOption(tT), Array(paramT)), 11, GetVar.costKind)
     .withInfo(GetVar, "Get context variable with given \\lst{varId} and type.",
       ArgInfo("varId", "\\lst{Byte} identifier of context variable"))
 
-  protected override def getMethods() = super.getMethods() ++ Seq(
+  lazy val getVarV6Method = SMethod(
+    this, "getVar", SFunc(ContextFuncDom, SOption(tT), Array(paramT)), 11, GetVar.costKind, Seq(tT))
+    .withIRInfo(
+      MethodCallIrBuilder,
+      javaMethodOf[Context, Byte, RType[_]]("getVar"),
+      { mtype => Array(mtype.tRange.asOption[SType].elemType) })
+    .withInfo(MethodCall, "Get context variable with given \\lst{varId} and type.")
+
+  lazy val getVarFromInputMethod = SMethod(
+    this, "getVarFromInput", SFunc(Array(SContext, SShort, SByte), SOption(tT), Array(paramT)), 12, GetVar.costKind, Seq(tT))
+    .withIRInfo(
+      MethodCallIrBuilder,
+      javaMethodOf[Context, Short, Byte, RType[_]]("getVarFromInput"),
+      { mtype => Array(mtype.tRange.asOption[SType].elemType) })
+    .withInfo(MethodCall, "Get context variable with given \\lst{varId} and type.",
+      ArgInfo("inputIdx", "Index of input to read variable from."),
+      ArgInfo("varId", "Index of variable.")
+    )
+
+  private lazy val commonMethods = super.getMethods() ++ Array(
     dataInputsMethod, headersMethod, preHeaderMethod, inputsMethod, outputsMethod, heightMethod, selfMethod,
-    selfBoxIndexMethod, lastBlockUtxoRootHashMethod, minerPubKeyMethod, getVarMethod
+    selfBoxIndexMethod, lastBlockUtxoRootHashMethod, minerPubKeyMethod
   )
 
+  private lazy val v5Methods = commonMethods ++ Seq(
+    getVarV5Method
+  )
+
+  private lazy val v6Methods = commonMethods ++ Seq(
+    getVarV6Method, getVarFromInputMethod
+  )
+
+  protected override def getMethods(): Seq[SMethod] = {
+    if (VersionContext.current.isV6SoftForkActivated) {
+      v6Methods
+    } else {
+      v5Methods
+    }
+  }
+
   /** Names of methods which provide blockchain context.
    * This value can be reused where necessary to avoid allocations. */
   val BlockchainContextMethodNames: IndexedSeq[String] = Array(
diff --git a/data/shared/src/main/scala/sigma/ast/transformers.scala b/data/shared/src/main/scala/sigma/ast/transformers.scala
index 939da79d98..8d7e689a18 100644
--- a/data/shared/src/main/scala/sigma/ast/transformers.scala
+++ b/data/shared/src/main/scala/sigma/ast/transformers.scala
@@ -10,7 +10,7 @@ import sigma.eval.ErgoTreeEvaluator.DataEnv
 import sigma.serialization.CoreByteWriter.ArgInfo
 import sigma.serialization.OpCodes
 import sigma.serialization.ValueCodes.OpCode
-import sigma.{Box, Coll, Evaluation}
+import sigma.{Box, Coll, Evaluation, VersionContext}
 
 // TODO refactor: remove this trait as it doesn't have semantic meaning
 
@@ -258,10 +258,22 @@ case class ByIndex[V <: SType](input: Value[SCollection[V]],
     val indexV = index.evalTo[Int](env)
     default match {
       case Some(d) =>
-        val dV = d.evalTo[V#WrappedType](env)
-        Value.checkType(d, dV) // necessary because cast to V#WrappedType is erased
-        addCost(ByIndex.costKind)
-        inputV.getOrElse(indexV, dV)
+        if (VersionContext.current.isV6SoftForkActivated) {
+          // lazy evaluation of default in 6.0
+          addCost(ByIndex.costKind)
+          if (inputV.isDefinedAt(indexV)) {
+            inputV.apply(indexV)
+          } else {
+            val dV = d.evalTo[V#WrappedType](env)
+            Value.checkType(d, dV) // necessary because cast to V#WrappedType is erased
+            inputV.getOrElse(indexV, dV)
+          }
+        } else {
+          val dV = d.evalTo[V#WrappedType](env)
+          Value.checkType(d, dV) // necessary because cast to V#WrappedType is erased
+          addCost(ByIndex.costKind)
+          inputV.getOrElse(indexV, dV)
+        }
       case _ =>
         addCost(ByIndex.costKind)
         inputV.apply(indexV)
@@ -613,11 +625,22 @@ case class OptionGetOrElse[V <: SType](input: Value[SOption[V]], default: Value[
   override val opType = SFunc(IndexedSeq(input.tpe, tpe), tpe)
   override def tpe: V = input.tpe.elemType
   protected final override def eval(env: DataEnv)(implicit E: ErgoTreeEvaluator): Any = {
-    val inputV = input.evalTo[Option[V#WrappedType]](env)
-    val dV = default.evalTo[V#WrappedType](env)  // TODO v6.0: execute lazily (see https://github.com/ScorexFoundation/sigmastate-interpreter/issues/906)
-    Value.checkType(default, dV) // necessary because cast to V#WrappedType is erased
-    addCost(OptionGetOrElse.costKind)
-    inputV.getOrElse(dV)
+    if(VersionContext.current.isV6SoftForkActivated) {
+      // lazy evaluation of default in 6.0
+      val inputV = input.evalTo[Option[V#WrappedType]](env)
+      addCost(OptionGetOrElse.costKind)
+      inputV.getOrElse {
+        val dV = default.evalTo[V#WrappedType](env)
+        Value.checkType(default, dV) // necessary because cast to V#WrappedType is erased
+        dV
+      }
+    } else {
+      val inputV = input.evalTo[Option[V#WrappedType]](env)
+      val dV = default.evalTo[V#WrappedType](env)
+      Value.checkType(default, dV) // necessary because cast to V#WrappedType is erased
+      addCost(OptionGetOrElse.costKind)
+      inputV.getOrElse(dV)
+    }
   }
 }
 object OptionGetOrElse extends ValueCompanion with FixedCostValueCompanion {
diff --git a/data/shared/src/main/scala/sigma/interpreter/ContextExtension.scala b/data/shared/src/main/scala/sigma/interpreter/ContextExtension.scala
index e8cdb7d709..f03d076d43 100644
--- a/data/shared/src/main/scala/sigma/interpreter/ContextExtension.scala
+++ b/data/shared/src/main/scala/sigma/interpreter/ContextExtension.scala
@@ -16,8 +16,15 @@ import sigma.serialization.{SigmaByteReader, SigmaByteWriter, SigmaSerializer}
   * @param values internal container of the key-value pairs
   */
 case class ContextExtension(values: scala.collection.Map[Byte, EvaluatedValue[_ <: SType]]) {
-  def add(bindings: VarBinding*): ContextExtension =
+  def add(bindings: VarBinding*): ContextExtension = {
     ContextExtension(values ++ bindings)
+  }
+
+  /**
+    * @param varId - index of context variable
+    * @return context variable with provided index or None if it is not there
+    */
+  def get(varId: Byte): Option[EvaluatedValue[_ <: SType]] = values.get(varId)
 }
 
 object ContextExtension {
diff --git a/docs/LangSpec.md b/docs/LangSpec.md
index 5b72a8659d..16defff5ff 100644
--- a/docs/LangSpec.md
+++ b/docs/LangSpec.md
@@ -919,7 +919,7 @@ def longToByteArray(input: Long): Coll[Byte]
 def decodePoint(bytes: Coll[Byte]): GroupElement 
 
 
-/** Extracts Context variable by id and type.
+/** Extracts Context variable from SELF input by id and type.
   * ErgoScript is typed, so accessing a the variables is an operation which involves
   * some expected type given in brackets. Thus `getVar[Int](id)` expression should
   * evaluate to a valid value of the `Option[Int]` type.
@@ -976,6 +976,18 @@ def decodePoint(bytes: Coll[Byte]): GroupElement
   */
 def getVar[T](tag: Int): Option[T]
 
+/** Extracts Context variable from any input by input index, variable id and variable type.
+  * Unlike getVar, it is not throwing exception when expected type does not match real type of the variable.
+  * Thus it can be used to get context variable from self without exception, using selfBoxIndex, e.g. 
+  * <pre class="stHighlight">
+  *   {
+  *       val idx = CONTEXT.selfBoxIndex
+  *       sigmaProp(CONTEXT.getVarFromInput[Int](idx.toShort, 1.toByte).get == 5)
+  *   }
+  * </pre>
+  */
+def getVarFromInput[T](inputId: Short, varId: Byte): Option[T]
+
 /** Construct a new SigmaProp value representing public key of Diffie Hellman
   * signature protocol. When executed as part of Sigma protocol allow to provide
   * for a verifier a zero-knowledge proof of secret knowledge.
diff --git a/interpreter/shared/src/main/scala/org/ergoplatform/ErgoLikeContext.scala b/interpreter/shared/src/main/scala/org/ergoplatform/ErgoLikeContext.scala
index e421e8fdfe..4b1366d9fd 100644
--- a/interpreter/shared/src/main/scala/org/ergoplatform/ErgoLikeContext.scala
+++ b/interpreter/shared/src/main/scala/org/ergoplatform/ErgoLikeContext.scala
@@ -168,7 +168,7 @@ class ErgoLikeContext(val lastBlockUtxoRoot: AvlTreeData,
         syntax.error(s"Undefined context property: currentErgoTreeVersion"))
     CContext(
       dataInputs, headers, preHeader, inputs, outputs, preHeader.height, selfBox, selfIndex, avlTree,
-      preHeader.minerPk.getEncoded, vars, activatedScriptVersion, ergoTreeVersion)
+      preHeader.minerPk.getEncoded, vars, spendingTransaction, activatedScriptVersion, ergoTreeVersion)
   }
 
 
diff --git a/interpreter/shared/src/main/scala/sigmastate/eval/CContext.scala b/interpreter/shared/src/main/scala/sigmastate/eval/CContext.scala
index 2b076403ad..b0e5b01186 100644
--- a/interpreter/shared/src/main/scala/sigmastate/eval/CContext.scala
+++ b/interpreter/shared/src/main/scala/sigmastate/eval/CContext.scala
@@ -1,8 +1,11 @@
 package sigmastate.eval
 
 import debox.cfor
+import org.ergoplatform.{ErgoLikeTransactionTemplate, UnsignedInput}
+import sigma.Evaluation.stypeToRType
 import sigma.Extensions.ArrayOps
 import sigma._
+import sigma.ast.SType
 import sigma.data._
 import sigma.exceptions.InvalidType
 
@@ -24,6 +27,7 @@ case class CContext(
     lastBlockUtxoRootHash: AvlTree,
     _minerPubKey: Coll[Byte],
     vars: Coll[AnyValue],
+    spendingTransaction: ErgoLikeTransactionTemplate[_ <: UnsignedInput],
     override val activatedScriptVersion: Byte,
     override val currentErgoTreeVersion: Byte
 ) extends Context {
@@ -69,6 +73,14 @@ case class CContext(
     } else None
   }
 
+  override def getVarFromInput[T](inputIndex: Short, id: Byte)(implicit tT: RType[T]): Option[T] = {
+    spendingTransaction.inputs.lift(inputIndex).flatMap(_.extension.get(id)) match {
+      case Some(v) if stypeToRType[SType](v.tpe) == tT => Some(v.value.asInstanceOf[T])
+      case _ =>
+        None
+    }
+  }
+
   /** Return a new context instance with variables collection updated.
     * @param bindings  a new binding of the context variables with new values.
     * @return a new instance (if `bindings` non-empty) with the specified bindings.
diff --git a/interpreter/shared/src/test/scala/special/sigma/ContractsTestkit.scala b/interpreter/shared/src/test/scala/special/sigma/ContractsTestkit.scala
index b04e9c150f..ba04df1347 100644
--- a/interpreter/shared/src/test/scala/special/sigma/ContractsTestkit.scala
+++ b/interpreter/shared/src/test/scala/special/sigma/ContractsTestkit.scala
@@ -47,7 +47,7 @@ trait ContractsTestkit {
     new CContext(
       noInputs.toColl, noHeaders, dummyPreHeader,
       inputs.toColl, outputs.toColl, height, self, inputs.indexOf(self), tree,
-      minerPk.toColl, vars.toColl, activatedScriptVersion, currErgoTreeVersion)
+      minerPk.toColl, vars.toColl, null, activatedScriptVersion, currErgoTreeVersion)
 
   def newContext(
       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 bce313d20b..6048d884d1 100644
--- a/sc/shared/src/main/scala/sigma/compiler/ir/GraphBuilding.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/ir/GraphBuilding.scala
@@ -1,6 +1,7 @@
 package sigma.compiler.ir
 
 import org.ergoplatform._
+import sigma.ast.SType.tT
 import sigma.Evaluation.stypeToRType
 import sigma.ast.SType.tT
 import sigma.ast.TypeCodes.LastConstantCode
@@ -1099,6 +1100,15 @@ trait GraphBuilding extends Base with DefRewriting { IR: IRContext =>
               ctx.LastBlockUtxoRootHash
             case SContextMethods.minerPubKeyMethod.name =>
               ctx.minerPubKey
+            case SContextMethods.getVarV6Method.name =>
+              val c2 = asRep[Byte](argsV(0))
+              val c3 = stypeToElem(typeSubst.apply(tT))
+              ctx.getVar(c2)(c3)
+            case SContextMethods.getVarFromInputMethod.name =>
+              val c1 = asRep[Short](argsV(0))
+              val c2 = asRep[Byte](argsV(1))
+              val c3 = stypeToElem(typeSubst.apply(tT))
+              ctx.getVarFromInput(c1, c2)(c3)
             case _ => throwError()
           }
           case (tree: Ref[AvlTree]@unchecked, SAvlTreeMethods) => method.name match {
diff --git a/sc/shared/src/main/scala/sigma/compiler/ir/GraphIRReflection.scala b/sc/shared/src/main/scala/sigma/compiler/ir/GraphIRReflection.scala
index adea48af0a..8f461e502e 100644
--- a/sc/shared/src/main/scala/sigma/compiler/ir/GraphIRReflection.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/ir/GraphIRReflection.scala
@@ -349,6 +349,9 @@ object GraphIRReflection {
         mkMethod(clazz, "getVar", Array[Class[_]](classOf[Base#Ref[_]], classOf[TypeDescs#Elem[_]])) { (obj, args) =>
           obj.asInstanceOf[ctx.Context].getVar(args(0).asInstanceOf[ctx.Ref[Byte]])(args(1).asInstanceOf[ctx.Elem[_]])
         },
+        mkMethod(clazz, "getVarFromInput", Array[Class[_]](classOf[Base#Ref[_]], classOf[Base#Ref[_]], classOf[TypeDescs#Elem[_]])) { (obj, args) =>
+          obj.asInstanceOf[ctx.Context].getVarFromInput(args(0).asInstanceOf[ctx.Ref[Short]], args(1).asInstanceOf[ctx.Ref[Byte]])(args(2).asInstanceOf[ctx.Elem[_]])
+        },
         mkMethod(clazz, "headers", Array[Class[_]]()) { (obj, args) =>
           obj.asInstanceOf[ctx.Context].headers
         }
diff --git a/sc/shared/src/main/scala/sigma/compiler/ir/TreeBuilding.scala b/sc/shared/src/main/scala/sigma/compiler/ir/TreeBuilding.scala
index 906ace0fa4..37ec47f2dc 100644
--- a/sc/shared/src/main/scala/sigma/compiler/ir/TreeBuilding.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/ir/TreeBuilding.scala
@@ -1,6 +1,7 @@
 package sigma.compiler.ir
 
 import org.ergoplatform._
+import sigma.VersionContext
 import sigma.Evaluation.{rtypeToSType, stypeToRType}
 import sigma.ast.SType.tT
 import sigma.ast._
diff --git a/sc/shared/src/main/scala/sigma/compiler/ir/wrappers/sigma/SigmaDslUnit.scala b/sc/shared/src/main/scala/sigma/compiler/ir/wrappers/sigma/SigmaDslUnit.scala
index e2a43c693c..491a196f8d 100644
--- a/sc/shared/src/main/scala/sigma/compiler/ir/wrappers/sigma/SigmaDslUnit.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/ir/wrappers/sigma/SigmaDslUnit.scala
@@ -109,6 +109,7 @@ import scalan._
       def preHeader: Ref[PreHeader];
       def minerPubKey: Ref[Coll[Byte]];
       def getVar[T](id: Ref[Byte])(implicit cT: Elem[T]): Ref[WOption[T]];
+      def getVarFromInput[T](inputId: Ref[Short], id: Ref[Byte])(implicit cT: Elem[T]): Ref[WOption[T]];
     };
     trait SigmaDslBuilder extends Def[SigmaDslBuilder] {
       def Colls: Ref[CollBuilder];
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 468cc2efde..d9dbea493a 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
@@ -1902,10 +1902,19 @@ object Context extends EntityObject("Context") {
     }
 
     override def getVar[T](id: Ref[Byte])(implicit cT: Elem[T]): Ref[WOption[T]] = {
+      val st = Evaluation.rtypeToSType(cT.sourceType)
       asRep[WOption[T]](mkMethodCall(self,
         ContextClass.getMethod("getVar", classOf[Sym], classOf[Elem[_]]),
         Array[AnyRef](id, cT),
-        true, false, element[WOption[T]]))
+        true, false, element[WOption[T]], Map(tT -> st)))
+    }
+
+    override def getVarFromInput[T](inputId: Ref[Short], varId: Ref[Byte])(implicit cT: Elem[T]): Ref[WOption[T]] = {
+      val st = Evaluation.rtypeToSType(cT.sourceType)
+      asRep[WOption[T]](mkMethodCall(self,
+        ContextClass.getMethod("getVarFromInput", classOf[Sym], classOf[Sym], classOf[Elem[_]]),
+        Array[AnyRef](inputId, varId, cT),
+        true, false, element[WOption[T]], Map(tT -> st)))
     }
 
   }
@@ -1999,10 +2008,19 @@ object Context extends EntityObject("Context") {
     }
 
     def getVar[T](id: Ref[Byte])(implicit cT: Elem[T]): Ref[WOption[T]] = {
+      val st = Evaluation.rtypeToSType(cT.sourceType)
       asRep[WOption[T]](mkMethodCall(source,
         ContextClass.getMethod("getVar", classOf[Sym], classOf[Elem[_]]),
         Array[AnyRef](id, cT),
-        true, true, element[WOption[T]]))
+        true, true, element[WOption[T]], Map(tT -> st)))
+    }
+
+    def getVarFromInput[T](inputId: Ref[Short], varId: Ref[Byte])(implicit cT: Elem[T]): Ref[WOption[T]] = {
+      val st = Evaluation.rtypeToSType(cT.sourceType)
+      asRep[WOption[T]](mkMethodCall(source,
+        ContextClass.getMethod("getVarFromInput", classOf[Sym], classOf[Sym], classOf[Elem[_]]),
+        Array[AnyRef](inputId, varId, cT),
+        true, true, element[WOption[T]], Map(tT -> st)))
     }
   }
 
@@ -2021,7 +2039,7 @@ object Context extends EntityObject("Context") {
     override protected def collectMethods: Map[RMethod, MethodDesc] = {
       super.collectMethods ++
         Elem.declaredMethods(RClass(classOf[Context]), RClass(classOf[SContext]), Set(
-        "OUTPUTS", "INPUTS", "dataInputs", "HEIGHT", "SELF", "selfBoxIndex", "LastBlockUtxoRootHash", "headers", "preHeader", "minerPubKey", "getVar", "vars"
+        "OUTPUTS", "INPUTS", "dataInputs", "HEIGHT", "SELF", "selfBoxIndex", "LastBlockUtxoRootHash", "headers", "preHeader", "minerPubKey", "getVar", "getVarFromInput", "vars"
         ))
     }
   }
diff --git a/sc/shared/src/main/scala/sigma/compiler/phases/SigmaTyper.scala b/sc/shared/src/main/scala/sigma/compiler/phases/SigmaTyper.scala
index c251b5d50e..beb46554a3 100644
--- a/sc/shared/src/main/scala/sigma/compiler/phases/SigmaTyper.scala
+++ b/sc/shared/src/main/scala/sigma/compiler/phases/SigmaTyper.scala
@@ -134,8 +134,19 @@ class SigmaTyper(val builder: SigmaBuilder,
       res
 
     case Apply(ApplyTypes(sel @ Select(obj, n, _), Seq(rangeTpe)), args) =>
+      // downcast getVarFromInput arguments to short and byte
+      val nArgs = if (n == SContextMethods.getVarFromInputMethod.name &&
+          args.length == 2 &&
+          args(0).isInstanceOf[Constant[_]] &&
+          args(1).isInstanceOf[Constant[_]] &&
+          args(0).tpe.isNumType &&
+          args(1).tpe.isNumType) {
+        IndexedSeq(ShortConstant(SShort.downcast(args(0).asInstanceOf[Constant[SNumericType]].value.asInstanceOf[AnyVal])).withSrcCtx(args(0).sourceContext),
+          ByteConstant(SByte.downcast(args(1).asInstanceOf[Constant[SNumericType]].value.asInstanceOf[AnyVal])).withSrcCtx(args(1).sourceContext))
+      } else args
+
       val newObj = assignType(env, obj)
-      val newArgs = args.map(assignType(env, _))
+      val newArgs = nArgs.map(assignType(env, _))
       newObj.tpe match {
         case p: SProduct =>
           MethodsContainer.getMethod(p, n) match {
@@ -155,7 +166,7 @@ class SigmaTyper(val builder: SigmaBuilder,
                   .getOrElse(mkMethodCall(newObj, method, newArgs, subst))
               } else {
                 val newSelect = mkSelect(newObj, n, Some(concrFunTpe)).withSrcCtx(sel.sourceContext)
-                mkApply(newSelect, newArgs.toArray[SValue])
+                mkApply(newSelect, newArgs)
               }
             case Some(method) =>
               error(s"Don't know how to handle method $method in obj $p", sel.sourceContext)
@@ -232,6 +243,11 @@ class SigmaTyper(val builder: SigmaBuilder,
             case (Ident(GetVarFunc.name | ExecuteFromVarFunc.name, _), Seq(id: Constant[SNumericType]@unchecked))
               if id.tpe.isNumType =>
                 Seq(ByteConstant(SByte.downcast(id.value.asInstanceOf[AnyVal])).withSrcCtx(id.sourceContext))
+            case (Ident(SContextMethods.getVarFromInputMethod.name, _),
+                  Seq(inputId: Constant[SNumericType]@unchecked, varId: Constant[SNumericType]@unchecked))
+                  if inputId.tpe.isNumType && varId.tpe.isNumType =>
+              Seq(ShortConstant(SShort.downcast(inputId.value.asInstanceOf[AnyVal])).withSrcCtx(inputId.sourceContext),
+                ByteConstant(SByte.downcast(varId.value.asInstanceOf[AnyVal])).withSrcCtx(varId.sourceContext))
             case _ => typedArgs
           }
           val actualTypes = adaptedTypedArgs.map(_.tpe)
@@ -420,11 +436,6 @@ class SigmaTyper(val builder: SigmaBuilder,
           error(s"Invalid application of type arguments $app: function $input doesn't have type parameters", input.sourceContext)
       }
 
-//    case app @ ApplyTypes(in, targs) =>
-//      val newIn = assignType(env, in)
-//      ApplyTypes(newIn, targs)
-//      error(s"Invalid application of type arguments $app: expression doesn't have type parameters")
-
     case If(c, t, e) =>
       val c1 = assignType(env, c).asValue[SBoolean.type]
       val t1 = assignType(env, t)
diff --git a/sc/shared/src/test/scala/org/ergoplatform/ErgoLikeTransactionSpec.scala b/sc/shared/src/test/scala/org/ergoplatform/ErgoLikeTransactionSpec.scala
index 6a7ef5a512..4b3aa2eab5 100644
--- a/sc/shared/src/test/scala/org/ergoplatform/ErgoLikeTransactionSpec.scala
+++ b/sc/shared/src/test/scala/org/ergoplatform/ErgoLikeTransactionSpec.scala
@@ -7,8 +7,7 @@ import org.ergoplatform.settings.ErgoAlgos
 import scorex.util.encode.Base16
 import scorex.util.{ModifierId, Random}
 import sigma.Extensions._
-import sigma.SigmaDslTesting
-import sigma.ast.SCollection.SByteArray
+import sigma.{SigmaDslTesting, VersionContext}
 import sigma.ast.SType._
 import sigma.ast.syntax.{ErgoBoxCandidateRType, TrueSigmaProp}
 import sigma.ast._
@@ -20,9 +19,11 @@ import sigmastate.helpers.TestingHelpers.copyTransaction
 import sigmastate.utils.Helpers
 import sigma.SigmaDslTesting
 import sigma.Extensions._
+import sigma.ast.SCollection.SByteArray
+import sigmastate.CrossVersionProps
 import sigmastate.utils.Helpers.EitherOps  // required for Scala 2.11
 
-class ErgoLikeTransactionSpec extends SigmaDslTesting with JsonCodecs {
+  class ErgoLikeTransactionSpec extends SigmaDslTesting with CrossVersionProps with JsonCodecs {
 
   property("ErgoBox test vectors") {
     val token1 = "6e789ab7b2fffff12280a6cd01557f6fb22b7f80ff7aff8e1f7f15973d7f0001"
@@ -99,14 +100,24 @@ class ErgoLikeTransactionSpec extends SigmaDslTesting with JsonCodecs {
 
     { // test case for R2
       val res = b1.get(ErgoBox.R2).get
-      val exp = Coll(
-        (Digest32Coll @@ ErgoAlgos.decodeUnsafe(token1).toColl) -> 10000000L,
-        (Digest32Coll @@ ErgoAlgos.decodeUnsafe(token2).toColl) -> 500L
-      ).map(identity).toConstant
-      // TODO v6.0 (16h): fix collections equality and remove map(identity)
-      //  (PairOfColl should be equal CollOverArray but now it is not)
+
+      // We have versioned check here due to fixed collections equality in 6.0.0
+      //  (PairOfColl equal CollOverArray now)
       // see (https://github.com/ScorexFoundation/sigmastate-interpreter/issues/909)
-      res shouldBe exp
+      if(VersionContext.current.isV6SoftForkActivated) {
+        val exp = Coll(
+          (Digest32Coll @@ ErgoAlgos.decodeUnsafe(token1).toColl) -> 10000000L,
+          (Digest32Coll @@ ErgoAlgos.decodeUnsafe(token2).toColl) -> 500L
+        ).toConstant
+        res shouldBe exp
+        exp shouldBe res
+      } else {
+        val exp = Coll(
+          (Digest32Coll @@ ErgoAlgos.decodeUnsafe(token1).toColl) -> 10000000L,
+          (Digest32Coll @@ ErgoAlgos.decodeUnsafe(token2).toColl) -> 500L
+        ).map(identity).toConstant
+        res shouldBe exp
+      }
     }
 
     { // test case for R3
@@ -470,7 +481,6 @@ class ErgoLikeTransactionSpec extends SigmaDslTesting with JsonCodecs {
     // test equivalence of "from Json" and "from bytes" deserialization
     tx2.id shouldBe tx.id
     tx2.id shouldBe "d5c0a7908bbb8eefe72ad70a9f668dd47b748239fd34378d3588d5625dd75c82"
-    println(tx2.id)
   }
 
   property("Tuple in register test vector") {
diff --git a/sc/shared/src/test/scala/sigma/LanguageSpecificationV5.scala b/sc/shared/src/test/scala/sigma/LanguageSpecificationV5.scala
index bd86feb82b..0bb92f8249 100644
--- a/sc/shared/src/test/scala/sigma/LanguageSpecificationV5.scala
+++ b/sc/shared/src/test/scala/sigma/LanguageSpecificationV5.scala
@@ -4533,6 +4533,7 @@ class LanguageSpecificationV5 extends LanguageSpecificationBase { suite =>
           .append(Coll[AnyValue](
             CAnyValue(Helpers.decodeBytes("00")),
             CAnyValue(true))),
+      spendingTransaction = null,
       activatedScriptVersion = activatedVersionInTests,
       currentErgoTreeVersion = ergoTreeVersionInTests
     )
@@ -8059,6 +8060,7 @@ class LanguageSpecificationV5 extends LanguageSpecificationBase { suite =>
           )
         )
     )
+    if(!VersionContext.current.isV6SoftForkActivated) {
     verifyCases(
       // (coll, (index, default))
       {
@@ -8129,7 +8131,7 @@ class LanguageSpecificationV5 extends LanguageSpecificationBase { suite =>
               )
             )
           )
-      ))
+      ))}
   }
 
   property("Tuple size method equivalence") {
@@ -8696,13 +8698,15 @@ class LanguageSpecificationV5 extends LanguageSpecificationBase { suite =>
         "{ (x: Option[Long]) => x.isDefined }",
         FuncValue(Vector((1, SOption(SLong))), OptionIsDefined(ValUse(1, SOption(SLong))))))
 
-    verifyCases(
-      Seq(
-        (None -> Expected(Success(1L), 1766, costDetails3, 1766, Seq.fill(4)(2006))),
-        (Some(10L) -> Expected(Success(10L), 1766, costDetails3, 1766, Seq.fill(4)(2006)))),
-      existingFeature({ (x: Option[Long]) => x.getOrElse(1L) },
-        "{ (x: Option[Long]) => x.getOrElse(1L) }",
-        FuncValue(Vector((1, SOption(SLong))), OptionGetOrElse(ValUse(1, SOption(SLong)), LongConstant(1L)))))
+        if (!VersionContext.current.isV6SoftForkActivated) {
+      verifyCases(
+        Seq(
+          (None -> Expected(Success(1L), 1766, costDetails3, 1766, Seq.fill(4)(2006))),
+          (Some(10L) -> Expected(Success(10L), 1766, costDetails3, 1766, Seq.fill(4)(2006)))),
+        existingFeature({ (x: Option[Long]) => x.getOrElse(1L) },
+          "{ (x: Option[Long]) => x.getOrElse(1L) }",
+          FuncValue(Vector((1, SOption(SLong))), OptionGetOrElse(ValUse(1, SOption(SLong)), LongConstant(1L)))))
+    }
 
     verifyCases(
       Seq(
diff --git a/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala b/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
index 481c7101da..15ce673332 100644
--- a/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
+++ b/sc/shared/src/test/scala/sigma/LanguageSpecificationV6.scala
@@ -1,23 +1,31 @@
 package sigma
 
-import org.ergoplatform.ErgoHeader
+import org.ergoplatform.{ErgoBox, ErgoHeader, ErgoLikeTransaction, Input}
 import scorex.util.encode.Base16
 import sigma.VersionContext.V6SoftForkVersion
-import org.ergoplatform.ErgoBox
 import org.ergoplatform.ErgoBox.Token
+import org.ergoplatform.settings.ErgoAlgos
 import scorex.util.ModifierId
 import scorex.utils.{Ints, Longs, Shorts}
-import sigma.ast.ErgoTree.ZeroHeader
+import sigma.ast.ErgoTree.{HeaderType, ZeroHeader}
 import sigma.ast.SCollection.SByteArray
 import sigma.ast.syntax.TrueSigmaProp
 import sigma.ast.{SInt, _}
+import sigma.data.{AvlTreeData, AvlTreeFlags, CAnyValue, CAvlTree, CBigInt, CBox, CHeader, CSigmaProp, ExactNumeric, ProveDHTuple, RType}
 import sigma.data.{CBigInt, CBox, CHeader, CSigmaDslBuilder, ExactNumeric, PairOfCols, RType}
 import sigma.eval.{CostDetails, SigmaDsl, TracedCost}
 import sigma.serialization.ValueCodes.OpCode
 import sigma.util.Extensions.{BooleanOps, IntOps}
+import sigmastate.eval.{CContext, CPreHeader}
+import sigma.util.Extensions.{BooleanOps, IntOps}
+import sigma.data.{RType}
+import sigma.serialization.ValueCodes.OpCode
+import sigma.util.Extensions.{BooleanOps, ByteOps, IntOps, LongOps}
 import sigmastate.exceptions.MethodNotFound
 import sigmastate.utils.Extensions.ByteOpsForSigma
 import sigmastate.utils.Helpers
+import sigma.Extensions.{ArrayOps, CollOps}
+import sigma.interpreter.{ContextExtension, ProverResult}
 
 import java.math.BigInteger
 import scala.util.{Failure, Success}
@@ -1522,6 +1530,243 @@ class LanguageSpecificationV6 extends LanguageSpecificationBase { suite =>
     )
   }
 
+  private def contextData() = {
+    val input = CBox(
+      new ErgoBox(
+        80946L,
+        new ErgoTree(
+          HeaderType @@ 16.toByte,
+          Vector(
+            SigmaPropConstant(
+              CSigmaProp(
+                ProveDHTuple(
+                  Helpers.decodeECPoint("03c046fccb95549910767d0543f5e8ce41d66ae6a8720a46f4049cac3b3d26dafb"),
+                  Helpers.decodeECPoint("023479c9c3b86a0d3c8be3db0a2d186788e9af1db76d55f3dad127d15185d83d03"),
+                  Helpers.decodeECPoint("03d7898641cb6653585a8e1dabfa7f665e61e0498963e329e6e3744bd764db2d72"),
+                  Helpers.decodeECPoint("037ae057d89ec0b46ff8e9ff4c37e85c12acddb611c3f636421bef1542c11b0441")
+                )
+              )
+            )
+          ),
+          Right(ConstantPlaceholder(0, SSigmaProp))
+        ),
+        Coll(),
+        Map(
+          ErgoBox.R4 -> ByteArrayConstant(Helpers.decodeBytes("34")),
+          ErgoBox.R5 -> TrueLeaf
+        ),
+        ModifierId @@ ("0000bfe96a7c0001e7a5ee00aafb80ff057fbe7f8c6680e33a3dc18001820100"),
+        1.toShort,
+        5
+      )
+    )
+
+    val tx = ErgoLikeTransaction(
+      IndexedSeq(),
+      IndexedSeq(input.wrappedValue)
+    )
+
+    val tx2 = ErgoLikeTransaction(
+      IndexedSeq(Input(input.ebox.id, ProverResult(Array.emptyByteArray, ContextExtension(Map(11.toByte -> BooleanConstant(true)))))),
+      IndexedSeq(input.wrappedValue)
+    )
+
+    val tx3 = ErgoLikeTransaction(
+      IndexedSeq(Input(input.ebox.id, ProverResult(Array.emptyByteArray, ContextExtension(Map(11.toByte -> IntConstant(0)))))),
+      IndexedSeq(input.wrappedValue)
+    )
+
+    val tx4 = ErgoLikeTransaction(
+      IndexedSeq(Input(input.ebox.id, ProverResult(Array.emptyByteArray, ContextExtension(Map(11.toByte -> BooleanConstant(false)))))),
+      IndexedSeq(input.wrappedValue)
+    )
+
+    val ctx = CContext(
+      _dataInputs = Coll[Box](),
+      headers = Coll[Header](),
+      preHeader = CPreHeader(
+        0.toByte,
+        Colls.fromArray(Array.fill(32)(0.toByte)),
+        -755484979487531112L,
+        9223372036854775807L,
+        11,
+        Helpers.decodeGroupElement("0227a58e9b2537103338c237c52c1213bf44bdb344fa07d9df8ab826cca26ca08f"),
+        Helpers.decodeBytes("007f00")
+      ),
+      inputs = Coll[Box](input),
+      outputs = Coll[Box](),
+      height = 11,
+      selfBox = input.copy(), // in 3.x, 4.x implementation selfBox is never the same instance as input (see toSigmaContext)
+      selfIndex = 0,
+      lastBlockUtxoRootHash = CAvlTree(
+        AvlTreeData(
+          ErgoAlgos.decodeUnsafe("54d23dd080006bdb56800100356080935a80ffb77e90b800057f00661601807f17").toColl,
+          AvlTreeFlags(true, true, true),
+          1211925457,
+          None
+        )
+      ),
+      _minerPubKey = Helpers.decodeBytes("0227a58e9b2537103338c237c52c1213bf44bdb344fa07d9df8ab826cca26ca08f"),
+      vars = Colls
+        .replicate[AnyValue](10, null) // reserve 10 vars
+        .append(Coll[AnyValue](
+          CAnyValue(Helpers.decodeBytes("00")),
+          CAnyValue(true))),
+      spendingTransaction = tx,
+      activatedScriptVersion = activatedVersionInTests,
+      currentErgoTreeVersion = ergoTreeVersionInTests
+    )
+    val ctx2 = ctx.copy(spendingTransaction = tx2)
+    val ctx3 = ctx.copy(spendingTransaction = tx3, vars = ctx.vars.patch(11, Coll(CAnyValue(0)), 1))
+    val ctx4 = ctx.copy(spendingTransaction = tx4, vars = ctx.vars.patch(11, Coll(CAnyValue(false)), 1))
+
+    (ctx, ctx2, ctx3, ctx4)
+  }
+
+  property("getVarFromInput") {
+
+    def getVarFromInput = {
+      newFeature(
+        { (x: Context) => x.getVarFromInput[Boolean](0, 11) },
+        "{ (x: Context) => x.getVarFromInput[Boolean](0, 11) }",
+        FuncValue(
+          Array((1, SContext)),
+          MethodCall.typed[Value[SOption[SBoolean.type]]](
+            ValUse(1, SContext),
+            SContextMethods.getVarFromInputMethod.withConcreteTypes(Map(STypeVar("T") -> SBoolean)),
+            Array(ShortConstant(0.toShort), ByteConstant(11.toByte)),
+            Map(STypeVar("T") -> SBoolean)
+          )
+        ),
+        sinceVersion = VersionContext.V6SoftForkVersion
+      )
+    }
+
+    val (ctx, ctx2, ctx3, ctx4) = contextData()
+
+    verifyCases(
+      Seq(
+        ctx -> new Expected(ExpectedResult(Success(None), None)), // input with # provided does not exist
+        ctx2 -> new Expected(ExpectedResult(Success(Some(true)), None)),
+        ctx3 -> new Expected(ExpectedResult(Success(None), None)), // not expected type in context var
+        ctx4 -> new Expected(ExpectedResult(Success(Some(false)), None))
+      ),
+      getVarFromInput
+    )
+  }
+
+  property("Context.getVar") {
+
+    def getVar = {
+      newFeature(
+        { (x: Context) => x.getVar[Boolean](11)},
+        "{ (x: Context) => CONTEXT.getVar[Boolean](11.toByte) }",
+        sinceVersion = VersionContext.V6SoftForkVersion
+      )
+    }
+
+    val (_, ctx2, ctx3, ctx4) = contextData()
+
+    verifyCases(
+      Seq(
+        ctx2 -> new Expected(ExpectedResult(Success(Some(true)), None)),
+        ctx3 -> new Expected(ExpectedResult(Failure(new sigma.exceptions.InvalidType("Cannot getVar[Boolean](11): invalid type of value TestValue(0) at id=11")), None)), // not expected type in context var
+        ctx4 -> new Expected(ExpectedResult(Success(Some(false)), None))
+      ),
+      getVar
+    )
+  }
+
+  property("Option.getOrElse with lazy default") {
+
+    val trace = TracedCost(
+      Array(
+        FixedCostItem(Apply),
+        FixedCostItem(FuncValue),
+        FixedCostItem(GetVar),
+        FixedCostItem(OptionGet),
+        FixedCostItem(FuncValue.AddToEnvironmentDesc, FixedCost(JitCost(5))),
+        FixedCostItem(ValUse),
+        FixedCostItem(OptionGetOrElse)
+      )
+    )
+
+    verifyCases(
+      Seq(
+        Some(2L) -> Expected(Failure(new java.lang.ArithmeticException("/ by zero")), 6, trace, 1793,
+          newVersionedResults = {
+            expectedSuccessForAllTreeVersions(2L, 2015, trace)
+          } ),
+        None -> Expected(Failure(new java.lang.ArithmeticException("/ by zero")), 6, trace, 1793)
+      ),
+      changedFeature(
+        changedInVersion = VersionContext.V6SoftForkVersion,
+        { (x: Option[Long]) => val default = 1 / 0L; x.getOrElse(default) },
+        { (x: Option[Long]) => if (VersionContext.current.isV6SoftForkActivated) {x.getOrElse(1 / 0L)} else {val default = 1 / 0L; x.getOrElse(default)} },
+        "{ (x: Option[Long]) => x.getOrElse(1 / 0L) }",
+        FuncValue(
+          Array((1, SOption(SLong))),
+          OptionGetOrElse(
+            ValUse(1, SOption(SLong)),
+            ArithOp(LongConstant(1L), LongConstant(0L), OpCode @@ (-99.toByte))
+          )
+        ),
+        allowNewToSucceed = true
+      )
+    )
+  }
+
+  property("Coll getOrElse with lazy default") {
+
+    val trace = TracedCost(
+      Array(
+        FixedCostItem(Apply),
+        FixedCostItem(FuncValue),
+        FixedCostItem(GetVar),
+        FixedCostItem(OptionGet),
+        FixedCostItem(FuncValue.AddToEnvironmentDesc, FixedCost(JitCost(5))),
+        FixedCostItem(ValUse),
+        FixedCostItem(Constant),
+        FixedCostItem(ByIndex)
+      )
+    )
+
+    def scalaFuncNew(x: Coll[Int]) = {
+      if (VersionContext.current.isV6SoftForkActivated) {
+        x.toArray.toIndexedSeq.headOption.getOrElse(1 / 0)
+      } else scalaFuncOld(x)
+    }
+
+    def scalaFuncOld(x: Coll[Int]) = {
+      x.getOrElse(0, 1 / 0)
+    }
+
+    verifyCases(
+      Seq(
+        Coll(1) -> Expected(Failure(new java.lang.ArithmeticException("/ by zero")), 6, trace, 1793,
+          newVersionedResults = {
+            expectedSuccessForAllTreeVersions(1, 2029, trace)
+          } ),
+        Coll[Int]() -> Expected(Failure(new java.lang.ArithmeticException("/ by zero")), 6, trace, 1793)
+      ),
+      changedFeature(
+        changedInVersion = VersionContext.V6SoftForkVersion,
+        scalaFuncOld,
+        scalaFuncNew,
+        "{ (x: Coll[Int]) => x.getOrElse(0, 1 / 0) }",
+        FuncValue(
+          Array((1, SCollectionType(SInt))),
+          ByIndex(
+            ValUse(1, SCollectionType(SInt)),
+            IntConstant(0),
+            Some(ArithOp(IntConstant(1), IntConstant(0), OpCode @@ (-99.toByte)))
+          )
+        ),
+        allowNewToSucceed = true
+      )
+    )
+  }
+
 
   property("Global - fromBigEndianBytes") {
     import sigma.data.OrderingOps.BigIntOrdering
diff --git a/sc/shared/src/test/scala/sigma/SigmaDslStaginTests.scala b/sc/shared/src/test/scala/sigma/SigmaDslStaginTests.scala
index bcd4b21129..266c5e66e5 100644
--- a/sc/shared/src/test/scala/sigma/SigmaDslStaginTests.scala
+++ b/sc/shared/src/test/scala/sigma/SigmaDslStaginTests.scala
@@ -34,8 +34,6 @@ class SigmaDslStaginTests extends BaseCtxTests with ErgoScriptTestkit with BaseL
     val ctx: SContext = newContext(10, boxA1, VersionContext.MaxSupportedScriptVersion, VersionContext.MaxSupportedScriptVersion)
       .withInputs(boxA2)
       .withVariables(Map(1 -> toAnyValue(30), 2 -> toAnyValue(40)))
-    val p1: SSigmaProp = sigma.eval.SigmaDsl.SigmaProp(TrivialProp(true))
-    val p2: SSigmaProp = sigma.eval.SigmaDsl.SigmaProp(TrivialProp(false))
 
     cake.check(dsl,  { env: EnvRep[RSigmaDslBuilder] =>
       for { dsl <- env; arg <- lifted(true) } yield dsl.sigmaProp(arg) }, dsl.sigmaProp(true))
diff --git a/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala b/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
index 2eb73428a2..de9e080862 100644
--- a/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
+++ b/sc/shared/src/test/scala/sigma/SigmaDslTesting.scala
@@ -771,7 +771,7 @@ class SigmaDslTesting extends AnyPropSpec
     override def checkExpected(input: A, expected: Expected[B]): Unit = {
       // check the new implementation with Scala semantic function
       val newRes = VersionContext.withVersions(activatedVersionInTests, ergoTreeVersionInTests) {
-        checkEq(scalaFuncNew)(newF)(input)
+          checkEq(scalaFuncNew)(newF)(input)
       }
 
       if (VersionContext.current.activatedVersion < changedInVersion) {
diff --git a/sc/shared/src/test/scala/sigmastate/ErgoTreeSpecification.scala b/sc/shared/src/test/scala/sigmastate/ErgoTreeSpecification.scala
index b368a9da3d..1c38ca45a0 100644
--- a/sc/shared/src/test/scala/sigmastate/ErgoTreeSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/ErgoTreeSpecification.scala
@@ -509,8 +509,11 @@ class ErgoTreeSpecification extends SigmaDslTesting with ContractsTestkit with C
         MInfo(1, dataInputsMethod), MInfo(2, headersMethod), MInfo(3, preHeaderMethod),
         MInfo(4, inputsMethod), MInfo(5, outputsMethod), MInfo(6, heightMethod),
         MInfo(7, selfMethod), MInfo(8, selfBoxIndexMethod), MInfo(9, lastBlockUtxoRootHashMethod),
-        MInfo(10, minerPubKeyMethod), MInfo(11, getVarMethod)
-      ), true)
+        MInfo(10, minerPubKeyMethod)) ++ (if(VersionContext.current.isV6SoftForkActivated){
+          Seq(MInfo(11, getVarV6Method), MInfo(12, getVarFromInputMethod))
+        } else {
+          Seq(MInfo(11, getVarV5Method))
+        }), true)
     },
     { import SGlobalMethods._
       (SGlobal.typeId, Seq(
diff --git a/sc/shared/src/test/scala/sigmastate/lang/SigmaTyperTest.scala b/sc/shared/src/test/scala/sigmastate/lang/SigmaTyperTest.scala
index 5992259628..c86cb11afc 100644
--- a/sc/shared/src/test/scala/sigmastate/lang/SigmaTyperTest.scala
+++ b/sc/shared/src/test/scala/sigmastate/lang/SigmaTyperTest.scala
@@ -683,6 +683,16 @@ class SigmaTyperTest extends AnyPropSpec
     typecheck(env, "CONTEXT.dataInputs") shouldBe SCollection(SBox)
   }
 
+  property("SContext.getVar") {
+    typecheck(env, "CONTEXT.getVar[Int](1.toByte).get") shouldBe SInt
+  }
+
+  property("SContext.getVarFromInput") {
+    runWithVersion(VersionContext.V6SoftForkVersion) {
+      typecheck(env, "CONTEXT.getVarFromInput[Int](1.toShort, 1.toByte).get") shouldBe SInt
+    }
+  }
+
   property("SAvlTree.digest") {
     typecheck(env, "getVar[AvlTree](1).get.digest") shouldBe SByteArray
   }
diff --git a/sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala b/sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala
index 7a5f6ae668..11d5e9b00a 100644
--- a/sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala
+++ b/sc/shared/src/test/scala/sigmastate/utxo/BasicOpsSpecification.scala
@@ -4,10 +4,10 @@ import org.ergoplatform.ErgoBox.{AdditionalRegisters, R6, R8}
 import org.ergoplatform._
 import org.scalatest.Assertion
 import scorex.util.encode.Base16
-import org.scalatest.Assertion
 import scorex.utils.Ints
 import sigma.Extensions.ArrayOps
 import sigma.{SigmaTestingData, VersionContext}
+import sigma.VersionContext.{V6SoftForkVersion, withVersions}
 import sigma.VersionContext.V6SoftForkVersion
 import sigma.VersionContext
 import sigma.GroupElement
@@ -23,16 +23,18 @@ import sigmastate._
 import sigmastate.helpers.TestingHelpers._
 import sigmastate.helpers.{CompilerTestingCommons, ContextEnrichingTestProvingInterpreter, ErgoLikeContextTesting, ErgoLikeTestInterpreter}
 import sigma.interpreter.ContextExtension.VarBinding
-import sigmastate.interpreter.CErgoTreeEvaluator.DefaultEvalSettings
+import sigmastate.interpreter.CErgoTreeEvaluator.{DefaultEvalSettings, currentEvaluator}
 import sigmastate.interpreter.Interpreter._
 import sigma.ast.Apply
 import sigma.eval.EvalSettings
 import sigma.exceptions.InvalidType
 import sigma.serialization.ErgoTreeSerializer
+import sigma.interpreter.{ContextExtension, ProverResult}
 import sigmastate.utils.Helpers
 import sigmastate.utils.Helpers._
 
 import java.math.BigInteger
+import scala.collection.compat.immutable.ArraySeq
 import java.security.SecureRandom
 import scala.annotation.tailrec
 
@@ -96,8 +98,11 @@ class BasicOpsSpecification extends CompilerTestingCommons
       // is not supported by ErgoScript Compiler)
       // In such cases we use expected property as the property to test
       propExp.asSigmaProp
-    } else
-      compile(env, script).asBoolValue.toSigmaProp
+    } else {
+      withVersions(VersionContext.MaxSupportedScriptVersion, ergoTreeVersionInTests) {
+        compile(env, script).asBoolValue.toSigmaProp
+      }
+    }
 
     if (propExp != null)
       prop shouldBe propExp
@@ -114,7 +119,8 @@ class BasicOpsSpecification extends CompilerTestingCommons
     val newBox1 = testBox(10, tree, creationHeight = 0, boxIndex = 0, additionalRegisters = Map(
       reg1 -> IntConstant(1),
       reg2 -> IntConstant(10)))
-    val tx = createTransaction(newBox1)
+    val ce = ContextExtension(prover.contextExtenders)
+    val tx = new ErgoLikeTransaction(IndexedSeq(Input(boxToSpend.id, ProverResult(Array.empty, ce))), ArraySeq.empty, IndexedSeq(newBox1))
 
     val ctx = ErgoLikeContextTesting(currentHeight = 0,
       lastBlockUtxoRoot = AvlTreeData.dummy, ErgoLikeContextTesting.dummyPubkey, boxesToSpend = IndexedSeq(boxToSpend),
@@ -149,6 +155,64 @@ class BasicOpsSpecification extends CompilerTestingCommons
   }
 
 
+  property("getVarFromInput") {
+    def getVarTest(): Assertion = {
+      val customExt = Map(
+        1.toByte -> IntConstant(5)
+      ).toSeq
+      test("R1", env, customExt,
+        "{ sigmaProp(getVarFromInput[Int](0, 1).get == 5) }",
+        null
+      )
+    }
+
+    if (VersionContext.current.isV6SoftForkActivated) {
+      getVarTest()
+    } else {
+      an[sigma.validation.ValidationException] should be thrownBy getVarTest()
+    }
+  }
+
+  property("getVarFromInput - self index") {
+    def getVarTest(): Assertion = {
+      val customExt = Map(
+        1.toByte -> IntConstant(5)
+      ).toSeq
+      test("R1", env, customExt,
+        """{
+          | val idx = CONTEXT.selfBoxIndex
+          | sigmaProp(CONTEXT.getVarFromInput[Int](idx.toShort, 1.toByte).get == 5)
+          | }""".stripMargin,
+        null
+      )
+    }
+
+    if (VersionContext.current.isV6SoftForkActivated) {
+      getVarTest()
+    } else {
+      an[sigma.validation.ValidationException] should be thrownBy getVarTest()
+    }
+  }
+
+  property("getVarFromInput - invalid input") {
+    def getVarTest(): Assertion = {
+      val customExt = Map(
+        1.toByte -> IntConstant(5)
+      ).toSeq
+      test("R1", env, customExt,
+        "{ sigmaProp(CONTEXT.getVarFromInput[Int](1, 1).isDefined == false) }",
+        null
+      )
+    }
+
+    if (VersionContext.current.isV6SoftForkActivated) {
+      getVarTest()
+    } else {
+      an[sigma.validation.ValidationException] should be thrownBy getVarTest()
+    }
+  }
+
+
   property("group order deserialization") {
     val b = SecP256K1Group.q
 
@@ -635,9 +699,12 @@ class BasicOpsSpecification extends CompilerTestingCommons
   }
 
   property("Byte.toBits") {
-    def toBitsTest() = test("Byte.toBits", env, ext,
+    val customExt = Map(
+      1.toByte -> ByteConstant(1)
+    ).toSeq
+    def toBitsTest() = test("Byte.toBits", env, customExt,
       """{
-        | val b = 1.toByte
+        | val b = getVar[Byte](1).get
         | b.toBits == Coll(false, false, false, false, false, false, false, true)
         |}""".stripMargin,
       null
@@ -646,14 +713,17 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       toBitsTest()
     } else {
-      an[Exception] shouldBe thrownBy(toBitsTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(toBitsTest())
     }
   }
 
   property("Long.toBits") {
-    def toBitsTest() = test("Long.toBits", env, ext,
+    val customExt = Map(
+      1.toByte -> LongConstant(1)
+    ).toSeq
+    def toBitsTest() = test("Long.toBits", env, customExt,
       """{
-        | val b = 1L
+        | val b = getVar[Long](1).get
         | val ba = b.toBits
         |
         | // only rightmost bit is set
@@ -665,7 +735,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       toBitsTest()
     } else {
-      an[Exception] shouldBe thrownBy(toBitsTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(toBitsTest())
     }
   }
 
@@ -682,7 +752,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       toBitsTest()
     } else {
-      an[Exception] shouldBe thrownBy(toBitsTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(toBitsTest())
     }
   }
 
@@ -699,10 +769,11 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       bitwiseInverseTest()
     } else {
-      an[Exception] shouldBe thrownBy(bitwiseInverseTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(bitwiseInverseTest())
     }
   }
 
+
   property("Byte.bitwiseInverse") {
     def bitwiseInverseTest(): Assertion = test("Byte.bitwiseInverse", env, ext,
       s"""{
@@ -715,14 +786,17 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       bitwiseInverseTest()
     } else {
-      an[Exception] shouldBe thrownBy(bitwiseInverseTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(bitwiseInverseTest())
     }
   }
 
   property("Long.bitwiseInverse") {
-    def bitwiseInverseTest(): Assertion = test("Long.bitwiseInverse", env, ext,
+    val customExt = Map(
+      1.toByte -> LongConstant(9223372036854775807L)
+    ).toSeq
+    def bitwiseInverseTest(): Assertion = test("Long.bitwiseInverse", env, customExt,
       s"""{
-         | val l = 9223372036854775807L
+         | val l = getVar[Long](1).get
          | val lb = l.bitwiseInverse
          | lb.bitwiseInverse == l
          |}""".stripMargin,
@@ -732,14 +806,18 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       bitwiseInverseTest()
     } else {
-      an[Exception] shouldBe thrownBy(bitwiseInverseTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(bitwiseInverseTest())
     }
   }
 
+
   property("Byte.bitwiseOr") {
-    def bitwiseOrTest(): Assertion = test("Byte.bitwiseOrTest", env, ext,
+    val customExt = Map(
+      1.toByte -> ByteConstant(127)
+    ).toSeq
+    def bitwiseOrTest(): Assertion = test("Byte.bitwiseOrTest", env, customExt,
       s"""{
-         | val x = 127.toByte
+         | val x = getVar[Byte](1).get
          | val y = (-128).toByte
          | x.bitwiseOr(y) == -1
          |}""".stripMargin,
@@ -749,7 +827,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       bitwiseOrTest()
     } else {
-      an[Exception] shouldBe thrownBy(bitwiseOrTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(bitwiseOrTest())
     }
   }
 
@@ -765,7 +843,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       bitwiseOrTest()
     } else {
-      an[Exception] shouldBe thrownBy(bitwiseOrTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(bitwiseOrTest())
     }
   }
 
@@ -782,14 +860,17 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       bitwiseAndTest()
     } else {
-      an[Exception] shouldBe thrownBy(bitwiseAndTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(bitwiseAndTest())
     }
   }
 
   property("Short.bitwiseAnd") {
-    def bitwiseAndTest(): Assertion = test("Short.bitwiseAnd", env, ext,
+    val customExt = Map(
+      1.toByte -> ShortConstant(32767)
+    ).toSeq
+    def bitwiseAndTest(): Assertion = test("Short.bitwiseAnd", env, customExt,
       s"""{
-         | val x = (32767).toShort
+         | val x = getVar[Short](1).get
          | val y = (-32768).toShort
          | x.bitwiseAnd(y) == 0
          |}""".stripMargin,
@@ -799,14 +880,17 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       bitwiseAndTest()
     } else {
-      an[Exception] shouldBe thrownBy(bitwiseAndTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(bitwiseAndTest())
     }
   }
 
   property("Short.bitwiseXor") {
-    def bitwiseXorTest(): Assertion = test("Short.bitwiseXor", env, ext,
+    val customExt = Map(
+      1.toByte -> ShortConstant(32767)
+    ).toSeq
+    def bitwiseXorTest(): Assertion = test("Short.bitwiseXor", env, customExt,
       s"""{
-         | val x = (32767).toShort
+         | val x = getVar[Short](1).get
          | val y = (-32768).toShort
          | x.bitwiseXor(y) == -1
          |}""".stripMargin,
@@ -816,7 +900,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       bitwiseXorTest()
     } else {
-      an[Exception] shouldBe thrownBy(bitwiseXorTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(bitwiseXorTest())
     }
   }
 
@@ -833,7 +917,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       shiftLeftTest()
     } else {
-      an[Exception] shouldBe thrownBy(shiftLeftTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(shiftLeftTest())
     }
   }
 
@@ -850,7 +934,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       an[IllegalArgumentException] shouldBe thrownBy(shiftLeftTest())
     } else {
-      an[Exception] shouldBe thrownBy(shiftLeftTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(shiftLeftTest())
     }
   }
 
@@ -867,7 +951,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       shiftLeftTest()
     } else {
-      an[Exception] shouldBe thrownBy(shiftLeftTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(shiftLeftTest())
     }
   }
 
@@ -884,7 +968,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       shiftLeftTest()
     } else {
-      an[Exception] shouldBe thrownBy(shiftLeftTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(shiftLeftTest())
     }
   }
 
@@ -900,7 +984,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       an[ArithmeticException] shouldBe thrownBy(shiftLeftTest())
     } else {
-      an[Exception] shouldBe thrownBy(shiftLeftTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(shiftLeftTest())
     }
   }
 
@@ -917,7 +1001,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       shiftRightTest()
     } else {
-      an[Exception] shouldBe thrownBy(shiftRightTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(shiftRightTest())
     }
   }
 
@@ -934,7 +1018,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       shiftRightTest()
     } else {
-      an[Exception] shouldBe thrownBy(shiftRightTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(shiftRightTest())
     }
   }
 
@@ -951,10 +1035,11 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       an[IllegalArgumentException] shouldBe thrownBy(shiftRightTest())
     } else {
-      an[Exception] shouldBe thrownBy(shiftRightTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(shiftRightTest())
     }
   }
 
+
   property("Long.shiftRight - neg") {
     def shiftRightTest(): Assertion = test("Long.shiftRight", env, ext,
       s"""{
@@ -968,7 +1053,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       shiftRightTest()
     } else {
-      an[Exception] shouldBe thrownBy(shiftRightTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(shiftRightTest())
     }
   }
 
@@ -985,7 +1070,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       an[IllegalArgumentException] shouldBe thrownBy(shiftRightTest())
     } else {
-      an[Exception] shouldBe thrownBy(shiftRightTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(shiftRightTest())
     }
   }
 
@@ -1003,7 +1088,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       shiftRightTest()
     } else {
-      an[Exception] shouldBe thrownBy(shiftRightTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(shiftRightTest())
     }
   }
 
@@ -1021,30 +1106,26 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       an[IllegalArgumentException] shouldBe thrownBy(shiftRightTest())
     } else {
-      an[Exception] shouldBe thrownBy(shiftRightTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(shiftRightTest())
     }
   }
 
-  property("Unit register") {
-    // TODO frontend: implement missing Unit support in compiler
-    //  https://github.com/ScorexFoundation/sigmastate-interpreter/issues/820
-    test("R1", env, ext,
-      script = "", /* means cannot be compiled
-                     the corresponding script is { SELF.R4[Unit].isDefined } */
-      ExtractRegisterAs[SUnit.type](Self, reg1)(SUnit).isDefined.toSigmaProp,
-      additionalRegistersOpt = Some(Map(
-        reg1 -> UnitConstant.instance
-      ))
-    )
+  property("getVarFromInput - invalid var") {
+    def getVarTest(): Assertion = {
+      val customExt = Map(
+        1.toByte -> IntConstant(5)
+      ).toSeq
+      test("R1", env, customExt,
+        "{ sigmaProp(CONTEXT.getVarFromInput[Int](0, 2).isDefined == false) }",
+        null
+      )
+    }
 
-    test("R2", env, ext,
-      script = "", /* means cannot be compiled
-                   the corresponding script is "{ SELF.R4[Unit].get == () }" */
-      EQ(ExtractRegisterAs[SUnit.type](Self, reg1)(SUnit).get, UnitConstant.instance).toSigmaProp,
-      additionalRegistersOpt = Some(Map(
-        reg1 -> UnitConstant.instance
-      ))
-    )
+    if (VersionContext.current.isV6SoftForkActivated) {
+      getVarTest()
+    } else {
+      an[sigma.validation.ValidationException] should be thrownBy getVarTest()
+    }
   }
 
   property("Coll.reverse"){
@@ -1064,7 +1145,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       reverseTest()
     } else {
-      an[Exception] shouldBe thrownBy(reverseTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(reverseTest())
     }
   }
 
@@ -1085,7 +1166,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       reverseTest()
     } else {
-      an[Exception] shouldBe thrownBy(reverseTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(reverseTest())
     }
   }
 
@@ -1109,7 +1190,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       reverseTest()
     } else {
-      an[Exception] shouldBe thrownBy(reverseTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(reverseTest())
     }
   }
 
@@ -1133,7 +1214,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       reverseTest()
     } else {
-      an[Exception] shouldBe thrownBy(reverseTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(reverseTest())
     }
   }
 
@@ -1157,7 +1238,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       reverseTest()
     } else {
-      an[Exception] shouldBe thrownBy(reverseTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(reverseTest())
     }
   }
 
@@ -1181,7 +1262,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       reverseTest()
     } else {
-      an[Exception] shouldBe thrownBy(reverseTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(reverseTest())
     }
   }
 
@@ -1199,7 +1280,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       getTest()
     } else {
-      an[Exception] shouldBe thrownBy(getTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(getTest())
     }
   }
 
@@ -1215,7 +1296,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       fromTest()
     } else {
-      an[Exception] should be thrownBy(fromTest())
+      an[sigma.validation.ValidationException] should be thrownBy(fromTest())
     }
   }
 
@@ -1231,7 +1312,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       fromTest()
     } else {
-      an[Exception] should be thrownBy(fromTest())
+      an[sigma.validation.ValidationException] should be thrownBy(fromTest())
     }
   }
 
@@ -1247,7 +1328,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       fromTest()
     } else {
-      an[Exception] should be thrownBy(fromTest())
+      an[sigma.validation.ValidationException] should be thrownBy(fromTest())
     }
   }
 
@@ -1264,14 +1345,17 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       fromTest()
     } else {
-      an[Exception] should be thrownBy(fromTest())
+      an[sigma.validation.ValidationException] should be thrownBy(fromTest())
     }
   }
 
   property("Global.fromBigEndianBytes - Long.toBytes") {
-    def fromTest() = test("fromBigEndianBytes - long", env, ext,
+    val customExt = Map(
+      1.toByte -> LongConstant(1088800L)
+    ).toSeq
+    def fromTest() = test("fromBigEndianBytes - long", env, customExt,
       s"""{
-         |  val l = 1088800L
+         |  val l = getVar[Long](1).get
          |  val ba = l.toBytes
          |  Global.fromBigEndianBytes[Long](ba) == l
          |}
@@ -1281,7 +1365,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       fromTest()
     } else {
-      an[Exception] should be thrownBy(fromTest())
+      an[sigma.validation.ValidationException] should be thrownBy(fromTest())
     }
   }
 
@@ -1298,14 +1382,17 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       fromTest()
     } else {
-      an[Exception] should be thrownBy(fromTest())
+      an[sigma.validation.ValidationException] should be thrownBy(fromTest())
     }
   }
 
   property("Int.toBytes") {
-    def toBytesTest() = test("Int.toBytes", env, ext,
+    val customExt = Map(
+      1.toByte -> IntConstant(1)
+    ).toSeq
+    def toBytesTest() = test("Int.toBytes", env, customExt,
       """{
-        |   val l = 1
+        |   val l = getVar[Int](1).get
         |   l.toBytes == Coll(0.toByte, 0.toByte, 0.toByte, 1.toByte)
         | }""".stripMargin,
       null
@@ -1314,14 +1401,17 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       toBytesTest()
     } else {
-      an[Exception] shouldBe thrownBy(toBytesTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(toBytesTest())
     }
   }
 
   property("Int.toBits") {
-    def toBytesTest() = test("Int.toBytes", env, ext,
+    val customExt = Map(
+      1.toByte -> IntConstant(1477959696)
+    ).toSeq
+    def toBytesTest() = test("Int.toBytes", env, customExt,
       """{
-        |   val l = 1477959696
+        |   val l = getVar[Int](1).get
         |   l.toBits == Coll(false, true, false, true, true, false, false, false, false, false, false, true, false, true, true ,true, true, true, true, false, false, false, false, false, false, false, false, true, false, false, false, false)
         | }""".stripMargin,
       null
@@ -1330,14 +1420,17 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       toBytesTest()
     } else {
-      an[Exception] shouldBe thrownBy(toBytesTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(toBytesTest())
     }
   }
 
   property("Byte.toBytes") {
-    def toBytesTest() = test("Byte.toBytes", env, ext,
+    val customExt = Map(
+      1.toByte -> ByteConstant(10)
+    ).toSeq
+    def toBytesTest() = test("Byte.toBytes", env, customExt,
       """{
-        |   val l = 10.toByte
+        |   val l = getVar[Byte](1).get
         |   l.toBytes == Coll(10.toByte)
         | }""".stripMargin,
       null
@@ -1346,7 +1439,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       toBytesTest()
     } else {
-      an[Exception] shouldBe thrownBy(toBytesTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(toBytesTest())
     }
   }
 
@@ -1363,7 +1456,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       toBytesTest()
     } else {
-      an[Exception] shouldBe thrownBy(toBytesTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(toBytesTest())
     }
   }
 
@@ -1378,7 +1471,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     )
 
     if (activatedVersionInTests < V6SoftForkVersion) {
-      an [sigma.exceptions.TyperException] should be thrownBy deserTest()
+      an [sigma.validation.ValidationException] should be thrownBy deserTest()
     } else {
       deserTest()
     }
@@ -1395,7 +1488,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     )
 
     if (activatedVersionInTests < V6SoftForkVersion) {
-      an [sigma.exceptions.TyperException] should be thrownBy deserTest()
+      an [sigma.validation.ValidationException] should be thrownBy deserTest()
     } else {
       deserTest()
     }
@@ -1412,7 +1505,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     )
 
     if (activatedVersionInTests < V6SoftForkVersion) {
-      an [sigma.exceptions.TyperException] should be thrownBy deserTest()
+      an [sigma.validation.ValidationException] should be thrownBy deserTest()
     } else {
       deserTest()
     }
@@ -1431,7 +1524,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     )
 
     if (activatedVersionInTests < V6SoftForkVersion) {
-      an [sigma.exceptions.TyperException] should be thrownBy deserTest()
+      an [sigma.validation.ValidationException] should be thrownBy deserTest()
     } else {
       deserTest()
     }
@@ -1452,7 +1545,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     )
 
     if (activatedVersionInTests < V6SoftForkVersion) {
-      an [Exception] should be thrownBy deserTest()
+      an [sigma.validation.ValidationException] should be thrownBy deserTest()
     } else {
       deserTest()
     }
@@ -1473,7 +1566,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     )
 
     if (activatedVersionInTests < V6SoftForkVersion) {
-      an [Exception] should be thrownBy deserTest()
+      an [sigma.validation.ValidationException] should be thrownBy deserTest()
     } else {
       deserTest()
     }
@@ -1497,7 +1590,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     )
 
     if (activatedVersionInTests < V6SoftForkVersion) {
-      an [sigma.exceptions.TyperException] should be thrownBy deserTest()
+      an [sigma.validation.ValidationException] should be thrownBy deserTest()
     } else {
       deserTest()
     }
@@ -1522,7 +1615,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     )
 
     if (activatedVersionInTests < V6SoftForkVersion) {
-      an[Exception] should be thrownBy deserTest()
+      an[sigma.validation.ValidationException] should be thrownBy deserTest()
     } else {
       deserTest()
     }
@@ -1544,13 +1637,50 @@ class BasicOpsSpecification extends CompilerTestingCommons
     )
 
     if (activatedVersionInTests < V6SoftForkVersion) {
-      an[Exception] should be thrownBy deserTest()
+      an[sigma.validation.ValidationException] should be thrownBy deserTest()
     } else {
       // we have wrapped CostLimitException here
       an[Exception] should be thrownBy deserTest()
     }
   }
 
+  property("Lazy evaluation of default in Option.getOrElse") {
+    val customExt = Map (
+      1.toByte -> IntConstant(5)
+    ).toSeq
+    def optTest() = test("getOrElse", env, customExt,
+      """{
+        |  getVar[Int](1).getOrElse(getVar[Int](44).get) > 0
+        |}
+        |""".stripMargin,
+      null
+    )
+
+    if (VersionContext.current.isV6SoftForkActivated) {
+      optTest()
+    } else {
+      assertExceptionThrown(optTest(), _.isInstanceOf[NoSuchElementException])
+    }
+  }
+
+  property("Lazy evaluation of default in Coll.getOrElse") {
+    def optTest() = test("getOrElse", env, ext,
+      """{
+        |  val c = Coll[Int](1)
+        |  c.getOrElse(0, getVar[Int](44).get) > 0 &&
+        |   c.getOrElse(1, c.getOrElse(0, getVar[Int](44).get)) > 0
+        |}
+        |""".stripMargin,
+      null
+    )
+
+    if(VersionContext.current.isV6SoftForkActivated) {
+      optTest()
+    } else {
+      assertExceptionThrown(optTest(), _.isInstanceOf[NoSuchElementException])
+    }
+  }
+
   property("Relation operations") {
     test("R1", env, ext,
       "{ allOf(Coll(getVar[Boolean](trueVar).get, true, true)) }",
@@ -1870,7 +2000,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if(VersionContext.current.isV6SoftForkActivated) {
       holTest()
     } else {
-      an[Exception] shouldBe thrownBy(holTest())
+      an[sigma.validation.ValidationException] shouldBe thrownBy(holTest())
     }
   }
 
@@ -2184,11 +2314,15 @@ class BasicOpsSpecification extends CompilerTestingCommons
   }
 
   property("Box.getReg") {
+    val customExt = Map(
+      1.toByte -> IntConstant(0)
+    ).toSeq
     def getRegTest(): Assertion = {
-      test("Box.getReg", env, ext,
+      test("Box.getReg", env, customExt,
         """{
+          |   val idx = getVar[Int](1).get
           |   val x = SELF
-          |   x.getReg[Long](0).get == SELF.value &&
+          |   x.getReg[Long](idx).get == SELF.value &&
           |   x.getReg[Coll[(Coll[Byte], Long)]](2).get == SELF.tokens &&
           |   x.getReg[Int](9).isEmpty
           |}""".stripMargin,
@@ -2199,7 +2333,7 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       getRegTest()
     } else {
-      an[Exception] should be thrownBy getRegTest()
+      an[sigma.exceptions.ConstraintFailed] should be thrownBy getRegTest()
     }
   }
 
@@ -2220,8 +2354,30 @@ class BasicOpsSpecification extends CompilerTestingCommons
     if (VersionContext.current.isV6SoftForkActivated) {
       getRegTest()
     } else {
-      an[Exception] should be thrownBy getRegTest()
+      an[java.nio.BufferUnderflowException] should be thrownBy getRegTest()
     }
   }
 
+  property("Unit register") {
+    // TODO frontend: implement missing Unit support in compiler
+    //  https://github.com/ScorexFoundation/sigmastate-interpreter/issues/820
+    test("R1", env, ext,
+      script = "", /* means cannot be compiled
+                     the corresponding script is { SELF.R4[Unit].isDefined } */
+      ExtractRegisterAs[SUnit.type](Self, reg1)(SUnit).isDefined.toSigmaProp,
+      additionalRegistersOpt = Some(Map(
+        reg1 -> UnitConstant.instance
+      ))
+    )
+
+    test("R2", env, ext,
+      script = "", /* means cannot be compiled
+                   the corresponding script is "{ SELF.R4[Unit].get == () }" */
+      EQ(ExtractRegisterAs[SUnit.type](Self, reg1)(SUnit).get, UnitConstant.instance).toSigmaProp,
+      additionalRegistersOpt = Some(Map(
+        reg1 -> UnitConstant.instance
+      ))
+    )
+  }
+
 }
diff --git a/sc/shared/src/test/scala/sigmastate/utxo/examples/AssetsPartialFilling.scala b/sc/shared/src/test/scala/sigmastate/utxo/examples/AssetsPartialFilling.scala
index 969439fe59..5e89915384 100644
--- a/sc/shared/src/test/scala/sigmastate/utxo/examples/AssetsPartialFilling.scala
+++ b/sc/shared/src/test/scala/sigmastate/utxo/examples/AssetsPartialFilling.scala
@@ -68,11 +68,9 @@ case class AssetsPartialFilling[Spec <: ContractSpec]
       val out = OUTPUTS(outIdx)
 
       val tokenData = out.R2[Coll[(Coll[Byte], Long)]].get(0)
-      val tokenId = tokenData._1
       val tokenValue = tokenData._2
 
       val selfTokenData = SELF.R2[Coll[(Coll[Byte], Long)]].get(0)
-      val selfTokenId = selfTokenData._1
       val selfTokenValue = selfTokenData._2
 
       val selfValue = SELF.value