c

sigmastate.lang

SigmaBuilder

abstract class SigmaBuilder extends AnyRef

Abstract interface of ErgoTree node builders. Each method of the interface creates the corresponding ErgoTree node. The signatures of the methods reflect the constructors of the nodes. See the corresponding node classes for details.

Linear Supertypes
AnyRef, Any
Known Subclasses
CheckingSigmaBuilder, CheckingSigmaBuilder, DeserializationSigmaBuilder, StdSigmaBuilder, StdSigmaBuilder, TransformingSigmaBuilder, TransformingSigmaBuilder
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. SigmaBuilder
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new SigmaBuilder()

Abstract Value Members

  1. abstract def mkAND(input: Value[SCollection[SBoolean.type]]): BoolValue
  2. abstract def mkAllOf(input: Seq[Value[SBoolean.type]]): BoolValue
  3. abstract def mkAnyOf(input: Seq[Value[SBoolean.type]]): BoolValue
  4. abstract def mkAppend[IV <: SType](input: Value[SCollection[IV]], col2: Value[SCollection[IV]]): Value[SCollection[IV]]
  5. abstract def mkApply(func: Value[SType], args: IndexedSeq[Value[SType]]): Value[SType]
  6. abstract def mkApplyTypes(input: Value[SType], tpeArgs: Seq[SType]): Value[SType]
  7. abstract def mkArith[T <: SNumericType](left: Value[T], right: Value[T], opCode: OpCode): Value[T]
  8. abstract def mkAtLeast(bound: Value[SInt.type], input: Value[SCollection[SSigmaProp.type]]): SigmaPropValue
  9. abstract def mkBinAnd(left: BoolValue, right: BoolValue): BoolValue
  10. abstract def mkBinOr(left: BoolValue, right: BoolValue): BoolValue
  11. abstract def mkBinXor(left: BoolValue, right: BoolValue): BoolValue
  12. abstract def mkBitAnd[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
  13. abstract def mkBitInversion[T <: SNumericType](input: Value[T]): Value[T]
  14. abstract def mkBitOr[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
  15. abstract def mkBitShiftLeft[T <: SNumericType](bits: Value[T], shift: Value[T]): Value[T]
  16. abstract def mkBitShiftRight[T <: SNumericType](bits: Value[T], shift: Value[T]): Value[T]
  17. abstract def mkBitShiftRightZeroed[T <: SNumericType](bits: Value[T], shift: Value[T]): Value[T]
  18. abstract def mkBitXor[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
  19. abstract def mkBlock(bindings: Seq[Val], result: Value[SType]): Value[SType]
  20. abstract def mkBlockValue(items: IndexedSeq[BlockItem], result: Value[SType]): Value[SType]
  21. abstract def mkBoolToSigmaProp(value: BoolValue): SigmaPropValue

    Logically inverse to mkSigmaPropIsProven

  22. abstract def mkByIndex[IV <: SType](input: Value[SCollection[IV]], index: Value[SInt.type], default: Option[Value[IV]] = None): Value[IV]
  23. abstract def mkByteArrayToBigInt(input: Value[SByteArray]): Value[SBigInt.type]
  24. abstract def mkByteArrayToLong(input: Value[SByteArray]): Value[SLong.type]
  25. abstract def mkCalcBlake2b256(input: Value[SByteArray]): Value[SByteArray]
  26. abstract def mkCalcSha256(input: Value[SByteArray]): Value[SByteArray]
  27. abstract def mkCollectionConstant[T <: SType](values: Coll[mkCollectionConstant.T.WrappedType], elementType: T): Constant[SCollection[T]]
  28. abstract def mkCollectionConstant[T <: SType](values: Array[mkCollectionConstant.T.WrappedType], elementType: T): Constant[SCollection[T]]
  29. abstract def mkConcreteCollection[T <: SType](items: Seq[Value[T]], elementType: T): Value[SCollection[T]]
  30. abstract def mkConstant[T <: SType](value: mkConstant.T.WrappedType, tpe: T): Constant[T]
  31. abstract def mkConstantPlaceholder[T <: SType](id: Int, tpe: T): Value[SType]
  32. abstract def mkCreateAvlTree(operationFlags: ByteValue, digest: Value[SByteArray], keyLength: IntValue, valueLengthOpt: Value[SIntOption]): AvlTreeValue
  33. abstract def mkCreateProveDHTuple(gv: Value[SGroupElement.type], hv: Value[SGroupElement.type], uv: Value[SGroupElement.type], vv: Value[SGroupElement.type]): SigmaPropValue
  34. abstract def mkCreateProveDlog(value: Value[SGroupElement.type]): SigmaPropValue
  35. abstract def mkDecodePoint(input: Value[SByteArray]): GroupElementValue
  36. abstract def mkDeserializeContext[T <: SType](id: Byte, tpe: T): Value[T]
  37. abstract def mkDeserializeRegister[T <: SType](reg: RegisterId, tpe: T, default: Option[Value[T]] = None): Value[T]
  38. abstract def mkDivide[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
  39. abstract def mkDowncast[T <: SNumericType, R <: SNumericType](input: Value[T], tpe: R): Value[R]
  40. abstract def mkEQ[T <: SType](left: Value[T], right: Value[T]): Value[SBoolean.type]
  41. abstract def mkExists[IV <: SType](input: Value[SCollection[IV]], condition: Value[SFunc]): Value[SBoolean.type]
  42. abstract def mkExponentiate(left: Value[SGroupElement.type], right: Value[SBigInt.type]): Value[SGroupElement.type]
  43. abstract def mkExtractAmount(input: Value[SBox.type]): Value[SLong.type]
  44. abstract def mkExtractBytes(input: Value[SBox.type]): Value[SByteArray]
  45. abstract def mkExtractBytesWithNoRef(input: Value[SBox.type]): Value[SByteArray]
  46. abstract def mkExtractCreationInfo(input: Value[SBox.type]): Value[STuple]
  47. abstract def mkExtractId(input: Value[SBox.type]): Value[SByteArray]
  48. abstract def mkExtractRegisterAs[IV <: SType](input: Value[SBox.type], registerId: RegisterId, tpe: SOption[IV]): Value[SType]
  49. abstract def mkExtractScriptBytes(input: Value[SBox.type]): Value[SByteArray]
  50. abstract def mkFilter[IV <: SType](input: Value[SCollection[IV]], condition: Value[SFunc]): Value[SCollection[IV]]
  51. abstract def mkFold[IV <: SType, OV <: SType](input: Value[SCollection[IV]], zero: Value[OV], foldOp: Value[SFunc]): Value[OV]
  52. abstract def mkForAll[IV <: SType](input: Value[SCollection[IV]], condition: Value[SFunc]): Value[SBoolean.type]
  53. abstract def mkFuncValue(args: IndexedSeq[(Int, SType)], body: Value[SType]): Value[SFunc]
  54. abstract def mkGE[T <: SType](left: Value[T], right: Value[T]): Value[SBoolean.type]
  55. abstract def mkGT[T <: SType](left: Value[T], right: Value[T]): Value[SBoolean.type]
  56. abstract def mkGenLambda(tpeParams: Seq[STypeParam], args: IndexedSeq[(String, SType)], givenResType: SType, body: Option[Value[SType]]): Value[SFunc]
  57. abstract def mkGetVar[T <: SType](varId: Byte, tpe: T): Value[SOption[T]]
  58. abstract def mkIdent(name: String, tpe: SType): Value[SType]
  59. abstract def mkIf[T <: SType](condition: Value[SBoolean.type], trueBranch: Value[T], falseBranch: Value[T]): Value[T]
  60. abstract def mkLE[T <: SType](left: Value[T], right: Value[T]): Value[SBoolean.type]
  61. abstract def mkLT[T <: SType](left: Value[T], right: Value[T]): Value[SBoolean.type]
  62. abstract def mkLambda(args: IndexedSeq[(String, SType)], givenResType: SType, body: Option[Value[SType]]): Value[SFunc]
  63. abstract def mkLogicalNot(input: Value[SBoolean.type]): Value[SBoolean.type]
  64. abstract def mkLongToByteArray(input: Value[SLong.type]): Value[SByteArray]
  65. abstract def mkMapCollection[IV <: SType, OV <: SType](input: Value[SCollection[IV]], mapper: Value[SFunc]): Value[SCollection[OV]]
  66. abstract def mkMax[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
  67. abstract def mkMethodCall(obj: Value[SType], method: SMethod, args: IndexedSeq[Value[SType]], typeSubst: STypeSubst): Value[SType]
  68. abstract def mkMethodCallLike(obj: Value[SType], name: String, args: IndexedSeq[Value[SType]], tpe: SType = NoType): Value[SType]
  69. abstract def mkMin[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
  70. abstract def mkMinus[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
  71. abstract def mkMinusModQ(left: Value[SBigInt.type], right: Value[SBigInt.type]): Value[SBigInt.type]
  72. abstract def mkModQ(input: Value[SBigInt.type]): Value[SBigInt.type]
  73. abstract def mkModulo[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
  74. abstract def mkMultiply[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
  75. abstract def mkMultiplyGroup(left: Value[SGroupElement.type], right: Value[SGroupElement.type]): Value[SGroupElement.type]
  76. abstract def mkNEQ[T <: SType](left: Value[T], right: Value[T]): Value[SBoolean.type]
  77. abstract def mkNegation[T <: SNumericType](input: Value[T]): Value[T]
  78. abstract def mkOR(input: Value[SCollection[SBoolean.type]]): BoolValue
  79. abstract def mkOptionGet[T <: SType](input: Value[SOption[T]]): Value[T]
  80. abstract def mkOptionGetOrElse[T <: SType](input: Value[SOption[T]], default: Value[T]): Value[T]
  81. abstract def mkOptionIsDefined[T <: SType](input: Value[SOption[T]]): Value[SBoolean.type]
  82. abstract def mkPlus[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
  83. abstract def mkPlusModQ(left: Value[SBigInt.type], right: Value[SBigInt.type]): Value[SBigInt.type]
  84. abstract def mkSelect(obj: Value[SType], field: String, resType: Option[SType] = None): Value[SType]
  85. abstract def mkSelectField(input: Value[STuple], fieldIndex: Byte): Value[SType]
  86. abstract def mkSigmaAnd(items: Seq[SigmaPropValue]): SigmaPropValue
  87. abstract def mkSigmaOr(items: Seq[SigmaPropValue]): SigmaPropValue
  88. abstract def mkSigmaPropBytes(value: Value[SSigmaProp.type]): Value[SByteArray]
  89. abstract def mkSigmaPropIsProven(value: Value[SSigmaProp.type]): BoolValue

    Logically inverse to mkBoolToSigmaProp

  90. abstract def mkSizeOf[IV <: SType](input: Value[SCollection[IV]]): Value[SInt.type]
  91. abstract def mkSlice[IV <: SType](input: Value[SCollection[IV]], from: Value[SInt.type], until: Value[SInt.type]): Value[SCollection[IV]]
  92. abstract def mkStringConcat(left: Constant[SString.type], right: Constant[SString.type]): Value[SString.type]
  93. abstract def mkSubstConst[T <: SType](scriptBytes: Value[SByteArray], positions: Value[SIntArray], newValues: Value[SCollection[T]]): Value[SByteArray]
  94. abstract def mkTaggedVariable[T <: SType](varId: Byte, tpe: T): TaggedVariable[T]
  95. abstract def mkTreeLookup(tree: Value[SAvlTree.type], key: Value[SByteArray], proof: Value[SByteArray]): Value[SOption[SByteArray]]
  96. abstract def mkTuple(items: Seq[Value[SType]]): Value[SType]
  97. abstract def mkUnitConstant: Value[SUnit.type]
  98. abstract def mkUpcast[T <: SNumericType, R <: SNumericType](input: Value[T], tpe: R): Value[R]
  99. abstract def mkVal(name: String, givenType: SType, body: Value[SType]): Val
  100. abstract def mkValUse(valId: Int, tpe: SType): Value[SType]
  101. abstract def mkXor(left: Value[SByteArray], right: Value[SByteArray]): Value[SByteArray]
  102. abstract def mkXorOf(input: Value[SCollection[SBoolean.type]]): BoolValue
  103. abstract def mkZKProofBlock(body: Value[SSigmaProp.type]): Value[SBoolean.type]

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  6. val currentSrcCtx: DynamicVariable[Nullable[SourceContext]]

    Dynamic variable used to pass SourceContext to the constructors of the node.

    Dynamic variable used to pass SourceContext to the constructors of the node. Used in concrete implementations of this interface.

  7. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  8. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  9. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  10. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  11. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  12. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  13. def liftAny(obj: Any): Nullable[SValue]

    Created a new Value instance with an appropriate type derived from the given data obj.

    Created a new Value instance with an appropriate type derived from the given data obj. If obj is already Value, then it is returned as result. Uses scalan.Nullable instead of Option to avoid allocation on consensus hot path.

  14. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  15. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  16. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  17. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  18. def toString(): String
    Definition Classes
    AnyRef → Any
  19. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  20. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  21. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()

Inherited from AnyRef

Inherited from Any

Ungrouped