with-sigma-v5.0.13-RC: updated to sigma with DefaultHeader == ZeroHeader

build.sbt

@@ -37,7 +37,7 @@ val circeVersion = "0.13.0"
 val akkaVersion = "2.6.10"
 val akkaHttpVersion = "10.2.4"
 
-val sigmaStateVersion = "5.0.12"
+val sigmaStateVersion = "5.0.12-25-0ee2dfb7-SNAPSHOT"
 
 // for testing current sigmastate build (see sigmastate-ergo-it jenkins job)
 val effectiveSigmaStateVersion = Option(System.getenv().get("SIGMASTATE_VERSION")).getOrElse(sigmaStateVersion)

ergo-wallet/src/main/scala/org/ergoplatform/contracts/ReemissionContracts.scala

@@ -9,6 +9,8 @@ import sigmastate.Values.{ByteArrayConstant, ErgoTree, IntConstant, LongConstant
 import sigmastate.utxo._
 import sigmastate._
 import sigma.Coll
+import sigma.ast.{SBox, SCollection, STuple}
+import sigmastate.Values.ErgoTree.ZeroHeader
 
 /**
   * Container for re-emission related contracts. Contains re-emission contract and pay-to-reemission contract.
@@ -39,8 +41,8 @@ trait ReemissionContracts {
   /** Helper method to produce v1 tree from a SigmaPropValue instance (i.e. root node of AST).*/
   private def v1Tree(prop: SigmaPropValue): ErgoTree = {
     val version: Byte = 1
-    val headerFlags = ErgoTree.headerWithVersion(version)
-    ErgoTree.fromProposition(headerFlags, prop)
+    val header = ErgoTree.headerWithVersion(ZeroHeader, version)
+    ErgoTree.fromProposition(header, prop)
   }
 
   /**

ergo-wallet/src/main/scala/org/ergoplatform/wallet/boxes/BoxSelector.scala

@@ -1,6 +1,6 @@
 package org.ergoplatform.wallet.boxes
 
-import org.ergoplatform.SigmaConstants.MaxBoxSize
+import sigma.data.SigmaConstants.MaxBoxSize
 import org.ergoplatform.sdk.wallet.TokensMap
 import org.ergoplatform.wallet.boxes.BoxSelector.{BoxSelectionError, BoxSelectionResult}
 import org.ergoplatform.{ErgoBoxAssets, ErgoBoxAssetsHolder}

ergo-wallet/src/test/scala/org/ergoplatform/wallet/boxes/DefaultBoxSelectorSpec.scala

@@ -2,7 +2,7 @@ package org.ergoplatform.wallet.boxes
 
 import org.ergoplatform.ErgoBox.TokenId
 import org.ergoplatform.ErgoLikeTransaction
-import org.ergoplatform.SigmaConstants.MaxBoxSize
+import sigma.data.SigmaConstants.MaxBoxSize
 import org.ergoplatform.sdk.wallet.Constants.MaxAssetsPerBox
 import org.ergoplatform.wallet.Constants.PaymentsScanId
 import org.ergoplatform.wallet.boxes.DefaultBoxSelector.{NotEnoughErgsError, NotEnoughTokensError}
@@ -12,7 +12,7 @@ import org.scalatest.propspec.AnyPropSpec
 import scorex.crypto.hash.Blake2b256
 import scorex.util.bytesToId
 import sigmastate.Values
-import sigmastate.Values.SigmaPropValue
+import sigmastate.Values.{ErgoTree, SigmaPropValue}
 import sigmastate.eval.Extensions._
 import sigmastate.helpers.TestingHelpers._
 import sigmastate.utils.Extensions._
@@ -37,7 +37,7 @@ class DefaultBoxSelectorSpec extends AnyPropSpec with Matchers with EitherValues
   private val selector = new DefaultBoxSelector(None)
 
   property("returns error when it is impossible to select coins") {
-    val box = testBox(1, TrueLeaf, creationHeight = StartHeight)
+    val box = testBox(1, ErgoTree.fromProposition(TrueLeaf), creationHeight = StartHeight)
     val uBox = TrackedBox(parentTx, 0, None, box, Set(PaymentsScanId))
 
     //target amount is too high
@@ -55,9 +55,9 @@ class DefaultBoxSelectorSpec extends AnyPropSpec with Matchers with EitherValues
   }
 
   property("properly selects coins - simple case with no assets") {
-    val box1 = testBox(1, TrueLeaf, creationHeight = StartHeight)
-    val box2 = testBox(10, TrueLeaf, creationHeight = StartHeight)
-    val box3 = testBox(100, TrueLeaf, creationHeight = StartHeight)
+    val box1 = testBox(1, ErgoTree.fromProposition(TrueLeaf), creationHeight = StartHeight)
+    val box2 = testBox(10, ErgoTree.fromProposition(TrueLeaf), creationHeight = StartHeight)
+    val box3 = testBox(100, ErgoTree.fromProposition(TrueLeaf), creationHeight = StartHeight)
 
     val uBox1 = TrackedBox(parentTx, 0, Option(100), box1, Set(PaymentsScanId))
     val uBox2 = TrackedBox(parentTx, 1, None, box2, Set(PaymentsScanId))
@@ -101,9 +101,9 @@ class DefaultBoxSelectorSpec extends AnyPropSpec with Matchers with EitherValues
     val assetId2 = bytesToId(Blake2b256("world"))
 
     val parentTx = ErgoLikeTransaction(IndexedSeq(), IndexedSeq())
-    val box1 = testBox(1 * MinBoxValue, TrueLeaf, StartHeight, Seq(assetId1.toTokenId -> 1))
-    val box2 = testBox(10 * MinBoxValue, TrueLeaf, StartHeight, Seq(assetId2.toTokenId -> 10))
-    val box3 = testBox(100 * MinBoxValue, TrueLeaf, StartHeight, Seq(assetId1.toTokenId -> 100))
+    val box1 = testBox(1 * MinBoxValue, ErgoTree.fromProposition(TrueLeaf), StartHeight, Seq(assetId1.toTokenId -> 1))
+    val box2 = testBox(10 * MinBoxValue, ErgoTree.fromProposition(TrueLeaf), StartHeight, Seq(assetId2.toTokenId -> 10))
+    val box3 = testBox(100 * MinBoxValue, ErgoTree.fromProposition(TrueLeaf), StartHeight, Seq(assetId1.toTokenId -> 100))
 
     val uBox1 = TrackedBox(parentTx, 0, Some(100), box1, Set(PaymentsScanId))
     val uBox2 = TrackedBox(parentTx, 1, None, box2, Set(PaymentsScanId))
@@ -150,17 +150,17 @@ class DefaultBoxSelectorSpec extends AnyPropSpec with Matchers with EitherValues
     val assetId8 = bytesToId(Blake2b256("8"))
 
     val box1 = testBox(
-      1 * MinBoxValue, TrueLeaf, StartHeight,
+      1 * MinBoxValue, ErgoTree.fromProposition(TrueLeaf), StartHeight,
       Seq(assetId1.toTokenId -> 1, assetId2.toTokenId -> 1,
           assetId3.toTokenId -> 1, assetId4.toTokenId -> 1))
 
     val box2 = testBox(
-      10 * MinBoxValue, TrueLeaf, StartHeight,
+      10 * MinBoxValue, ErgoTree.fromProposition(TrueLeaf), StartHeight,
       Seq(assetId5.toTokenId -> 10, assetId6.toTokenId -> 10,
           assetId7.toTokenId -> 10, assetId8.toTokenId -> 10))
 
     val box3 = testBox(
-      100 * MinBoxValue, TrueLeaf, StartHeight,
+      100 * MinBoxValue, ErgoTree.fromProposition(TrueLeaf), StartHeight,
       Seq(assetId3.toTokenId -> 100, assetId4.toTokenId -> 100,
         assetId5.toTokenId -> 100, assetId6.toTokenId -> 100))
 
@@ -201,21 +201,21 @@ class DefaultBoxSelectorSpec extends AnyPropSpec with Matchers with EitherValues
     val tokens = (0 until MaxAssetsPerBox).map { _ =>
       (scorex.util.Random.randomBytes(TokenId.size).toTokenId, Random.nextInt(100000000).toLong)
     }
-    val box = testBox(1 * MinBoxValue, TrueLeaf, StartHeight, tokens)
+    val box = testBox(1 * MinBoxValue, ErgoTree.fromProposition(TrueLeaf), StartHeight, tokens)
     assert(box.bytes.length <= MaxBoxSize.value)
   }
 
   property("Select boxes such that change boxes are grouped by MaxAssetsPerBox") {
     // make selection such that '2 * MaxAssetsPerBox + 1' tokens generates exactly 2 change boxes with MaxAssetsPerBox tokens
-    val box1 = testBox(4 * MinBoxValue, TrueLeaf, StartHeight, genTokens(2 * MaxAssetsPerBox + 1))
+    val box1 = testBox(4 * MinBoxValue, ErgoTree.fromProposition(TrueLeaf), StartHeight, genTokens(2 * MaxAssetsPerBox + 1))
     val uBox1 = TrackedBox(parentTx, 0, Some(100), box1, Set(PaymentsScanId))
     val s1 = selector.select(Iterator(uBox1), noFilter, 1 * MinBoxValue, Map(bytesToId(Blake2b256("1")) -> 1))
     s1 shouldBe 'right
     s1.right.get.changeBoxes.size shouldBe 2
     s1.right.get.changeBoxes.forall(_.tokens.size == MaxAssetsPerBox) shouldBe true
 
     // make selection such that '2 * MaxAssetsPerBox + 2' tokens generates 3 change boxes, one with just a single token
-    val box2 = testBox(4 * MinBoxValue, TrueLeaf, StartHeight, genTokens(2 * MaxAssetsPerBox + 2))
+    val box2 = testBox(4 * MinBoxValue, ErgoTree.fromProposition(TrueLeaf), StartHeight, genTokens(2 * MaxAssetsPerBox + 2))
     val uBox2 = TrackedBox(parentTx, 0, Some(100), box2, Set(PaymentsScanId))
     val s2 = selector.select(Iterator(uBox2), noFilter, 1 * MinBoxValue, Map(bytesToId(Blake2b256("1")) -> 1))
     s2 shouldBe 'right
@@ -232,17 +232,17 @@ class DefaultBoxSelectorSpec extends AnyPropSpec with Matchers with EitherValues
 
     val ergValue = 10 * MinBoxValue
 
-    val box1 = testBox(ergValue, TrueLeaf, StartHeight, Seq(tokenData))
+    val box1 = testBox(ergValue, ErgoTree.fromProposition(TrueLeaf), StartHeight, Seq(tokenData))
     val uBox1 = TrackedBox(parentTx, 0, Some(100), box1, Set(PaymentsScanId))
-    val box2 = testBox(ergValue, TrueLeaf, StartHeight)
+    val box2 = testBox(ergValue, ErgoTree.fromProposition(TrueLeaf), StartHeight)
     val uBox2 = TrackedBox(parentTx, 0, Some(100), box2, Set(PaymentsScanId))
 
     val s1 = selector.select(Iterator(uBox1, uBox2), noFilter, ergValue, Map.empty)
     s1 shouldBe 'right
     s1.right.get.changeBoxes.size shouldBe 1
     s1.right.get.changeBoxes.head.tokens(tokenId) shouldBe 2
 
-    val box3 = testBox(ergValue, TrueLeaf, StartHeight)
+    val box3 = testBox(ergValue, ErgoTree.fromProposition(TrueLeaf), StartHeight)
     val uBox3 = TrackedBox(parentTx, 0, Some(100), box3, Set(PaymentsScanId))
 
     val s2 = selector.select(Iterator(uBox2, uBox3), noFilter, ergValue, Map.empty)
@@ -266,7 +266,7 @@ class DefaultBoxSelectorSpec extends AnyPropSpec with Matchers with EitherValues
     val fullValue = 2000000000L
     val reemissionAmt = fullValue / 2
 
-    val inputBox = testBox(fullValue, TrueLeaf, StartHeight, Array((reemissionTokenId, reemissionAmt)))
+    val inputBox = testBox(fullValue, ErgoTree.fromProposition(TrueLeaf), StartHeight, Array((reemissionTokenId, reemissionAmt)))
     val uBox = TrackedBox(parentTx, 0, Some(100), inputBox, Set(PaymentsScanId))
 
     val s1 = selector.select(Iterator(uBox), noFilter, fullValue - reemissionAmt + 1, Map.empty)

ergo-wallet/src/test/scala/org/ergoplatform/wallet/boxes/ReplaceCompactCollectBoxSelectorSpec.scala

@@ -4,7 +4,7 @@ import org.ergoplatform.wallet.Constants.PaymentsScanId
 import org.ergoplatform.ErgoLikeTransaction
 import org.ergoplatform.wallet.boxes.BoxSelector.BoxSelectionResult
 import sigmastate.Values
-import sigmastate.Values.SigmaPropValue
+import sigmastate.Values.{ErgoTree, SigmaPropValue}
 import sigmastate.helpers.TestingHelpers._
 import org.scalatest.EitherValues
 import org.scalatest.matchers.should.Matchers
@@ -17,7 +17,7 @@ class ReplaceCompactCollectBoxSelectorSpec extends AnyPropSpec with Matchers wit
 
   val TrueLeaf: SigmaPropValue = Values.TrueLeaf.toSigmaProp
 
-  def box(value:Long) = testBox(value, TrueLeaf, 0)
+  def box(value:Long) = testBox(value, ErgoTree.fromProposition(TrueLeaf), 0)
   def trackedBox(value:Long) = TrackedBox(parentTx, 0, None, box(value), Set(PaymentsScanId))
 
   property("compress() done properly") {

ergo-wallet/src/test/scala/org/ergoplatform/wallet/interpreter/ErgoProvingInterpreterSpec.scala

@@ -11,7 +11,7 @@ import scorex.util.{ModifierId, Random}
 import scorex.util.encode.Base16
 import sigma.Colls
 import sigmastate.CTHRESHOLD
-import sigmastate.Values.{GroupElementConstant, SigmaBoolean}
+import sigmastate.Values.{ErgoTree, GroupElementConstant, SigmaBoolean}
 import sigmastate.interpreter.{ContextExtension, HintsBag}
 import sigmastate.serialization.ErgoTreeSerializer
 
@@ -63,7 +63,7 @@ class ErgoProvingInterpreterSpec
 
     val creationHeight = 10000
 
-    val boxCandidate = new ErgoBoxCandidate(value, prop, creationHeight)
+    val boxCandidate = new ErgoBoxCandidate(value, ErgoTree.fromProposition(prop), creationHeight)
     val fakeTxId = ModifierId @@ Base16.encode(Array.fill(32)(5: Byte))
     val inputBox = boxCandidate.toBox(fakeTxId, 0.toShort)
 
@@ -94,7 +94,7 @@ class ErgoProvingInterpreterSpec
 
     val value = 100000000L
     val creationHeight = 10000
-    val boxCandidate = new ErgoBoxCandidate(value, pk, creationHeight)
+    val boxCandidate = new ErgoBoxCandidate(value, ErgoTree.fromSigmaBoolean(pk), creationHeight)
 
     val numOfInputs = 50
     val fakeTxId = ModifierId @@ Base16.encode(Array.fill(32)(5: Byte))

ergo-wallet/src/test/scala/org/ergoplatform/wallet/transactions/TransactionBuilderSpec.scala

@@ -10,7 +10,7 @@ import org.ergoplatform.wallet.mnemonic.Mnemonic
 import org.ergoplatform.wallet.utils.WalletTestHelpers
 import org.scalatest.matchers.should.Matchers
 import sigmastate.Values
-import sigmastate.Values.SigmaPropValue
+import sigmastate.Values.{ErgoTree, SigmaPropValue}
 import sigmastate.eval.Extensions._
 import sigmastate.eval._
 import sigmastate.helpers.TestingHelpers._
@@ -40,15 +40,15 @@ class TransactionBuilderSpec extends WalletTestHelpers with Matchers {
   val tid1 = stringToId("t1")
   val tid2 = stringToId("t2")
 
-  def box(value: Long) = testBox(value, TrueProp, currentHeight)
+  def box(value: Long) = testBox(value, ErgoTree.fromProposition(TrueProp), currentHeight)
 
   def box(value: Long, tokens: Seq[(TokenId, Long)]) =
-    testBox(value, TrueProp, currentHeight, tokens)
+    testBox(value, ErgoTree.fromProposition(TrueProp), currentHeight, tokens)
 
-  def boxCandidate(value: Long) = new ErgoBoxCandidate(value, TrueProp, currentHeight)
+  def boxCandidate(value: Long) = new ErgoBoxCandidate(value, ErgoTree.fromProposition(TrueProp), currentHeight)
 
   def boxCandidate(value: Long, tokens: Seq[(TokenId, Long)]) =
-    new ErgoBoxCandidate(value, TrueProp, currentHeight, tokens.toColl)
+    new ErgoBoxCandidate(value, ErgoTree.fromProposition(TrueProp), currentHeight, tokens.toColl)
 
   def transaction(inputBox: ErgoBox,
                   outBox: ErgoBoxCandidate,

ergo-wallet/src/test/scala/org/ergoplatform/wallet/utils/Generators.scala

@@ -12,13 +12,13 @@ import org.scalacheck.Arbitrary.arbByte
 import org.scalacheck.{Arbitrary, Gen}
 import scorex.crypto.authds.ADKey
 import scorex.util._
+import sigma.ast.{SByte, SType}
 import sigmastate.Values.{ByteArrayConstant, CollectionConstant, ErgoTree, EvaluatedValue, FalseLeaf, TrueLeaf}
 import sigmastate.crypto.DLogProtocol.ProveDlog
 import sigmastate.crypto.CryptoFacade.SecretKeyLength
 import sigmastate.eval.Extensions._
 import sigmastate.eval._
 import sigmastate.helpers.TestingHelpers._
-import sigmastate.{SByte, SType}
 
 
 trait Generators {
@@ -107,7 +107,7 @@ trait Generators {
     Gen.choose(minValue, CoinsTotalTest / 1000)
   }
 
-  def ergoBoxGen(propGen: Gen[ErgoTree] = Gen.const(TrueLeaf.toSigmaProp),
+  def ergoBoxGen(propGen: Gen[ErgoTree] = Gen.const(ErgoTree.fromProposition(TrueLeaf.toSigmaProp)),
                  tokensGen: Gen[Seq[(TokenId, Long)]] = additionalTokensGen,
                  valueGenOpt: Option[Gen[Long]] = None,
                  heightGen: Gen[Int] = heightGen): Gen[ErgoBox] = for {
@@ -174,7 +174,7 @@ trait Generators {
 
 
   def unsignedTxGen(secret: SecretKey): Gen[(IndexedSeq[ErgoBox], UnsignedErgoLikeTransaction)] = {
-    val dlog: Gen[ErgoTree] = Gen.const(secret.privateInput.publicImage.asInstanceOf[ProveDlog].toSigmaProp)
+    val dlog: Gen[ErgoTree] = Gen.const(ErgoTree.fromProposition(secret.privateInput.publicImage.asInstanceOf[ProveDlog]))
 
     for {
       ins <- Gen.listOfN(2, ergoBoxGen(dlog))

src/main/scala/org/ergoplatform/http/api/ScriptApiRoute.scala

@@ -15,8 +15,8 @@ import scorex.core.api.http.ApiError.BadRequest
 import scorex.core.api.http.ApiResponse
 import scorex.core.settings.RESTApiSettings
 import scorex.util.encode.Base16
+import sigma.ast.{SBoolean, SSigmaProp}
 import sigmastate.Values.{ByteArrayConstant, ErgoTree}
-import sigmastate._
 import sigmastate.crypto.DLogProtocol.ProveDlog
 import sigmastate.eval.CompiletimeIRContext
 import sigmastate.interpreter.Interpreter
@@ -62,12 +62,12 @@ case class ScriptApiRoute(readersHolder: ActorRef, ergoSettings: ErgoSettings)
 
   private def compileSource(source: String, env: Map[String, Any]): Try[ErgoTree] = {
     import sigmastate.Values._
-    val compiler = new SigmaCompiler(ergoSettings.chainSettings.addressPrefix)
+    val compiler = SigmaCompiler(ergoSettings.chainSettings.addressPrefix)
     Try(compiler.compile(env, source)(new CompiletimeIRContext)).flatMap {
       case CompilerResult(_, _, _, script: Value[SSigmaProp.type@unchecked]) if script.tpe == SSigmaProp =>
-        Success(script)
+        Success(ErgoTree.fromProposition(script))
       case CompilerResult(_, _, _, script: Value[SBoolean.type@unchecked]) if script.tpe == SBoolean =>
-        Success(script.toSigmaProp)
+        Success(ErgoTree.fromProposition(script.toSigmaProp))
       case other =>
         Failure(new Exception(s"Source compilation result is of type ${other.buildTree.tpe}, but `SBoolean` expected"))
     }

src/main/scala/org/ergoplatform/http/api/TransactionsApiRoute.scala

@@ -18,7 +18,7 @@ import scorex.core.api.http.{ApiError, ApiResponse}
 import scorex.core.settings.RESTApiSettings
 import scorex.crypto.authds.ADKey
 import scorex.util.encode.Base16
-import sigmastate.SType
+import sigma.ast.SType
 import sigmastate.Values.EvaluatedValue
 import sigmastate.eval.Extensions.ArrayByteOps
 

src/main/scala/org/ergoplatform/modifiers/history/header/Header.scala

@@ -16,9 +16,10 @@ import scorex.core.serialization.ErgoSerializer
 import scorex.crypto.authds.ADDigest
 import scorex.crypto.hash.Digest32
 import scorex.util._
+import sigma.data.CBigInt
 import sigmastate.crypto.CryptoConstants.EcPointType
 import sigmastate.eval.Extensions._
-import sigmastate.eval.{CAvlTree, CBigInt, CGroupElement, CHeader}
+import sigmastate.eval.{CAvlTree, CGroupElement, CHeader}
 
 import scala.concurrent.duration.FiniteDuration
 

src/main/scala/org/ergoplatform/modifiers/mempool/ErgoTransaction.scala

@@ -2,7 +2,7 @@ package org.ergoplatform.modifiers.mempool
 
 import io.circe.syntax._
 import org.ergoplatform.ErgoBox.BoxId
-import org.ergoplatform.SigmaConstants.{MaxBoxSize, MaxPropositionBytes}
+import sigma.data.SigmaConstants.{MaxBoxSize, MaxPropositionBytes}
 import org.ergoplatform._
 import org.ergoplatform.http.api.ApiCodecs
 import org.ergoplatform.mining.emission.EmissionRules

src/main/scala/org/ergoplatform/nodeView/history/extra/IndexedToken.scala

@@ -9,8 +9,8 @@ import scorex.core.serialization.ErgoSerializer
 import scorex.util.{ByteArrayOps, ModifierId, bytesToId}
 import scorex.util.serialization.{Reader, Writer}
 import sigmastate.Values.CollectionConstant
-import sigmastate.SByte
 import sigma.Extensions._
+import sigma.ast.SByte
 
 /**
   * Index of a token containing creation information.

src/main/scala/org/ergoplatform/nodeView/wallet/ErgoWalletSupport.scala

@@ -21,7 +21,7 @@ import org.ergoplatform.wallet.mnemonic.Mnemonic
 import org.ergoplatform.wallet.transactions.TransactionBuilder
 import scorex.util.ScorexLogging
 import sigma.Colls
-import sigmastate.Values.ByteArrayConstant
+import sigmastate.Values.{ByteArrayConstant, ErgoTree}
 import sigmastate.crypto.DLogProtocol.ProveDlog
 import sigmastate.eval.Extensions._
 import sigmastate.eval._
@@ -255,7 +255,7 @@ trait ErgoWalletSupport extends ScorexLogging {
         // todo: is this extra check needed ?
         val reemissionTokenId = ergoSettings.chainSettings.reemission.reemissionTokenId
         val assets = changeBox.tokens.filterKeys(_ != reemissionTokenId).map(t => t._1.toTokenId -> t._2).toIndexedSeq
-        new ErgoBoxCandidate(changeBox.value, changeAddressOpt.get, walletHeight, assets.toColl)
+        new ErgoBoxCandidate(changeBox.value, ErgoTree.fromProposition(changeAddressOpt.get), walletHeight, assets.toColl)
     }
     val inputBoxes = selectionResult.inputBoxes.toIndexedSeq
     new UnsignedErgoTransaction(

src/main/scala/org/ergoplatform/nodeView/wallet/requests/AssetIssueRequest.scala

@@ -7,7 +7,7 @@ import org.ergoplatform.ErgoBox.NonMandatoryRegisterId
 import org.ergoplatform.http.api.ApiCodecs
 import org.ergoplatform.nodeView.wallet.ErgoAddressJsonEncoder
 import org.ergoplatform.settings.ErgoSettings
-import sigmastate.SType
+import sigma.ast.SType
 import sigmastate.Values.EvaluatedValue
 
 /**

src/main/scala/org/ergoplatform/nodeView/wallet/requests/PaymentRequest.scala

@@ -7,7 +7,7 @@ import org.ergoplatform.modifiers.mempool.ErgoTransaction._
 import org.ergoplatform.nodeView.wallet.ErgoAddressJsonEncoder
 import org.ergoplatform.settings.ErgoSettings
 import org.ergoplatform.{ErgoAddress, ErgoBox}
-import sigmastate.SType
+import sigma.ast.SType
 import sigmastate.Values.EvaluatedValue
 
 /**

src/main/scala/org/ergoplatform/nodeView/wallet/scanning/ScanningPredicate.scala

@@ -2,8 +2,9 @@ package org.ergoplatform.nodeView.wallet.scanning
 
 import org.ergoplatform.ErgoBox
 import sigmastate.Values.EvaluatedValue
-import sigmastate.{SType, Values}
+import sigmastate.Values
 import sigma.Extensions._
+import sigma.ast.SType
 
 /**
   * Basic interface for box scanning predicate functionality

src/main/scala/org/ergoplatform/nodeView/wallet/scanning/ScanningPredicateJsonCodecs.scala

@@ -5,9 +5,9 @@ import io.circe.{Decoder, Encoder, Json}
 import org.ergoplatform.ErgoBox
 import org.ergoplatform.ErgoBox.RegisterId
 import org.ergoplatform.http.api.ApiCodecs
-import sigmastate.SType
 import sigmastate.Values.EvaluatedValue
 import sigma.Extensions._
+import sigma.ast.SType
 
 
 object ScanningPredicateJsonCodecs extends ApiCodecs {