diff --git a/build.sbt b/build.sbt
index c17fd3c00bc..941ad38d997 100644
--- a/build.sbt
+++ b/build.sbt
@@ -6,7 +6,7 @@
    2. You've checked "Make project before run"
  */
 
-import sbt.Def
+import sbt.{Compile, Def}
 import sbt.Keys.{concurrentRestrictions, _}
 
 Global / onChangedBuildSource := ReloadOnSourceChanges
@@ -20,6 +20,7 @@ lazy val lang =
       libraryDependencies ++= Dependencies.lang.value ++ Dependencies.test,
       inConfig(Compile)(
         Seq(
+          sourceGenerators += Tasks.docSource,
           PB.targets += scalapb.gen(flatPackage = true) -> sourceManaged.value,
           PB.protoSources += PB.externalIncludePath.value,
           PB.generate / includeFilter := { (f: File) =>
@@ -40,9 +41,6 @@ lazy val `lang-jvm` = lang.jvm
 
 lazy val `lang-js` = lang.js
   .enablePlugins(VersionObject)
-  .settings(
-    Compile / sourceGenerators += Tasks.docSource
-  )
 
 lazy val `lang-testkit` = project
   .dependsOn(`lang-jvm`)
@@ -54,17 +52,6 @@ lazy val `lang-testkit` = project
 lazy val `lang-tests` = project
   .in(file("lang/tests"))
   .dependsOn(`lang-testkit`)
-  .settings(
-    Compile / sourceGenerators += Tasks.docSource
-  )
-
-lazy val `lang-doc` = project
-  .in(file("lang/doc"))
-  .dependsOn(`lang-jvm`)
-  .settings(
-    Compile / sourceGenerators += Tasks.docSource,
-    libraryDependencies ++= Seq("com.github.spullara.mustache.java" % "compiler" % "0.9.10") ++ Dependencies.test
-  )
 
 lazy val node = project.dependsOn(`lang-jvm`, `lang-testkit` % "test")
 
diff --git a/lang/doc/src/main/scala/com/wavesplatform/utils/DocExport.scala b/lang/doc/src/main/scala/com/wavesplatform/utils/DocExport.scala
deleted file mode 100644
index 011050cfd0b..00000000000
--- a/lang/doc/src/main/scala/com/wavesplatform/utils/DocExport.scala
+++ /dev/null
@@ -1,186 +0,0 @@
-package com.wavesplatform.utils
-
-import com.github.mustachejava._
-import com.wavesplatform.DocSource
-import com.wavesplatform.common.utils.EitherExt2
-import com.wavesplatform.lang.directives.values._
-import com.wavesplatform.lang.directives.{DirectiveDictionary, DirectiveSet}
-import com.wavesplatform.lang.v1.CTX
-import com.wavesplatform.lang.v1.compiler.Types._
-import com.wavesplatform.lang.v1.traits.Environment
-import com.wavesplatform.utils.doc.RideFullContext
-
-import scala.jdk.CollectionConverters._
-
-object DocExport {
-  def main(args: Array[String]): Unit = {
-    if (args.size != 4 || args(0) != "--gen-doc") {
-      System.err.println("Expected args: --gen-doc <version> <template> <output>")
-    } else {
-      val versionStr  = args(1)
-      val docTemplate = args(2)
-      val outputFile  = args(3)
-
-      val version = DirectiveDictionary[StdLibVersion].idMap(versionStr.toInt)
-      val ds = DirectiveSet(version, Account, Expression).explicitGet()
-
-      abstract class TypeDoc {
-        val name: String
-        val isUnion: Boolean   = false
-        val isObj: Boolean     = false
-        val isNative: Boolean  = false
-        val haveParam: Boolean = false
-        val isComplex: Boolean = false
-        val needLink: Boolean  = false
-        def noLink: Boolean    = !needLink
-      }
-      case class Field(name: String, `type`: TypeDoc)
-      case class UnionDoc(override val name: String, union: java.util.List[TypeDoc]) extends TypeDoc { override val isUnion: Boolean = true }
-      case class objDoc(override val name: String, fields: java.util.List[Field]) extends TypeDoc {
-        override val isObj: Boolean = true; override val needLink: Boolean = true
-      }
-      case class ListOf(param: TypeDoc)   extends TypeDoc { override val name: String = "LIST"; val hasParam: Boolean   = true }
-      case class OptionOf(param: TypeDoc) extends TypeDoc { override val name: String = "OPTION"; val hasParam: Boolean = true }
-      case class nativeTypeDoc(override val name: String) extends TypeDoc {
-        override val isNative: Boolean = true; override val needLink: Boolean = true
-      }
-
-      def typeRepr(t: FINAL)(name: String = t.name): TypeDoc = t match {
-        case UNION(Seq(UNIT, l), _) => OptionOf(typeRepr(l)(l.name))
-        case UNION(Seq(l, UNIT), _) => OptionOf(typeRepr(l)(l.name))
-        case UNION(l, _)            => UnionDoc(name, l.map(t => typeRepr(t)(t.name)).asJava)
-        case CASETYPEREF(_, fields, _) =>
-          objDoc(name, fields.map(f => Field(f._1, typeRepr(f._2)(f._2.name))).asJava)
-        case LIST(t) => ListOf(typeRepr(t)(t.name))
-        case t       => nativeTypeDoc(t.toString)
-      }
-
-      val fullContext: CTX[Environment] = RideFullContext.build(ds)
-
-      def getTypes() = fullContext.types.map(v => typeRepr(v)(v.name))
-
-      case class VarDoc(name: String, `type`: TypeDoc, doc: String)
-      def getVarsDoc() = fullContext.vars.map(v => VarDoc(
-        v._1,
-        typeRepr(v._2._1)(),
-        DocSource.varData((v._1, version.value.asInstanceOf[Int]))
-      ))
-
-      case class FuncDoc(name: String, `type`: TypeDoc, doc: String, params: java.util.List[VarDoc], cost: String)
-
-      def extType(t: TYPE): TypeDoc = t match {
-        case t: FINAL                         => typeRepr(t)()
-        case TYPEPARAM(char: Byte)            => new TypeDoc { val name: String = char.toChar.toString; override val isComplex: Boolean = true }
-        case PARAMETERIZEDLIST(l)             => ListOf(extType(l))
-        case PARAMETERIZEDUNION(Seq(UNIT, l)) => OptionOf(extType(l))
-        case PARAMETERIZEDUNION(Seq(l, UNIT)) => OptionOf(extType(l))
-        case PARAMETERIZEDUNION(l)            => UnionDoc("", l.map(t => extType(t)).asJava)
-        case t                                => new TypeDoc { val name: String = t.toString; override val isComplex: Boolean = true }
-      }
-
-      def getFunctionsDoc() =
-        fullContext.functions
-          .map(
-            f => {
-              val (funcDoc, paramsDoc, _) = DocSource.funcData((
-                f.name,
-                f.signature.args.map(_._2.toString).toList,
-                version.value.asInstanceOf[Int]
-              ))
-              FuncDoc(
-                f.name,
-                extType(f.signature.result),
-                funcDoc,
-                (f.args.lazyZip(f.signature.args).lazyZip(paramsDoc).toList
-                  map { arg => VarDoc(arg._1, extType(arg._2._2), arg._3)}
-                ).asJava,
-                f.costByLibVersion(version).toString
-              )
-            })
-
-      case class TransactionDoc(name: String, fields: java.util.List[TransactionField])
-      case class TransactionField(absend: Boolean, `type`: java.util.List[TypeDoc])
-      case class FieldTypes(name: String, types: java.util.List[TransactionField])
-      val transactionsType       = fullContext.types.filter(v => v.name == "Transaction")
-      val transactionsTypesNames = transactionsType.collect({ case UNION(union, _) => union.map(_.name) }).flatten.toSet
-      def transactionDocs(types: Seq[FINAL], fieldsFlt: String => Boolean = (_ => true)) = {
-        val transactionsTypes =
-          types.flatMap({
-            case UNION(union, _) => union
-            case t: CASETYPEREF  => Seq(t)
-            case t               => println(t.toString); Seq()
-          })
-        val transactionsFields =
-          transactionsTypes
-            .flatMap(_.fields.map(_._1))
-            .filter(fieldsFlt)
-            .distinct
-            .map(name =>
-              FieldTypes(
-                name,
-                transactionsTypes
-                  .map(t =>
-                    t.fields
-                      .find(_._1 == name)
-                      .fold(TransactionField(true, List[TypeDoc]().asJava))(ft => TransactionField(false, List(typeRepr(ft._2)()).asJava)))
-                  .asJava
-            ))
-        val transactionDocs = transactionsTypes.map { t =>
-          val fields = t.fields.toMap
-          TransactionDoc(
-            t.name,
-            transactionsFields
-              .map(
-                field =>
-                  fields
-                    .get(field.name)
-                    .fold(TransactionField(true, List[TypeDoc]().asJava))(ft => TransactionField(false, List(typeRepr(ft)()).asJava)))
-              .asJava
-          )
-        }
-        (transactionDocs, transactionsFields)
-      }
-
-      val commonFields              = Set("id", "fee", "version", "timestamp", "sender", "senderPublicKey", "bodyBytes", "proofs")
-      def otherFields(name: String) = !commonFields(name)
-
-      case class CaseDoc(types: java.util.List[TransactionDoc], fields: java.util.List[FieldTypes])
-      def caseDoc(d: (Seq[TransactionDoc], Seq[FieldTypes])) = CaseDoc(d._1.asJava, d._2.asJava)
-      case class Special(`class`: String, descr: CaseDoc)
-      case class Doc(types: java.util.List[TypeDoc],
-                     vars: java.util.List[VarDoc],
-                     funcs: java.util.List[FuncDoc],
-                     transactionDoc: java.util.List[TransactionDoc],
-                     transactionFields: java.util.List[FieldTypes],
-                     commonFields: CaseDoc,
-                     specials: java.util.List[Special])
-
-      val mf      = new DefaultMustacheFactory()
-      val doc     = mf.compile(docTemplate)
-      val output  = new java.io.FileWriter(outputFile) //new java.io.StringWriter
-      val (t, f)  = transactionDocs(transactionsType)
-      val commons = transactionDocs(transactionsType, commonFields)
-      val transactionClasses = Seq(
-        "Transfers"      -> Set("TransferTransaction", "MassTransferTransaction", "PaymentTransaction"),
-        "Issuing assets" -> Set("IssueTransaction", "ReissueTransaction", "BurnTransaction", "SponsorFeeTransaction", "SetAssetScriptTransaction"),
-        "Leasing"        -> Set("LeaseTransaction", "LeaseCancelTransaction")
-      )
-      def otherTransactions(name: String) = transactionsTypesNames(name) && !transactionClasses.map(_._2).exists(_(name))
-      val out = doc.execute(
-        output,
-        Doc(
-          getTypes().asJava,
-          getVarsDoc().toList.asJava,
-          getFunctionsDoc().toList.asJava,
-          t.asJava,
-          f.asJava,
-          CaseDoc(commons._1.asJava, commons._2.asJava),
-          (transactionClasses.map(c => Special(c._1, caseDoc(transactionDocs(fullContext.types.filter(v => c._2(v.name)), otherFields))))
-            :+ Special("Other", caseDoc(transactionDocs(fullContext.types.filter(v => otherTransactions(v.name)), otherFields)))).asJava
-        )
-      )
-      out.flush()
-      out.close()
-    }
-  }
-}
diff --git a/lang/doc/src/main/scala/com/wavesplatform/utils/doc/DocExport.scala b/lang/doc/src/main/scala/com/wavesplatform/utils/doc/DocExport.scala
deleted file mode 100644
index 0f4e961130c..00000000000
--- a/lang/doc/src/main/scala/com/wavesplatform/utils/doc/DocExport.scala
+++ /dev/null
@@ -1,124 +0,0 @@
-package com.wavesplatform.utils.doc
-
-import com.wavesplatform.common.utils.EitherExt2
-import com.github.mustachejava.DefaultMustacheFactory
-import com.wavesplatform.DocSource
-import com.wavesplatform.lang.directives.{DirectiveDictionary, DirectiveSet}
-import com.wavesplatform.lang.directives.values.{Account, Expression, StdLibVersion}
-import com.wavesplatform.lang.v1.compiler.Types.{CASETYPEREF, FINAL, UNION}
-
-import scala.jdk.CollectionConverters._
-
-object DocExport {
-  def main(args: Array[String]): Unit = {
-    if (args.length != 4 || args(0) != "--gen-doc") {
-      System.err.println("Expected args: --gen-doc <version> <template> <output>")
-    } else {
-      val versionStr  = args(1)
-      val docTemplate = args(2)
-      val outputFile  = args(3)
-
-      val version = DirectiveDictionary[StdLibVersion].idMap(versionStr.toInt)
-      val fullContext = RideFullContext.build(DirectiveSet(version, Account, Expression).explicitGet())
-
-      def getTypes() = fullContext.types.map(v => TypeDoc.typeRepr(v)(v.name))
-
-      def getVarsDoc() = fullContext.vars.map(v => VarDoc(
-        v._1,
-        TypeDoc.typeRepr(v._2._1)(),
-        DocSource.varData((v._1, version.value.asInstanceOf[Int]))
-      ))
-
-      def getFunctionsDoc() =
-        fullContext.functions
-          .map(
-            f => {
-              val (funcDoc, paramsDoc, _) = DocSource.funcData((
-                f.name,
-                f.signature.args.map(_._2.toString).toList,
-                version.value.asInstanceOf[Int]
-              ))
-              FuncDoc(
-                f.name,
-                TypeDoc(f.signature.result),
-                funcDoc,
-                ((f.args, f.signature.args, paramsDoc).zipped.toList
-                  map { arg => VarDoc(arg._1, TypeDoc(arg._2._2), arg._3)}
-                ).asJava,
-                f.costByLibVersion(version).toString
-              )
-            })
-
-      val transactionsType       = fullContext.types.filter(v => v.name == "Transaction")
-      val transactionsTypesNames = transactionsType.collect({ case UNION(union, _) => union.map(_.name) }).flatten.toSet
-      def transactionDocs(types: Seq[FINAL], fieldsFlt: String => Boolean = (_ => true)) = {
-        val transactionsTypes =
-          types.flatMap({
-            case UNION(union, _) => union
-            case t: CASETYPEREF  => Seq(t)
-            case t               => println(t.toString); Seq()
-          })
-        val transactionsFields =
-          transactionsTypes
-            .flatMap(_.fields.map(_._1))
-            .filter(fieldsFlt)
-            .distinct
-            .map(name =>
-              FieldTypes(
-                name,
-                transactionsTypes
-                  .map(t =>
-                    t.fields
-                      .find(_._1 == name)
-                      .fold(TransactionField(true, List[TypeDoc]().asJava))(ft => TransactionField(false, List(TypeDoc.typeRepr(ft._2)()).asJava)))
-                  .asJava
-            ))
-        val transactionDocs = transactionsTypes.map { t =>
-          val fields = t.fields.toMap
-          TransactionDoc(
-            t.name,
-            transactionsFields
-              .map(
-                field =>
-                  fields
-                    .get(field.name)
-                    .fold(TransactionField(true, List[TypeDoc]().asJava))(ft => TransactionField(false, List(TypeDoc.typeRepr(ft)()).asJava)))
-              .asJava
-          )
-        }
-        (transactionDocs, transactionsFields)
-      }
-
-      val commonFields              = Set("id", "fee", "version", "timestamp", "sender", "senderPublicKey", "bodyBytes", "proofs")
-      def otherFields(name: String) = !commonFields(name)
-
-      val mf      = new DefaultMustacheFactory()
-      val doc     = mf.compile(docTemplate)
-      val output  = new java.io.FileWriter(outputFile) //new java.io.StringWriter
-      val (t, f)  = transactionDocs(transactionsType)
-      val commons = transactionDocs(transactionsType, commonFields)
-      val transactionClasses = Seq(
-        "Transfers"      -> Set("TransferTransaction", "MassTransferTransaction", "PaymentTransaction"),
-        "Issuing assets" -> Set("IssueTransaction", "ReissueTransaction", "BurnTransaction", "SponsorFeeTransaction", "SetAssetScriptTransaction"),
-        "Leasing"        -> Set("LeaseTransaction", "LeaseCancelTransaction")
-      )
-      def otherTransactions(name: String) = transactionsTypesNames(name) && !transactionClasses.map(_._2).exists(_(name))
-      val out = doc.execute(
-        output,
-        Doc(
-          getTypes().asJava,
-          getVarsDoc().toList.asJava,
-          getFunctionsDoc().toList.asJava,
-          t.asJava,
-          f.asJava,
-          CaseDoc(commons._1.asJava, commons._2.asJava),
-          (transactionClasses.map(c => Special(c._1, Doc(transactionDocs(fullContext.types.filter(v => c._2(v.name)), otherFields))))
-            :+ Special("Other", Doc(transactionDocs(fullContext.types.filter(v => otherTransactions(v.name)), otherFields)))).asJava
-        )
-      )
-
-      out.flush()
-      out.close()
-    }
-  }
-}
diff --git a/lang/doc/src/main/scala/com/wavesplatform/utils/doc/DocExportV3.scala b/lang/doc/src/main/scala/com/wavesplatform/utils/doc/DocExportV3.scala
deleted file mode 100644
index c9c5a424728..00000000000
--- a/lang/doc/src/main/scala/com/wavesplatform/utils/doc/DocExportV3.scala
+++ /dev/null
@@ -1,57 +0,0 @@
-package com.wavesplatform.utils.doc
-
-import java.io.FileWriter
-import java.nio.file.{Files, Paths}
-
-import com.github.mustachejava.DefaultMustacheFactory
-import com.wavesplatform.DocSource
-import com.wavesplatform.common.utils.EitherExt2
-import com.wavesplatform.lang.directives.DirectiveSet
-import com.wavesplatform.lang.directives.values.{Account, Expression, V3}
-
-import scala.jdk.CollectionConverters._
-
-object DocExportV3 {
-  def main(args: Array[String]): Unit = {
-      val funcV3Template = if (args.length == 1) args(0) else "lang/func-doc.template.md"
-      val path = Paths.get("target/funcs")
-      Files.createDirectories(path)
-
-      val ds = DirectiveSet(V3, Account, Expression).explicitGet()
-      RideFullContext.build(ds)
-        .functions
-        .map(
-          f => {
-            val argTypes = f.signature.args.map(_._2.toString).toList
-            val docKey = (f.name, argTypes, V3.value.asInstanceOf[Int])
-            val (doc, paramsDoc, category, _) = DocSource.categorizedfuncDataV3(docKey)
-            val varDocs =
-              (f.args, f.signature.args, paramsDoc)
-                .zipped
-                .toList
-                .map { arg => VarDoc(arg._1, TypeDoc(arg._2._2), arg._3.replace("\n", "<br>")) }
-                .asJava
-
-            val cost = f.costByLibVersion(V3).toString
-            val funcDoc = FuncDoc(f.name, TypeDoc(f.signature.result), doc.replace("\n", "<br>"), varDocs, cost)
-            (funcDoc, category)
-          }
-        )
-        .groupBy(_._2)
-        .map { case (category, funcs) =>
-          val indexedDocs = funcs
-            .zipWithIndex
-            .map { case ((func, _), index) => FuncDocV3(func, index + 1) }
-            .toList
-            .asJava
-          val title = category.replace("-", " ").capitalize
-          val writer = new FileWriter(path.resolve(category + ".md").toFile)
-          val docs = CategorizedFuncsDoc(indexedDocs, title)
-          (writer, docs)
-        }
-        .foreach { case (writer, docs) =>
-          new DefaultMustacheFactory().compile(funcV3Template).execute(writer, docs)
-          writer.close()
-        }
-    }
-}
diff --git a/lang/doc/src/main/scala/com/wavesplatform/utils/doc/MustacheDoc.scala b/lang/doc/src/main/scala/com/wavesplatform/utils/doc/MustacheDoc.scala
deleted file mode 100644
index 26432a435b0..00000000000
--- a/lang/doc/src/main/scala/com/wavesplatform/utils/doc/MustacheDoc.scala
+++ /dev/null
@@ -1,90 +0,0 @@
-package com.wavesplatform.utils.doc
-
-import com.wavesplatform.lang.v1.compiler.Types._
-
-import scala.jdk.CollectionConverters._
-
-abstract class TypeDoc {
-  val name: String
-  val isUnion: Boolean   = false
-  val isObj: Boolean     = false
-  val isNative: Boolean  = false
-  val haveParam: Boolean = false
-  val isComplex: Boolean = false
-  val needLink: Boolean  = false
-  def noLink: Boolean    = !needLink
-
-  val verticalLineSymbol  = "&#124;"
-  lazy val mdName: String = name.replace("|", verticalLineSymbol)
-}
-object TypeDoc {
-  def apply(t: TYPE): TypeDoc = t match {
-    case t: FINAL                         => typeRepr(t)()
-    case TYPEPARAM(char: Byte)            => new TypeDoc { val name: String = char.toChar.toString; override val isComplex: Boolean = true }
-    case PARAMETERIZEDLIST(l)             => ListOf(apply(l))
-    case PARAMETERIZEDUNION(Seq(UNIT, l)) => OptionOf(apply(l))
-    case PARAMETERIZEDUNION(Seq(l, UNIT)) => OptionOf(apply(l))
-    case PARAMETERIZEDUNION(l)            => UnionDoc(t.toString, l.map(apply).asJava)
-    case t                                => new TypeDoc { val name: String = t.toString; override val isComplex: Boolean = true }
-  }
-
-  def typeRepr(t: FINAL)(name: String = t.name): TypeDoc = t match {
-    case UNION(Seq(UNIT, l), _) => OptionOf(typeRepr(l)())
-    case UNION(Seq(l, UNIT), _) => OptionOf(typeRepr(l)())
-    case UNION(l, _)            => UnionDoc(name, l.map(t => typeRepr(t)()).asJava)
-    case CASETYPEREF(_, fields, _) =>
-      objDoc(name, fields.map(f => Field(f._1, typeRepr(f._2)())).asJava)
-    case LIST(t) => ListOf(typeRepr(t)())
-    case t       => nativeTypeDoc(t.toString)
-  }
-}
-
-case class Field(name: String, `type`: TypeDoc)
-case class UnionDoc(override val name: String, union: java.util.List[TypeDoc]) extends TypeDoc {
-  override val isUnion: Boolean = true
-}
-case class objDoc(override val name: String, fields: java.util.List[Field]) extends TypeDoc {
-  override val isObj: Boolean    = true
-  override val needLink: Boolean = true
-}
-case class ListOf(param: TypeDoc)   extends TypeDoc { override val name: String = s"List[${param.name}]"; val hasParam: Boolean = true }
-case class OptionOf(param: TypeDoc) extends TypeDoc { override val name: String = s"${param.name}|Unit"; val hasParam: Boolean  = true }
-case class nativeTypeDoc(override val name: String) extends TypeDoc {
-  override val isNative: Boolean = true
-  override val needLink: Boolean = true
-}
-
-case class VarDoc(private val nameRaw: String, `type`: TypeDoc, doc: String) {
-  val name = nameRaw.replace("@", "")
-}
-case class FuncDoc(name: String, `type`: TypeDoc, doc: String, params: java.util.List[VarDoc], cost: String)
-
-case class TransactionDoc(name: String, fields: java.util.List[TransactionField])
-case class TransactionField(absend: Boolean, `type`: java.util.List[TypeDoc])
-case class FieldTypes(name: String, types: java.util.List[TransactionField])
-case class CaseDoc(types: java.util.List[TransactionDoc], fields: java.util.List[FieldTypes])
-case class Special(`class`: String, descr: CaseDoc)
-case class Doc(
-    types: java.util.List[TypeDoc],
-    vars: java.util.List[VarDoc],
-    funcs: java.util.List[FuncDoc],
-    transactionDoc: java.util.List[TransactionDoc],
-    transactionFields: java.util.List[FieldTypes],
-    commonFields: CaseDoc,
-    specials: java.util.List[Special]
-)
-object Doc {
-  def apply(d: (Seq[TransactionDoc], Seq[FieldTypes])) = CaseDoc(d._1.asJava, d._2.asJava)
-}
-
-case class FuncDocV3(funcDoc: FuncDoc, index: Int) {
-  val name          = funcDoc.name
-  val `type`        = funcDoc.`type`
-  val doc           = funcDoc.doc
-  val params        = funcDoc.params
-  val cost          = funcDoc.cost
-  val paramTypes    = params.asScala.map(p => p.`type`.mdName).mkString(", ")
-  val paramArgTypes = params.asScala.map(p => s"${p.name}: ${p.`type`.name}").mkString(", ")
-  val anchor        = name + params.asScala.map(_.`type`.mdName).mkString
-}
-case class CategorizedFuncsDoc(funcs: java.util.List[FuncDocV3], category: String)
diff --git a/lang/doc/src/main/scala/com/wavesplatform/utils/doc/RideFullContext.scala b/lang/doc/src/main/scala/com/wavesplatform/utils/doc/RideFullContext.scala
deleted file mode 100644
index 19564796fa2..00000000000
--- a/lang/doc/src/main/scala/com/wavesplatform/utils/doc/RideFullContext.scala
+++ /dev/null
@@ -1,18 +0,0 @@
-package com.wavesplatform.utils.doc
-
-import cats.implicits._
-import com.wavesplatform.lang.Global
-import com.wavesplatform.lang.directives.DirectiveSet
-import com.wavesplatform.lang.v1.CTX
-import com.wavesplatform.lang.v1.evaluator.ctx.impl.waves.WavesContext
-import com.wavesplatform.lang.v1.evaluator.ctx.impl.{CryptoContext, PureContext}
-import com.wavesplatform.lang.v1.traits.Environment
-
-object RideFullContext {
-  def build(ds: DirectiveSet): CTX[Environment] = {
-    val wavesCtx  = WavesContext.build(Global,ds)
-    val cryptoCtx = CryptoContext.build(Global, ds.stdLibVersion).withEnvironment[Environment]
-    val pureCtx = PureContext.build().withEnvironment[Environment]
-    pureCtx |+| cryptoCtx |+| wavesCtx
-  }
-}
diff --git a/lang/shared/src/main/scala/com/wavesplatform/lang/v1/parser/Parser.scala b/lang/shared/src/main/scala/com/wavesplatform/lang/v1/parser/Parser.scala
index 919c3edaf1b..a65d81332d8 100644
--- a/lang/shared/src/main/scala/com/wavesplatform/lang/v1/parser/Parser.scala
+++ b/lang/shared/src/main/scala/com/wavesplatform/lang/v1/parser/Parser.scala
@@ -37,58 +37,57 @@ object Parser {
   def escapedUnicodeSymbolP[A: P]: P[(Int, String, Int)] = P(Index ~~ (NoCut(unicodeSymbolP) | specialSymbols).! ~~ Index)
   def stringP[A: P]: P[EXPR] =
     P(Index ~~ "\"" ~/ Pass ~~ (escapedUnicodeSymbolP | notEndOfString).!.repX ~~ "\"" ~~ Index)
-      .map {
-        case (start, xs, end) =>
-          var errors         = Vector.empty[String]
-          val consumedString = new StringBuilder
-
-          xs.foreach { x =>
-            if (x.startsWith("\\u")) {
-              if (x.length == 6) {
-                val hexCode = x.drop(2)
-                try {
-                  val int           = Integer.parseInt(hexCode, 16)
-                  val unicodeSymbol = new String(Character.toChars(int))
-                  consumedString.append(unicodeSymbol)
-                } catch {
-                  case _: NumberFormatException =>
-                    consumedString.append(x)
-                    errors :+= s"can't parse '$hexCode' as HEX string in '$x'"
-                  case _: IllegalArgumentException =>
-                    consumedString.append(x)
-                    errors :+= s"invalid UTF-8 symbol: '$x'"
-                }
-              } else {
-                consumedString.append(x)
-                errors :+= s"incomplete UTF-8 symbol definition: '$x'"
-              }
-            } else if (x.startsWith("\\")) {
-              if (x.length == 2) {
-                consumedString.append(x(1) match {
-                  case 'b'  => "\b"
-                  case 'f'  => "\f"
-                  case 'n'  => "\n"
-                  case 'r'  => "\r"
-                  case 't'  => "\t"
-                  case '\\' => "\\"
-                  case '"'  => "\""
-                  case _ =>
-                    errors :+= s"""unknown escaped symbol: '$x'. The valid are \b, \f, \n, \r, \t"""
-                    x
-                })
-              } else {
-                consumedString.append(x)
-                errors :+= s"""invalid escaped symbol: '$x'. The valid are \b, \f, \n, \r, \t"""
+      .map { case (start, xs, end) =>
+        var errors         = Vector.empty[String]
+        val consumedString = new StringBuilder
+
+        xs.foreach { x =>
+          if (x.startsWith("\\u")) {
+            if (x.length == 6) {
+              val hexCode = x.drop(2)
+              try {
+                val int           = Integer.parseInt(hexCode, 16)
+                val unicodeSymbol = new String(Character.toChars(int))
+                consumedString.append(unicodeSymbol)
+              } catch {
+                case _: NumberFormatException =>
+                  consumedString.append(x)
+                  errors :+= s"can't parse '$hexCode' as HEX string in '$x'"
+                case _: IllegalArgumentException =>
+                  consumedString.append(x)
+                  errors :+= s"invalid UTF-8 symbol: '$x'"
               }
             } else {
               consumedString.append(x)
+              errors :+= s"incomplete UTF-8 symbol definition: '$x'"
+            }
+          } else if (x.startsWith("\\")) {
+            if (x.length == 2) {
+              consumedString.append(x(1) match {
+                case 'b'  => "\b"
+                case 'f'  => "\f"
+                case 'n'  => "\n"
+                case 'r'  => "\r"
+                case 't'  => "\t"
+                case '\\' => "\\"
+                case '"'  => "\""
+                case _ =>
+                  errors :+= s"""unknown escaped symbol: '$x'. The valid are \b, \f, \n, \r, \t"""
+                  x
+              })
+            } else {
+              consumedString.append(x)
+              errors :+= s"""invalid escaped symbol: '$x'. The valid are \b, \f, \n, \r, \t"""
             }
+          } else {
+            consumedString.append(x)
           }
+        }
 
-          val r =
-            if (errors.isEmpty) PART.VALID(Pos(start + 1, end - 1), consumedString.toString)
-            else PART.INVALID(Pos(start + 1, end - 1), errors.mkString(";"))
-          (Pos(start, end), r)
+        val r =
+          if (errors.isEmpty) PART.VALID(Pos(start + 1, end - 1), consumedString.toString)
+          else PART.INVALID(Pos(start + 1, end - 1), errors.mkString(";"))
+        (Pos(start, end), r)
       }
       .map(posAndVal => CONST_STRING(posAndVal._1, posAndVal._2))
 
@@ -106,10 +105,9 @@ object Parser {
 
   def genericVarName(namePx: fastparse.P[Any] => P[Unit])(implicit c: fastparse.P[Any]): P[PART[String]] = {
     def nameP(implicit c: fastparse.P[Any]) = namePx(c)
-    (Index ~~ nameP.! ~~ Index).map {
-      case (start, x, end) =>
-        if (keywords.contains(x)) PART.INVALID(Pos(start, end), s"keywords are restricted: $x")
-        else PART.VALID(Pos(start, end), x)
+    (Index ~~ nameP.! ~~ Index).map { case (start, x, end) =>
+      if (keywords.contains(x)) PART.INVALID(Pos(start, end), s"keywords are restricted: $x")
+      else PART.VALID(Pos(start, end), x)
     }
   }
 
@@ -121,8 +119,8 @@ object Parser {
   def invalid[A: P]: P[INVALID] = {
     import fastparse.NoWhitespace.*
     P(Index ~~ CharPred(_ != '\n').rep(1) ~~ Index)
-      .map {
-        case (start, end) => INVALID(Pos(start, end), "can't parse the expression")
+      .map { case (start, end) =>
+        INVALID(Pos(start, end), "can't parse the expression")
       }
   }
 
@@ -145,30 +143,26 @@ object Parser {
   }
 
   def ifP[A: P]: P[IF] = {
-    def optionalPart(keyword: String, branch: String): P[EXPR] = (Index ~ (keyword ~/ Index ~ baseExpr.?).?).map {
-      case (ifTruePos, ifTrueRaw) =>
-        ifTrueRaw
-          .map { case (pos, expr) => expr.getOrElse(INVALID(Pos(pos, pos), s"expected a $branch branch's expression")) }
-          .getOrElse(INVALID(Pos(ifTruePos, ifTruePos), s"expected a $branch branch"))
+    def optionalPart(keyword: String, branch: String): P[EXPR] = (Index ~ (keyword ~/ Index ~ baseExpr.?).?).map { case (ifTruePos, ifTrueRaw) =>
+      ifTrueRaw
+        .map { case (pos, expr) => expr.getOrElse(INVALID(Pos(pos, pos), s"expected a $branch branch's expression")) }
+        .getOrElse(INVALID(Pos(ifTruePos, ifTruePos), s"expected a $branch branch"))
     }
 
     def thenPart[AA: P] = optionalPart("then", "true")
     def elsePart[AA: P] = optionalPart("else", "false")
 
-    P(Index ~~ "if" ~~ &(border) ~/ Index ~ baseExpr.? ~ thenPart ~ elsePart ~~ Index).map {
-      case (start, condPos, condRaw, ifTrue, ifFalse, end) =>
-        val cond = condRaw.getOrElse(INVALID(Pos(condPos, condPos), "expected a condition"))
-        IF(Pos(start, end), cond, ifTrue, ifFalse)
+    P(Index ~~ "if" ~~ &(border) ~/ Index ~ baseExpr.? ~ thenPart ~ elsePart ~~ Index).map { case (start, condPos, condRaw, ifTrue, ifFalse, end) =>
+      val cond = condRaw.getOrElse(INVALID(Pos(condPos, condPos), "expected a condition"))
+      IF(Pos(start, end), cond, ifTrue, ifFalse)
     } |
-      P(Index ~~ "then" ~~ &(border) ~/ Index ~ baseExpr.? ~ elsePart ~~ Index).map {
-        case (start, ifTrueExprPos, ifTrueRaw, ifFalse, end) =>
-          val ifTrue = ifTrueRaw.getOrElse(INVALID(Pos(ifTrueExprPos, ifTrueExprPos), "expected a true branch's expression"))
-          IF(Pos(start, end), INVALID(Pos(start, start), "expected a condition"), ifTrue, ifFalse)
+      P(Index ~~ "then" ~~ &(border) ~/ Index ~ baseExpr.? ~ elsePart ~~ Index).map { case (start, ifTrueExprPos, ifTrueRaw, ifFalse, end) =>
+        val ifTrue = ifTrueRaw.getOrElse(INVALID(Pos(ifTrueExprPos, ifTrueExprPos), "expected a true branch's expression"))
+        IF(Pos(start, end), INVALID(Pos(start, start), "expected a condition"), ifTrue, ifFalse)
       } |
-      P(Index ~~ "else" ~~ &(border) ~/ Index ~ baseExpr.? ~~ Index).map {
-        case (start, ifFalseExprPos, ifFalseRaw, end) =>
-          val ifFalse = ifFalseRaw.getOrElse(INVALID(Pos(ifFalseExprPos, ifFalseExprPos), "expected a false branch's expression"))
-          IF(Pos(start, end), INVALID(Pos(start, start), "expected a condition"), INVALID(Pos(start, start), "expected a true branch"), ifFalse)
+      P(Index ~~ "else" ~~ &(border) ~/ Index ~ baseExpr.? ~~ Index).map { case (start, ifFalseExprPos, ifFalseRaw, end) =>
+        val ifFalse = ifFalseRaw.getOrElse(INVALID(Pos(ifFalseExprPos, ifFalseExprPos), "expected a false branch's expression"))
+        IF(Pos(start, end), INVALID(Pos(start, start), "expected a condition"), INVALID(Pos(start, start), "expected a true branch"), ifFalse)
       }
   }
 
@@ -181,23 +175,21 @@ object Parser {
 
   def foldMacroP[A: P]: P[EXPR] =
     (Index ~~ P("FOLD<") ~~ Index ~~ digit.repX(1).! ~~ Index ~~ ">(" ~/ baseExpr ~ "," ~ baseExpr ~ "," ~ lfunP ~ ")" ~~ Index)
-      .map {
-        case (start, limStart, limit, limEnd, list, acc, f, end) =>
-          val lim = limit.toInt
-          if (lim < 1)
-            INVALID(Pos(limStart, limEnd), "FOLD limit should be natural")
-          else if (lim > MaxListLengthV4)
-            INVALID(Pos(limStart, limEnd), s"List size limit in FOLD is too big, $lim must be less or equal $MaxListLengthV4")
-          else
-            FOLD(Pos(start, end), lim, list, acc, f)
+      .map { case (start, limStart, limit, limEnd, list, acc, f, end) =>
+        val lim = limit.toInt
+        if (lim < 1)
+          INVALID(Pos(limStart, limEnd), "FOLD limit should be natural")
+        else if (lim > MaxListLengthV4)
+          INVALID(Pos(limStart, limEnd), s"List size limit in FOLD is too big, $lim must be less or equal $MaxListLengthV4")
+        else
+          FOLD(Pos(start, end), lim, list, acc, f)
       }
 
-  def list[A: P]: P[EXPR] = (Index ~~ P("[") ~ functionCallArgs ~ P("]") ~~ Index).map {
-    case (s, e, f) =>
-      val pos = Pos(s, f)
-      e.foldRight(REF(pos, PART.VALID(pos, "nil")): EXPR) { (v, l) =>
-        FUNCTION_CALL(pos, PART.VALID(pos, "cons"), List(v, l))
-      }
+  def list[A: P]: P[EXPR] = (Index ~~ P("[") ~ functionCallArgs ~ P("]") ~~ Index).map { case (s, e, f) =>
+    val pos = Pos(s, f)
+    e.foldRight(REF(pos, PART.VALID(pos, "nil")): EXPR) { (v, l) =>
+      FUNCTION_CALL(pos, PART.VALID(pos, "cons"), List(v, l))
+    }
   }
 
   def bracedArgs[A: P]: P[Seq[EXPR]] =
@@ -235,8 +227,8 @@ object Parser {
     val KnownMethods: Set[String] = Set(ExactAs, As)
   }
 
-  def singleTypeP[A: P]: P[Single] = (anyVarName ~~ ("[" ~~ Index ~ unionTypeP ~ Index ~~ "]").?).map {
-    case (t, param) => Single(t, param.map { case (start, param, end) => VALID(Pos(start, end), param) })
+  def singleTypeP[A: P]: P[Single] = (anyVarName ~~ ("[" ~~ Index ~ unionTypeP ~ Index ~~ "]").?).map { case (t, param) =>
+    Single(t, param.map { case (start, param, end) => VALID(Pos(start, end), param) })
   }
 
   def unionTypeP[A: P]: P[Type] =
@@ -259,8 +251,8 @@ object Parser {
     def args(implicit c: fastparse.P[Any])        = "(" ~ comment ~ argWithType.rep(0, "," ~ comment) ~ ")" ~ comment
     def funcHeader(implicit c: fastparse.P[Any]) =
       Index ~~ "func" ~ funcname ~ comment ~ args ~ "=" ~ P(singleBaseExpr | ("{" ~ comment ~ baseExpr ~ "}")) ~~ Index
-    funcHeader.map {
-      case (start, name, args, expr, end) => FUNC(Pos(start, end), expr, name, args)
+    funcHeader.map { case (start, name, args, expr, end) =>
+      FUNC(Pos(start, end), expr, name, args)
     }
   }
 
@@ -268,8 +260,8 @@ object Parser {
     case (start, name: PART[String], args: Seq[PART[String]], end) => ANNOTATION(Pos(start, end), name, args)
   }
 
-  def annotatedFunc[A: P]: P[ANNOTATEDFUNC] = (Index ~~ annotationP.rep(1) ~ comment ~ funcP ~~ Index).map {
-    case (start, as, f, end) => ANNOTATEDFUNC(Pos(start, end), as, f)
+  def annotatedFunc[A: P]: P[ANNOTATEDFUNC] = (Index ~~ annotationP.rep(1) ~ comment ~ funcP ~~ Index).map { case (start, as, f, end) =>
+    ANNOTATEDFUNC(Pos(start, end), as, f)
   }
 
   def matchCaseP(implicit c: fastparse.P[Any]): P[MATCH_CASE] = {
@@ -300,9 +292,8 @@ object Parser {
     def typesDefP(implicit c: fastparse.P[Any]) =
       (
         ":" ~ comment ~
-          (unionTypeP | (Index ~~ restMatchCaseInvalidP ~~ Index).map {
-            case (start, _, end) =>
-              Single(PART.INVALID(Pos(start, end), "the type for variable should be specified: `case varName: Type => expr`"), None)
+          (unionTypeP | (Index ~~ restMatchCaseInvalidP ~~ Index).map { case (start, _, end) =>
+            Single(PART.INVALID(Pos(start, end), "the type for variable should be specified: `case varName: Type => expr`"), None)
           })
       ).?.map(_.getOrElse(Union(Seq())))
 
@@ -330,28 +321,27 @@ object Parser {
     P(
       Index ~~ "case" ~~ &(border) ~ comment ~/ (
         pattern |
-          (Index ~~ restMatchCaseInvalidP ~~ Index).map {
-            case (start, _, end) =>
-              TypedVar(
-                Some(PART.INVALID(Pos(start, end), "invalid syntax, should be: `case varName: Type => expr` or `case _ => expr`")),
-                Union(Seq())
-              )
+          (Index ~~ restMatchCaseInvalidP ~~ Index).map { case (start, _, end) =>
+            TypedVar(
+              Some(PART.INVALID(Pos(start, end), "invalid syntax, should be: `case varName: Type => expr` or `case _ => expr`")),
+              Union(Seq())
+            )
           }
       ) ~ comment ~ "=>" ~/ baseExpr.? ~~ Index
-    ).map {
-      case (caseStart, p, e, end) =>
-        checkPattern(p)
-          .fold(
-            error => MATCH_CASE(error.position, pattern = p, expr = error), { pos =>
-              val cPos      = Pos(caseStart, end)
-              val exprStart = pos.fold(caseStart)(_.end)
-              MATCH_CASE(
-                cPos,
-                pattern = p,
-                expr = e.getOrElse(INVALID(Pos(exprStart, end), "expected expression"))
-              )
-            }
-          )
+    ).map { case (caseStart, p, e, end) =>
+      checkPattern(p)
+        .fold(
+          error => MATCH_CASE(error.position, pattern = p, expr = error),
+          { pos =>
+            val cPos      = Pos(caseStart, end)
+            val exprStart = pos.fold(caseStart)(_.end)
+            MATCH_CASE(
+              cPos,
+              pattern = p,
+              expr = e.getOrElse(INVALID(Pos(exprStart, end), "expected expression"))
+            )
+          }
+        )
     }
   }
 
@@ -378,42 +368,39 @@ object Parser {
   )
 
   def functionCallOrGetter[A: P]: P[Accessor] =
-    (genericMethodName ~~/ ("[" ~ unionTypeP ~ "]")).map {
-      case (name, tpe) => GenericMethod(name, tpe)
-    } | (accessorName.map(Getter) ~/ comment ~~ ("(" ~/ comment ~ functionCallArgs ~/ comment ~ ")").?).map {
-      case (g @ Getter(name), args) => args.fold(g: Accessor)(Method(name, _))
+    (genericMethodName ~~/ ("[" ~ unionTypeP ~ "]")).map { case (name, tpe) =>
+      GenericMethod(name, tpe)
+    } | (accessorName.map(Getter) ~/ comment ~~ ("(" ~/ comment ~ functionCallArgs ~/ comment ~ ")").?).map { case (g @ Getter(name), args) =>
+      args.fold(g: Accessor)(Method(name, _))
     }
 
   def maybeAccessP[A: P]: P[EXPR] =
     P(Index ~~ extractableAtom ~~ Index ~~ NoCut(accessP).repX)
-      .map {
-        case (start, obj, _, accessors) =>
-          accessors.foldLeft(obj) {
-            case (e, (accessStart, a, accessEnd)) =>
-              a match {
-                case Getter(n)           => GETTER(Pos(start, accessEnd), e, n)
-                case Method(n, args)     => FUNCTION_CALL(Pos(start, accessEnd), n, e :: args.toList)
-                case ListIndex(index)    => FUNCTION_CALL(Pos(start, accessEnd), PART.VALID(Pos(accessStart, accessEnd), "getElement"), List(e, index))
-                case GenericMethod(n, t) => GENERIC_FUNCTION_CALL(Pos(start, accessEnd), e, n, t)
-              }
+      .map { case (start, obj, _, accessors) =>
+        accessors.foldLeft(obj) { case (e, (accessStart, a, accessEnd)) =>
+          a match {
+            case Getter(n)           => GETTER(Pos(start, accessEnd), e, n)
+            case Method(n, args)     => FUNCTION_CALL(Pos(start, accessEnd), n, e :: args.toList)
+            case ListIndex(index)    => FUNCTION_CALL(Pos(start, accessEnd), PART.VALID(Pos(accessStart, accessEnd), "getElement"), List(e, index))
+            case GenericMethod(n, t) => GENERIC_FUNCTION_CALL(Pos(start, accessEnd), e, n, t)
           }
+        }
       }
 
   def byteVectorP[A: P]: P[EXPR] =
     P(Index ~~ "base" ~~ ("58" | "64" | "16").! ~~ "'" ~/ Pass ~~ CharPred(_ != '\'').repX.! ~~ "'" ~~ Index)
-      .map {
-        case (start, base, xs, end) =>
-          val innerStart = start + 8
-          val innerEnd   = end - 1
-          val decoded = base match {
-            case "16" => Global.base16Decode(xs, checkLength = false)
-            case "58" => Global.base58Decode(xs)
-            case "64" => Global.base64Decode(xs)
-          }
-          decoded match {
-            case Left(err) => CONST_BYTESTR(Pos(start, end), PART.INVALID(Pos(innerStart, innerEnd), err))
-            case Right(r)  => CONST_BYTESTR(Pos(start, end), PART.VALID(Pos(innerStart, innerEnd), ByteStr(r)))
-          }
+      .map { case (start, base, xs, end) =>
+        val innerStart = start + 8
+        val innerEnd   = end - 1
+        val decoded = base match {
+          case "16" => Global.base16Decode(xs, checkLength = false)
+          case "58" => Global.base58Decode(xs)
+          case "64" => Global.base64Decode(xs)
+        }
+        decoded match {
+          case Left(err) => CONST_BYTESTR(Pos(start, end), PART.INVALID(Pos(innerStart, innerEnd), err))
+          case Right(r)  => CONST_BYTESTR(Pos(start, end), PART.VALID(Pos(innerStart, innerEnd), ByteStr(r)))
+        }
       }
 
   private def destructuredTupleValuesP[A: P]: P[Seq[(Int, Option[PART[String]])]] =
@@ -430,34 +417,34 @@ object Parser {
 
   def variableDefP[A: P](key: String): P[Seq[LET]] =
     P(
-      Index ~~ key ~~ &(CharIn(" \t\n\r")) ~/ comment ~ (destructuredTupleValuesP | letNameP) ~ comment ~ Index ~ ("=" ~/ Index ~ baseExpr.?).? ~~ Index
-    ).map {
-      case (start, names, valuePos, valueRaw, end) =>
-        val value = extractValue(valuePos, valueRaw)
-        val pos   = Pos(start, end)
-        if (names.length == 1)
-          names.map {
-            case (nameStart, nameRaw) =>
-              val name = extractName(Pos(nameStart, nameStart), nameRaw)
-              LET(pos, name, value)
-          } else {
-          val exprRefName = "$t0" + s"${pos.start}${pos.end}"
-          val exprRef     = LET(pos, VALID(pos, exprRefName), value)
-          val tupleValues =
-            names.zipWithIndex
-              .map {
-                case ((nameStart, nameRaw), i) =>
-                  val namePos = Pos(nameStart, nameStart)
-                  val name    = extractName(namePos, nameRaw)
-                  val getter = GETTER(
-                    namePos,
-                    REF(namePos, VALID(namePos, exprRefName)),
-                    VALID(namePos, s"_${i + 1}")
-                  )
-                  LET(pos, name, getter)
-              }
-          exprRef +: tupleValues
+      Index ~~ key ~~ &(
+        CharIn(" \t\n\r")
+      ) ~/ comment ~ (destructuredTupleValuesP | letNameP) ~ comment ~ Index ~ ("=" ~/ Index ~ baseExpr.?).? ~~ Index
+    ).map { case (start, names, valuePos, valueRaw, end) =>
+      val value = extractValue(valuePos, valueRaw)
+      val pos   = Pos(start, end)
+      if (names.length == 1)
+        names.map { case (nameStart, nameRaw) =>
+          val name = extractName(Pos(nameStart, nameStart), nameRaw)
+          LET(pos, name, value)
         }
+      else {
+        val exprRefName = "$t0" + s"${pos.start}${pos.end}"
+        val exprRef     = LET(pos, VALID(pos, exprRefName), value)
+        val tupleValues =
+          names.zipWithIndex
+            .map { case ((nameStart, nameRaw), i) =>
+              val namePos = Pos(nameStart, nameStart)
+              val name    = extractName(namePos, nameRaw)
+              val getter = GETTER(
+                namePos,
+                REF(namePos, VALID(namePos, exprRefName)),
+                VALID(namePos, s"_${i + 1}")
+              )
+              LET(pos, name, getter)
+            }
+        exprRef +: tupleValues
+      }
     }
 
   // Hack to force parse of "\n". Otherwise it is treated as a separator
@@ -476,10 +463,9 @@ object Parser {
             (Index ~~ CharPred(_ != '\n').repX).map(pos => Some(INVALID(Pos(pos, pos), "expected ';'")))
         ) ~~
         Index
-    ).map {
-      case (start, varNames, body, end) =>
-        val blockPos = Pos(start, end)
-        Macro.unwrapStrict(blockPos, varNames, body.getOrElse(INVALID(Pos(end, end), "expected a body")))
+    ).map { case (start, varNames, body, end) =>
+      val blockPos = Pos(start, end)
+      Macro.unwrapStrict(blockPos, varNames, body.getOrElse(INVALID(Pos(end, end), "expected a body")))
     }
   }
 
@@ -512,12 +498,11 @@ object Parser {
             (Index ~~ CharPred(_ != '\n').repX).map(pos => Some(otherExpr(Pos(pos, pos))))
         ) ~~
         Index
-    ).map {
-      case (start, declarations, body, end) =>
-        declarations.flatten.reverse
-          .foldLeft(body.getOrElse(INVALID(Pos(end, end), "expected a body"))) { (acc, l) =>
-            BLOCK(Pos(start, end), l, acc)
-          }
+    ).map { case (start, declarations, body, end) =>
+      declarations.flatten.reverse
+        .foldLeft(body.getOrElse(INVALID(Pos(end, end), "expected a body"))) { (acc, l) =>
+          BLOCK(Pos(start, end), l, acc)
+        }
     }
   }
 
@@ -546,8 +531,8 @@ object Parser {
     }
   }
 
-  def binaryOp(atomA: fastparse.P[Any] => P[EXPR], rest: List[Either[List[BinaryOperation], List[BinaryOperation]]])(
-      implicit c: fastparse.P[Any]
+  def binaryOp(atomA: fastparse.P[Any] => P[EXPR], rest: List[Either[List[BinaryOperation], List[BinaryOperation]]])(implicit
+      c: fastparse.P[Any]
   ): P[EXPR] = {
     def atom(implicit c: fastparse.P[Any]) = atomA(c)
     rest match {
@@ -555,9 +540,8 @@ object Parser {
       case Left(kinds) :: restOps =>
         def operand(implicit c: fastparse.P[Any]) = binaryOp(atom(_), restOps)
         val kindc = kinds
-          .map(o => {
-            implicit c: fastparse.P[Any] =>
-              o.parser
+          .map(o => { implicit c: fastparse.P[Any] =>
+            o.parser
           })
           .reduce((plc, prc) => {
             def pl(implicit c: fastparse.P[Any]) = plc(c)
@@ -574,9 +558,8 @@ object Parser {
       case Right(kinds) :: restOps =>
         def operand(implicit c: fastparse.P[Any]) = binaryOp(atom(_), restOps)
         val kindc = kinds
-          .map(o => {
-            implicit c: fastparse.P[Any] =>
-              o.parser
+          .map(o => { implicit c: fastparse.P[Any] =>
+            o.parser
           })
           .reduce((plc, prc) => {
             def pl(implicit c: fastparse.P[Any]) = plc(c)
@@ -595,14 +578,13 @@ object Parser {
   }
 
   def unaryOp(atom: fastparse.P[Any] => P[EXPR], ops: List[UnaryOperation])(implicit c: fastparse.P[Any]): P[EXPR] =
-    ops.foldRight(atom) {
-      case (op, accc) =>
-        def acc(implicit c: fastparse.P[Any]) = accc(c);
-        { implicit c: fastparse.P[Any] =>
-          (Index ~~ op.parser.map(_ => ()) ~ P(unaryOp(atom, ops)) ~~ Index).map {
-            case (start, expr, end) => op.expr(start, end, expr)
-          } | acc
-        }
+    ops.foldRight(atom) { case (op, accc) =>
+      def acc(implicit c: fastparse.P[Any]) = accc(c);
+      { implicit c: fastparse.P[Any] =>
+        (Index ~~ op.parser.map(_ => ()) ~ P(unaryOp(atom, ops)) ~~ Index).map { case (start, expr, end) =>
+          op.expr(start, end, expr)
+        } | acc
+      }
     }(c)
 
   def parseExpr(str: String): Parsed[EXPR] = {
@@ -618,8 +600,8 @@ object Parser {
   def parseContract(str: String): Parsed[DAPP] = {
     def contract[A: P] =
       P(Start ~ unusedText ~ declaration.rep ~ comment ~ annotatedFunc.rep ~ declaration.rep ~ End ~~ Index)
-        .map {
-          case (ds, fs, t, end) => (DAPP(Pos(0, end), ds.flatten.toList, fs.toList), t)
+        .map { case (ds, fs, t, end) =>
+          (DAPP(Pos(0, end), ds.flatten.toList, fs.toList), t)
         }
 
     parse(str, contract(_), verboseFailures = true) match {
diff --git a/lang/tests/src/test/scala/com/wavesplatform/lang/v1/estimator/FunctionComplexityTest.scala b/lang/tests/src/test/scala/com/wavesplatform/lang/doc/FunctionComplexityDocTest.scala
similarity index 96%
rename from lang/tests/src/test/scala/com/wavesplatform/lang/v1/estimator/FunctionComplexityTest.scala
rename to lang/tests/src/test/scala/com/wavesplatform/lang/doc/FunctionComplexityDocTest.scala
index 1cceb591d79..39713ce2b3a 100644
--- a/lang/tests/src/test/scala/com/wavesplatform/lang/v1/estimator/FunctionComplexityTest.scala
+++ b/lang/tests/src/test/scala/com/wavesplatform/lang/doc/FunctionComplexityDocTest.scala
@@ -1,4 +1,4 @@
-package com.wavesplatform.lang.v1.estimator
+package com.wavesplatform.lang.doc
 
 import com.wavesplatform.DocSource
 import com.wavesplatform.common.utils.EitherExt2
@@ -14,7 +14,7 @@ import com.wavesplatform.lang.v1.traits.Environment
 import com.wavesplatform.test.PropSpec
 import org.scalatest.exceptions.TestFailedException
 
-class FunctionComplexityTest extends PropSpec {
+class FunctionComplexityDocTest extends PropSpec {
   private val directives: Iterable[DirectiveSet] =
     DirectiveDictionary[StdLibVersion].all
       .flatMap(version =>
@@ -83,7 +83,7 @@ class FunctionComplexityTest extends PropSpec {
     val checkedUnusedDocCosts = onlyDApp(onlyAccount(unusedDocCosts))
     if (checkedUnusedDocCosts.nonEmpty)
       throw new TestFailedException(
-        s"For RIDE ${ds.stdLibVersion} documented functions is unused: ${checkedUnusedDocCosts.map(_._1).mkString(", ")}",
+        s"For RIDE ${ds.stdLibVersion} documented functions is unused: ${checkedUnusedDocCosts.keys.mkString(", ")}",
         0
       )
   }
diff --git a/lang/tests/src/test/scala/com/wavesplatform/lang/ObjectTypesTest.scala b/lang/tests/src/test/scala/com/wavesplatform/lang/doc/ObjectTypesDocTest.scala
similarity index 94%
rename from lang/tests/src/test/scala/com/wavesplatform/lang/ObjectTypesTest.scala
rename to lang/tests/src/test/scala/com/wavesplatform/lang/doc/ObjectTypesDocTest.scala
index efcea14793b..009494106d5 100644
--- a/lang/tests/src/test/scala/com/wavesplatform/lang/ObjectTypesTest.scala
+++ b/lang/tests/src/test/scala/com/wavesplatform/lang/doc/ObjectTypesDocTest.scala
@@ -1,4 +1,4 @@
-package com.wavesplatform.lang
+package com.wavesplatform.lang.doc
 
 import com.wavesplatform.DocSource
 import com.wavesplatform.lang.directives.values.*
@@ -7,7 +7,7 @@ import com.wavesplatform.lang.v1.compiler.Types.CASETYPEREF
 import com.wavesplatform.test.*
 import org.scalatest.exceptions.TestFailedException
 
-class ObjectTypesTest extends PropSpec {
+class ObjectTypesDocTest extends PropSpec {
   private def getDocFields(typeName: String, version: StdLibVersion): List[(String, String)] =
     DocSource.typeData
       .getOrElse(
diff --git a/lang/tests/src/test/scala/com/wavesplatform/lang/doc/DocExportTest.scala b/lang/tests/src/test/scala/com/wavesplatform/lang/doc/VarsDocTest.scala
similarity index 60%
rename from lang/tests/src/test/scala/com/wavesplatform/lang/doc/DocExportTest.scala
rename to lang/tests/src/test/scala/com/wavesplatform/lang/doc/VarsDocTest.scala
index bc9d43b4dc8..35ba64d2938 100644
--- a/lang/tests/src/test/scala/com/wavesplatform/lang/doc/DocExportTest.scala
+++ b/lang/tests/src/test/scala/com/wavesplatform/lang/doc/VarsDocTest.scala
@@ -5,36 +5,22 @@ import com.wavesplatform.DocSource
 import com.wavesplatform.common.utils.EitherExt2
 import com.wavesplatform.lang.Global
 import com.wavesplatform.lang.directives.DirectiveSet
-import com.wavesplatform.lang.directives.values.{Account, Expression, StdLibVersion, *}
+import com.wavesplatform.lang.directives.values.*
 import com.wavesplatform.lang.v1.CTX
-import com.wavesplatform.lang.v1.compiler.UtilityFunctionPrefix
 import com.wavesplatform.lang.v1.evaluator.ctx.impl.waves.WavesContext
 import com.wavesplatform.lang.v1.evaluator.ctx.impl.{CryptoContext, PureContext}
 import com.wavesplatform.lang.v1.traits.Environment
 import com.wavesplatform.test.*
 
-class DocExportTest extends PropSpec {
-
+class VarsDocTest extends PropSpec {
   def buildFullContext(ds: DirectiveSet): CTX[Environment] = {
     val wavesCtx  = WavesContext.build(Global, ds)
     val cryptoCtx = CryptoContext.build(Global, ds.stdLibVersion).withEnvironment[Environment]
-    val pureCtx = PureContext.build(ds.stdLibVersion, useNewPowPrecision = true).withEnvironment[Environment]
+    val pureCtx   = PureContext.build(ds.stdLibVersion, useNewPowPrecision = true).withEnvironment[Environment]
     pureCtx |+| cryptoCtx |+| wavesCtx
   }
 
-  for( ds <- directives ) {
-    property(s"declared ride FUNCs have doc for $ds contexts") {
-
-      val ctx = buildFullContext(ds)
-      val totalFuncDocs = funcDoc(ctx, ds.stdLibVersion)
-
-      val funcsWithoutDocInfo = totalFuncDocs.filter(_._1.isEmpty).map(_._2).mkString(", ")
-      funcsWithoutDocInfo shouldBe ""
-    }
-  }
-
   property("declared ride VARs have doc for all contexts") {
-
     val totalVarDocs = for {
       ds <- directives
       ctx = buildFullContext(ds)
@@ -51,14 +37,7 @@ class DocExportTest extends PropSpec {
         .map(DirectiveSet(_, Account, Expression).explicitGet())
         .toSeq
 
-
   def varsDoc(ctx: CTX[Environment], ver: StdLibVersion): Iterable[(Option[String], String)] =
     ctx.vars.keys
       .map(k => (DocSource.varData.get((k, ver.value.asInstanceOf[Int])), k))
-
-  def funcDoc(ctx: CTX[Environment], ver: StdLibVersion): Array[(Option[(String, List[String], Int)], String)] =
-    ctx.functions
-      .filterNot(_.name.startsWith(UtilityFunctionPrefix))
-      .map(f => (f.name, f.signature.args.map(_._2.toString).toList))
-      .map(k => (DocSource.funcData.get((k._1, k._2, ver.value.asInstanceOf[Int])), k._1))
 }
diff --git a/lang/tests/src/test/scala/com/wavesplatform/lang/v1/FoldTest.scala b/lang/tests/src/test/scala/com/wavesplatform/lang/evaluator/FoldTest.scala
similarity index 50%
rename from lang/tests/src/test/scala/com/wavesplatform/lang/v1/FoldTest.scala
rename to lang/tests/src/test/scala/com/wavesplatform/lang/evaluator/FoldTest.scala
index ff7ccbd09f2..ebfada6ba97 100644
--- a/lang/tests/src/test/scala/com/wavesplatform/lang/v1/FoldTest.scala
+++ b/lang/tests/src/test/scala/com/wavesplatform/lang/evaluator/FoldTest.scala
@@ -1,12 +1,7 @@
-package com.wavesplatform.lang.v1
+package com.wavesplatform.lang.evaluator
 
-import com.wavesplatform.lang.directives.values.{StdLibVersion, V3, V5}
-import com.wavesplatform.lang.evaluator.EvaluatorSpec
-import com.wavesplatform.lang.script.v1.ExprScript
-import com.wavesplatform.lang.utils.functionCosts
+import com.wavesplatform.lang.directives.values.{StdLibVersion, V3}
 import com.wavesplatform.lang.v1.compiler.Terms.{CONST_BOOLEAN, CONST_LONG}
-import com.wavesplatform.lang.v1.compiler.TestCompiler
-import com.wavesplatform.lang.v1.estimator.v3.ScriptEstimatorV3
 
 class FoldTest extends EvaluatorSpec {
   implicit val startVersion: StdLibVersion = V3
@@ -16,9 +11,7 @@ class FoldTest extends EvaluatorSpec {
       s"""
          | func sum(a:Int, b:Int) = a + b
          | let arr = [1, 2, 3, 4, 5]
-         | let total = FOLD<5>(arr, 9, sum)
-         | total
-         |
+         | FOLD<5>(arr, 9, sum)
       """.stripMargin
 
     eval(script) shouldBe Right(CONST_LONG(1 + 2 + 3 + 4 + 5 + 9))
@@ -122,76 +115,4 @@ class FoldTest extends EvaluatorSpec {
       """.stripMargin
     ) shouldBe Left("Compilation failed: Can't find suitable function sum(a: Int, b: Any) for FOLD<5> in 33-52")
   }
-
-  private val compiler: TestCompiler = TestCompiler(V5)
-  property("unique names are used for different folds") {
-    val script = compiler.compileExpression("""{-# STDLIB_VERSION 5 #-}
-        |{-# CONTENT_TYPE EXPRESSION #-}
-        |{-# SCRIPT_TYPE ACCOUNT #-}
-        |
-        |func f1(acc: String, v: String) = {
-        |    acc + v
-        |}
-        |
-        |let src = ["a", "b", "c"]
-        |
-        |FOLD<3>(src, "F1", f1) != FOLD<3>(src, "F2", f1)
-        |""".stripMargin).asInstanceOf[ExprScript].expr
-    ScriptEstimatorV3(fixOverflow = true, overhead = true).apply(Set.empty, functionCosts(V5), script).isRight shouldBe true
-  }
-
-  property("unique names are used for folds inside foldFunc") {
-    val script = compiler.compileExpression("""{-# STDLIB_VERSION 5 #-}
-        |{-# CONTENT_TYPE EXPRESSION #-}
-        |{-# SCRIPT_TYPE ACCOUNT #-}
-        |
-        |func f1(acc: String, v: String) = {
-        |    acc + v
-        |}
-        |
-        |func f2(acc: String, v: List[String]) = {
-        |    acc + FOLD<3>(v, "STEP", f1)
-        |}
-        |
-        |let src = [
-        |    ["01", "v1_1", "v1_2"],
-        |    ["02", "v2_1", "v2_2"],
-        |    ["03", "v3_1", "v3_2"]
-        |]
-        |
-        |FOLD<3>(src, "", f2) == "STEP01v1_1v1_2STEP02v2_1v2_2STEP03v3_1v3_2"
-        |""".stripMargin).asInstanceOf[ExprScript].expr
-    ScriptEstimatorV3(fixOverflow = true, overhead = true).apply(Set.empty, functionCosts(V5), script).isRight shouldBe true
-  }
-
-  property("unique names are used for native fold") {
-    val script = compiler.compileExpression("""{-# STDLIB_VERSION 5 #-}
-        |{-# CONTENT_TYPE EXPRESSION #-}
-        |{-# SCRIPT_TYPE ACCOUNT #-}
-        |
-        |func f1(acc: List[String], v: Int) = cons(toString(v), acc)
-        |
-        |func add(acc: String, v: String) = acc + v
-        |
-        |FOLD<3>(FOLD<3>([1, 2, 3], [], f1), "F1", add) == "F1321"
-        |""".stripMargin).asInstanceOf[ExprScript].expr
-    ScriptEstimatorV3(fixOverflow = true, overhead = true).apply(Set.empty, functionCosts(V5), script).isRight shouldBe true
-  }
-
-  property("multiple scopes") {
-    val script = compiler.compileExpression("""{-# STDLIB_VERSION 5 #-}
-        |{-# CONTENT_TYPE EXPRESSION #-}
-        |{-# SCRIPT_TYPE ACCOUNT #-}
-        |let foo = [1, 2, 3]
-        |func add(a: Int, b: Int) = a + b
-        |
-        |func f(x: Int) = {
-        |  let a = FOLD<3>(foo, 0, add)
-        |  FOLD<3>(foo, a, add)
-        |}
-        |
-        |f(10) > 0
-        |""".stripMargin).asInstanceOf[ExprScript].expr
-    ScriptEstimatorV3(fixOverflow = true, overhead = true).apply(Set.empty, functionCosts(V5), script).isRight shouldBe true
-  }
 }
diff --git a/lang/tests/src/test/scala/com/wavesplatform/lang/evaluator/fold/GenericFoldTest.scala b/lang/tests/src/test/scala/com/wavesplatform/lang/evaluator/fold/GenericFoldTest.scala
deleted file mode 100644
index 45a396fe73c..00000000000
--- a/lang/tests/src/test/scala/com/wavesplatform/lang/evaluator/fold/GenericFoldTest.scala
+++ /dev/null
@@ -1,80 +0,0 @@
-package com.wavesplatform.lang.evaluator.fold
-
-import com.wavesplatform.lang.directives.values.V3
-import com.wavesplatform.lang.evaluator.EvaluatorSpec
-import com.wavesplatform.lang.v1.compiler.Terms
-import com.wavesplatform.lang.v1.compiler.Terms.{CONST_BOOLEAN, CONST_LONG}
-import com.wavesplatform.test.*
-import org.scalatest.Assertion
-
-class GenericFoldTest extends EvaluatorSpec {
-  private def eval(script: String => String): Either[String, Terms.EVALUATED] =
-    eval(script("FOLD<20>"))(V3)
-
-  private def assertError(script: String => String, error: String => String): Assertion =
-    eval(script("FOLD<20>"))(V3) should produce (error("FOLD<20>"))
-
-  property("sum") {
-    eval(fold =>
-      s"""
-         | func sum(a:Int, b:Int) = a + b
-         | $fold([1, 2, 3, 4, 5], 9, sum)
-       """.stripMargin
-    ) shouldBe Right(CONST_LONG(1 + 2 + 3 + 4 + 5 + 9))
-  }
-
-  property("all is odd") {
-    eval(fold =>
-      s"""
-         | func checkOdd(acc: Boolean, a: Int) = acc && (a % 2 == 1)
-         | $fold([1, 3, 5, 7], true, checkOdd)
-       """.stripMargin
-    ) shouldBe Right(CONST_BOOLEAN(true))
-  }
-
-  property("fold as fold param") {
-    eval(fold =>
-      s"""
-         | func sum(a:Int, b:Int) = a + b
-         | let arr = [1, 2, 3, 4, 5]
-         | $fold(arr, $fold(arr, 9, sum), sum)
-       """.stripMargin
-    ) shouldBe Right(CONST_LONG(9 + 2 * (1 + 2 + 3 + 4 + 5)))
-  }
-
-  property("first argument should be list") {
-    assertError(fold =>
-      s"""
-         | func sum(a:Int, b:Int) = a + b
-         | $fold(1, 9, sum)
-       """.stripMargin,
-      fold => s"Compilation failed: First $fold argument should be List[A], but Int found"
-    )
-  }
-
-  property("suitable function is not found") {
-    assertError(fold =>
-      s"""
-         | func sum(a:Int, b:String) = a
-         | $fold([1], 0, sum)
-       """.stripMargin,
-      fold => s"Compilation failed: Can't find suitable function sum(a: Int, b: Int) for $fold"
-    )
-
-    assertError(fold =>
-      s"""
-         | func sum(a:String, b:Int) = a
-         | $fold([1], 0, sum)
-       """.stripMargin,
-      fold => s"Compilation failed: Can't find suitable function sum(a: Int, b: Int) for $fold"
-    )
-
-    assertError(fold =>
-      s"""
-         | func sum(a:String, b:Int) = a
-         | $fold([], 0, sum)
-       """.stripMargin,
-      fold => s"Compilation failed: Can't find suitable function sum(a: Int, b: Any) for $fold"
-    )
-  }
-}
diff --git a/lang/tests/src/test/scala/com/wavesplatform/lang/evaluator/fold/MacroFoldTest.scala b/lang/tests/src/test/scala/com/wavesplatform/lang/evaluator/fold/MacroFoldTest.scala
deleted file mode 100644
index 7cc8ce5e782..00000000000
--- a/lang/tests/src/test/scala/com/wavesplatform/lang/evaluator/fold/MacroFoldTest.scala
+++ /dev/null
@@ -1,49 +0,0 @@
-package com.wavesplatform.lang.evaluator.fold
-
-import com.wavesplatform.lang.directives.values.{StdLibVersion, V3}
-import com.wavesplatform.lang.evaluator.EvaluatorSpec
-import com.wavesplatform.lang.v1.compiler.Terms.CONST_LONG
-
-class MacroFoldTest extends EvaluatorSpec {
-  implicit val startVersion: StdLibVersion = V3
-
-  property("limit") {
-    val script =
-      s"""
-         | func sum(a:Int, b:Int) = a + b
-         | let arr = [1, 2, 3, 4, 5]
-         | let total = FOLD<4>(arr, 9, sum)
-         | total
-         |
-      """.stripMargin
-
-    eval(script) shouldBe Left("List size exceeds 4")
-  }
-
-  property("limit for limit") {
-    val script =
-      s"""
-         | func sum(a:Int, b:Int) = a + b
-         | let arr = [1, 2, 3, 4, 5]
-         | let total = FOLD<1001>(arr, 9, sum)
-         | total
-         |
-      """.stripMargin
-
-    val index = script.indexOf("1001")
-    eval(script) shouldBe Left(s"Compilation failed: [List size limit in FOLD is too big, 1001 must be less or equal 1000 in $index-${index + 4}]")
-  }
-
-  property("maximum limit") {
-    val script =
-      s"""
-         | func sum(a:Int, b:Int) = a + b
-         | let arr = [${"1," * 999}1]
-         | let total = FOLD<1000>(arr, 2, sum)
-         | total
-         |
-      """.stripMargin
-
-    eval(script) shouldBe Right(CONST_LONG(1002L))
-  }
-}
diff --git a/lang/tests/src/test/scala/com/wavesplatform/lang/v1/estimator/FoldEstimationTest.scala b/lang/tests/src/test/scala/com/wavesplatform/lang/v1/estimator/FoldEstimationTest.scala
new file mode 100644
index 00000000000..4f0aa7fd202
--- /dev/null
+++ b/lang/tests/src/test/scala/com/wavesplatform/lang/v1/estimator/FoldEstimationTest.scala
@@ -0,0 +1,56 @@
+package com.wavesplatform.lang.v1.estimator
+
+import com.wavesplatform.lang.v1.estimator.v3.ScriptEstimatorV3
+
+class FoldEstimationTest extends ScriptEstimatorTestBase(ScriptEstimatorV3(fixOverflow = true, overhead = true)) {
+  property("unique names are used for different folds") {
+    estimate(
+      """
+        | func f1(acc: String, v: String) = acc + v
+        | let src = ["a", "b", "c"]
+        | FOLD<3>(src, "F1", f1) != FOLD<3>(src, "F2", f1)
+      """.stripMargin
+    ).isRight shouldBe true
+  }
+
+  property("unique names are used for folds inside foldFunc") {
+    estimate(
+      """
+        | let src = [
+        |   ["01", "v1_1", "v1_2"],
+        |   ["02", "v2_1", "v2_2"],
+        |   ["03", "v3_1", "v3_2"]
+        | ]
+        | func f1(acc: String, v: String) = acc + v
+        | func f2(acc: String, v: List[String]) = acc + FOLD<3>(v, "STEP", f1)
+        | FOLD<3>(src, "", f2) == "STEP01v1_1v1_2STEP02v2_1v2_2STEP03v3_1v3_2"
+      """.stripMargin
+    ).isRight shouldBe true
+  }
+
+  property("unique names are used for native fold") {
+    estimate(
+      """
+        | func f1(acc: List[String], v: Int) = cons(toString(v), acc)
+        | func add(acc: String, v: String) = acc + v
+        | FOLD<3>(FOLD<3>([1, 2, 3], [], f1), "F1", add) == "F1321"
+      """.stripMargin
+    ).isRight shouldBe true
+  }
+
+  property("multiple scopes") {
+    estimate(
+      """
+        | let foo = [1, 2, 3]
+        | func add(a: Int, b: Int) = a + b
+        |
+        | func f(x: Int) = {
+        |   let a = FOLD<3>(foo, 0, add)
+        |   FOLD<3>(foo, a, add)
+        | }
+        |
+        | f(10) > 0
+      """.stripMargin
+    ).isRight shouldBe true
+  }
+}