Refactoring: removed env implicits

casper/src/main/scala/coop/rchain/casper/MultiParentCasper.scala

@@ -279,14 +279,12 @@ object MultiParentCasper {
 
   def deploy[F[_]: Sync: BlockDagStorage: Log](
       d: Signed[DeployData]
-  ): F[Either[ParsingError, DeployId]] = {
-    import coop.rchain.models.rholang.implicits._
+  ): F[Either[ParsingError, DeployId]] =
     InterpreterUtil
-      .mkTerm(d.data.term, NormalizerEnv(d))
+      .mkTerm(d.data.term)
       .flatMap(_ => addDeploy(d))
       .attempt
       .map(_.leftMap(err => parsingError(s"Error in parsing term: \n$err")))
-  }
 
   private def addDeploy[F[_]: Sync: BlockDagStorage: Log](deploy: Signed[DeployData]): F[DeployId] =
     for {

casper/src/main/scala/coop/rchain/casper/protocol/client/ListenAtName.scala

@@ -36,7 +36,7 @@ object ListenAtName {
   private def buildParId[F[_]: Sync](name: Name): F[Par] =
     name match {
       case PubName(content) =>
-        InterpreterUtil.mkTerm(content, NormalizerEnv.Empty)
+        InterpreterUtil.mkTerm(content)
       case PrivName(content) =>
         Sync[F].delay {
           RhoName(content.getBytes)

casper/src/main/scala/coop/rchain/casper/rholang/InterpreterUtil.scala

@@ -21,10 +21,9 @@ import coop.rchain.crypto.hash.Blake2b512Random
 import coop.rchain.crypto.signatures.Signed
 import coop.rchain.metrics.{Metrics, Span}
 import coop.rchain.models.BlockHash.BlockHash
-import coop.rchain.models.NormalizerEnv.ToEnvMap
 import coop.rchain.models.Validator.Validator
 import coop.rchain.models.syntax._
-import coop.rchain.models.{BlockMetadata, NormalizerEnv, Par}
+import coop.rchain.models.{BlockMetadata, Par}
 import coop.rchain.rholang.interpreter.SystemProcesses.BlockData
 import coop.rchain.rholang.interpreter.compiler.Compiler
 import coop.rchain.rholang.interpreter.errors.InterpreterError
@@ -44,9 +43,7 @@ object InterpreterUtil {
   private[this] val ReplayBlockMetricsSource =
     Metrics.Source(CasperMetricsSource, "replay-block")
 
-  def mkTerm[F[_]: Sync, Env](rho: String, normalizerEnv: NormalizerEnv[Env])(
-      implicit ev: ToEnvMap[Env]
-  ): F[Par] = Compiler[F].sourceToADT(rho, normalizerEnv.toEnv)
+  def mkTerm[F[_]: Sync, Env](rho: String): F[Par] = Compiler[F].sourceToADT(rho)
 
   // TODO: most of this function is legacy code, it should be refactored with separation of errors that are
   //  handled (with included data e.g. hash not equal) and fatal errors which should NOT be handled

casper/src/test/scala/coop/rchain/casper/genesis/contracts/TestUtil.scala

@@ -14,14 +14,13 @@ object TestUtil {
   def eval[F[_]: Sync, Env](
       source: CompiledRholangSource[Env],
       runtime: RhoRuntime[F]
-  )(implicit rand: Blake2b512Random): F[Unit] = eval(source.code, runtime, source.env)
+  )(implicit rand: Blake2b512Random): F[Unit] = eval(source.code, runtime)
 
   def eval[F[_]: Sync](
       code: String,
-      runtime: RhoRuntime[F],
-      normalizerEnv: Map[String, Par]
+      runtime: RhoRuntime[F]
   )(implicit rand: Blake2b512Random): F[Unit] =
-    Compiler[F].sourceToADT(code, normalizerEnv) >>= (evalTerm(_, runtime))
+    Compiler[F].sourceToADT(code) >>= (evalTerm(_, runtime))
 
   private def evalTerm[F[_]: FlatMap](
       term: Par,

casper/src/test/scala/coop/rchain/casper/helper/RhoSpec.scala

@@ -182,9 +182,8 @@ class RhoSpec(
       deploy: Signed[DeployData],
       runtime: RhoRuntime[F]
   ): F[Unit] = {
-    import coop.rchain.models.rholang.implicits._
     val rand = Tools.unforgeableNameRng(deploy.pk, deploy.data.timestamp)
-    eval(deploy.data.term, runtime, NormalizerEnv(deploy).toEnv)(Sync[F], rand)
+    eval(deploy.data.term, runtime)(Sync[F], rand)
   }
 
   private val rhoSpecDeploy: Signed[DeployData] = {

node/src/main/scala/coop/rchain/node/api/ReplGrpcService.scala

@@ -20,7 +20,7 @@ object ReplGrpcService {
         Sync[F]
           .attempt(
             Compiler[F]
-              .sourceToADT(source, Map.empty[String, Par])
+              .sourceToADT(source)
           )
           .flatMap {
             case Left(er) =>

rholang/src/main/scala/coop/rchain/rholang/build/CompiledRholangSource.scala

@@ -14,7 +14,7 @@ abstract class CompiledRholangSource[Env](val code: String, val normalizerEnv: N
   val path: String
 
   import coop.rchain.catscontrib.effect.implicits.sEval
-  val term: Par = Compiler[Eval].sourceToADT(code, normalizerEnv.toEnv).value
+  val term: Par = Compiler[Eval].sourceToADT(code).value
   final def env = normalizerEnv.toEnv
 }
 

rholang/src/main/scala/coop/rchain/rholang/interpreter/Interpreter.scala

@@ -56,7 +56,7 @@ class InterpreterImpl[F[_]: Sync: Span](implicit C: _cost[F], mergeChs: Ref[F, S
       _ <- Span[F].traceI("charge-parsing-cost") { charge[F](parsingCost) }
       parsed <- Span[F].traceI("build-normalized-term") {
                  Compiler[F]
-                   .sourceToADT(term, normalizerEnv)
+                   .sourceToADT(term)
                    .handleErrorWith {
                      case err: InterpreterError => ParserError(err).raiseError[F, Par]
                    }

rholang/src/main/scala/coop/rchain/rholang/interpreter/RholangCLI.scala

@@ -205,7 +205,7 @@ object RholangCLI {
 
     import coop.rchain.catscontrib.effect.implicits.sEval
     Compiler[Eval]
-      .sourceToADT(source, Map.empty[String, Par])
+      .sourceToADT(source)
       .attempt
       .value
       .toTry

rholang/src/main/scala/coop/rchain/rholang/interpreter/compiler/Compiler.scala

@@ -15,20 +15,11 @@ import java.io.{Reader, StringReader}
 trait Compiler[F[_]] {
 
   def sourceToADT(source: String): F[Par] =
-    sourceToADT(source, Map.empty[String, Par])
+    sourceToADT(new StringReader(source))
 
-  def sourceToADT(source: String, normalizerEnv: Map[String, Par]): F[Par] =
-    sourceToADT(new StringReader(source), normalizerEnv)
+  def sourceToADT(reader: Reader): F[Par]
 
-  def sourceToADT(reader: Reader): F[Par] =
-    sourceToADT(reader, Map.empty[String, Par])
-
-  def sourceToADT(reader: Reader, normalizerEnv: Map[String, Par]): F[Par]
-
-  def astToADT(proc: Proc): F[Par] =
-    astToADT(proc, Map.empty[String, Par])
-
-  def astToADT(proc: Proc, normalizerEnv: Map[String, Par]): F[Par]
+  def astToADT(proc: Proc): F[Par]
 
   def sourceToAST(source: String): F[Proc] =
     sourceToAST(new StringReader(source))
@@ -43,15 +34,15 @@ object Compiler {
 
   implicit def parBuilder[F[_]](implicit F: Sync[F]): Compiler[F] = new Compiler[F] {
 
-    def sourceToADT(reader: Reader, normalizerEnv: Map[String, Par]): F[Par] =
+    def sourceToADT(reader: Reader): F[Par] =
       for {
         proc <- sourceToAST(reader)
-        par  <- astToADT(proc, normalizerEnv)
+        par  <- astToADT(proc)
       } yield par
 
-    def astToADT(proc: Proc, normalizerEnv: Map[String, Par]): F[Par] =
+    def astToADT(proc: Proc): F[Par] =
       for {
-        par       <- normalizeTerm(proc)(normalizerEnv)
+        par       <- normalizeTerm(proc)
         sortedPar <- Sortable[Par].sortMatch(par)
       } yield sortedPar.term
 
@@ -75,7 +66,7 @@ object Compiler {
                }
       } yield proc
 
-    private def normalizeTerm(term: Proc)(implicit normalizerEnv: Map[String, Par]): F[Par] =
+    private def normalizeTerm(term: Proc): F[Par] =
       ProcNormalizeMatcher
         .normalizeMatch[F](
           term,