Packages

o

sigmastate

Values

object Values

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Values
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type AvlTreeConstant = Constant[SAvlTree.type]
  2. type AvlTreeValue = Value[SAvlTree.type]
  3. type BigIntConstant = Constant[SBigInt.type]
  4. type BigIntValue = Value[SBigInt.type]
  5. sealed trait BlockItem extends Value[SType] with NotReadyValue[SType]
  6. case class BlockValue(items: IndexedSeq[BlockItem], result: SValue) extends Value[SType] with NotReadyValue[SType] with Product with Serializable

    The order of ValDefs in the block is used to assign ids to ValUse(id) nodes For all i: items(i).id == {number of ValDefs preceded in a graph} with respect to topological order.

    The order of ValDefs in the block is used to assign ids to ValUse(id) nodes For all i: items(i).id == {number of ValDefs preceded in a graph} with respect to topological order. Specific topological order doesn't really matter, what is important is to preserve semantic linkage between ValUse(id) and ValDef with the corresponding id. This convention allow to valid serializing ids because we always serializing and deserializing in a fixed well defined order.

  7. type BoolValue = Value[SBoolean.type]
  8. type BooleanConstant = Constant[SBoolean.type]
  9. type BoxConstant = Constant[SBox.type]
  10. type BoxValue = Value[SBox.type]
  11. type ByteConstant = Constant[SByte.type]
  12. type ByteValue = Value[SByte.type]
  13. type CollectionConstant[T <: SType] = Constant[SCollection[T]]
  14. implicit final class CollectionOps[T <: SType] extends AnyVal
  15. type CollectionValue[T <: SType] = Value[SCollection[T]]
  16. case class ConcreteCollection[V <: SType](items: Seq[Value[V]], elementType: V) extends EvaluatedValue[SCollection[V]] with EvaluatedCollection[V, SCollection[V]] with Product with Serializable

    ErgoTree node which converts a collection of expressions into a collection of data values.

    ErgoTree node which converts a collection of expressions into a collection of data values. Each data value of the resulting collection is obtained by evaluating the corresponding expression in items. All items must have the same type.

    items

    source collection of expressions

    elementType

    type descriptor of elements in the resulting collection

  17. abstract class Constant[+S <: SType] extends EvaluatedValue[S]

    Base class for all constant literals whose data value is already known and never changes.

    Base class for all constant literals whose data value is already known and never changes.

    See also

    ConstantNode

  18. case class ConstantNode[S <: SType](value: S.WrappedType, tpe: S) extends Constant[S] with Product with Serializable

    ErgoTree node which represents data literals, i.e.

    ErgoTree node which represents data literals, i.e. data values embedded in an expression.

    value

    data value of the underlying Scala type

    tpe

    type descriptor of the data value and also the type of the value represented by this node.

    See also

    Constant

  19. case class ConstantPlaceholder[S <: SType](id: Int, tpe: S) extends Value[S] with Product with Serializable

    Placeholder for a constant in ErgoTree.

    Placeholder for a constant in ErgoTree. Zero based index in ErgoTree.constants array.

  20. trait ContextVariable[S <: SType] extends Value[S] with NotReadyValue[S]

    Base class for references to context variables.

  21. case class ErgoTree extends Product with Serializable

    The root of ErgoScript IR.

    The root of ErgoScript IR. Serialized instances of this class are self sufficient and can be passed around. ErgoTreeSerializer defines top-level serialization format of the scripts. The interpretation of the byte array depend on the first header byte, which uses VLQ encoding up to 30 bits. Currently we define meaning for only first byte, which may be extended in future versions. 7 6 5 4 3 2 1 0 -------------------------

    Bit 7 == 1 if the header contains more than 1 byte (default == 0) Bit 6 - reserved for GZIP compression (should be 0) Bit 5 == 1 - reserved for context dependent costing (should be = 0) Bit 4 == 1 if constant segregation is used for this ErgoTree (default = 0) (see https://github.com/ScorexFoundation/sigmastate-interpreter/issues/264) Bit 3 == 1 if size of the whole tree is serialized after the header byte (default = 0) Bits 2-0 - language version (current version == 0)

    Currently we don't specify interpretation for the second and other bytes of the header. We reserve the possibility to extend header by using Bit 7 == 1 and chain additional bytes as in VLQ. Once the new bytes are required, a new version of the language should be created and implemented. That new language will give an interpretation for the new bytes.

    Consistency between fields is ensured by private constructor and factory methods in ErgoTree object. For performance reasons, ErgoTreeSerializer can be configured to perform additional constant segregation. In such a case after deserialization there may be more constants segregated. This is done for example to support caching optimization described in #264 mentioned above.

    The default behavior of ErgoTreeSerializer is to preserve original structure of ErgoTree and check consistency. In case of any inconsistency the serializer throws exception.

  22. trait EvaluatedCollection[T <: SType, C <: SCollection[T]] extends EvaluatedValue[C]

    Base type for evaluated tree nodes of Coll type.

  23. abstract class EvaluatedValue[+S <: SType] extends Value[S]

    Base class for ErgoTree nodes which represents a data value which has already been evaluated and no further evaluation (aka reduction) is necessary by the interpreter.

    Base class for ErgoTree nodes which represents a data value which has already been evaluated and no further evaluation (aka reduction) is necessary by the interpreter.

    See also

    Constant, ConcreteCollection, Tuple

  24. trait FixedCostValueCompanion extends ValueCompanion

    Should be inherited by companion objects of operations with fixed cost kind.

  25. case class FuncValue(args: IndexedSeq[(Int, SType)], body: Value[SType]) extends Value[SFunc] with NotReadyValue[SFunc] with Product with Serializable

    args

    parameters list, where each parameter has an id and a type.

    body

    expression, which refers function parameters with ValUse.

  26. type GroupElementConstant = Constant[SGroupElement.type]
  27. type GroupElementValue = Value[SGroupElement.type]
  28. type IntConstant = Constant[SInt.type]
  29. type IntValue = Value[SInt.type]
  30. trait LazyCollection[V <: SType] extends Value[SCollection[V]] with NotReadyValue[SCollection[V]]
  31. type LongConstant = Constant[SLong.type]
  32. type LongValue = Value[SLong.type]
  33. case class NoneValue[T <: SType](elemType: T) extends Value[SOption[T]] with OptionValue[T] with Product with Serializable
  34. trait NotReadyValue[S <: SType] extends Value[S]
  35. trait NotReadyValueAvlTree extends Value[SAvlTree.type] with NotReadyValue[SAvlTree.type]
  36. trait NotReadyValueBigInt extends Value[SBigInt.type] with NotReadyValue[SBigInt.type]
  37. trait NotReadyValueBoolean extends Value[SBoolean.type] with NotReadyValue[SBoolean.type]
  38. trait NotReadyValueBox extends Value[SBox.type] with NotReadyValue[SBox.type]
  39. trait NotReadyValueByteArray extends Value[SByteArray] with NotReadyValue[SByteArray]
  40. trait NotReadyValueGroupElement extends Value[SGroupElement.type] with NotReadyValue[SGroupElement.type]
  41. trait NotReadyValueInt extends Value[SInt.type] with NotReadyValue[SInt.type]
  42. trait NotReadyValueLong extends Value[SLong.type] with NotReadyValue[SLong.type]
  43. trait OptionValue[T <: SType] extends Value[SOption[T]]
  44. implicit final class OptionValueOps[T <: SType] extends AnyVal
  45. trait PerItemCostValueCompanion extends ValueCompanion

    Should be inherited by companion objects of operations with per-item cost kind.

  46. type SAnyValue = Value[SAny.type]
  47. type SValue = Value[SType]
  48. type ShortConstant = Constant[SShort.type]
  49. type ShortValue = Value[SShort.type]
  50. trait SigmaBoolean extends AnyRef

    Algebraic data type of sigma proposition expressions.

    Algebraic data type of sigma proposition expressions. Values of this type are used as values of SigmaProp type of SigmaScript and SigmaDsl

  51. implicit final class SigmaBooleanOps extends AnyVal
  52. type SigmaPropConstant = Constant[SSigmaProp.type]
  53. type SigmaPropValue = Value[SSigmaProp.type]
  54. implicit final class SigmaPropValueOps extends AnyVal
  55. case class SomeValue[T <: SType](x: Value[T]) extends Value[SOption[T]] with OptionValue[T] with Product with Serializable
  56. type StringConstant = Constant[SString.type]
  57. type StringValue = Value[SString.type]
  58. type TaggedAvlTree = TaggedVariable[SAvlTree.type]
  59. type TaggedBigInt = TaggedVariable[SBigInt.type]
  60. type TaggedBoolean = TaggedVariable[SBoolean.type]
  61. type TaggedBox = TaggedVariable[SBox.type]
  62. type TaggedByte = TaggedVariable[SByte.type]
  63. type TaggedByteArray = TaggedVariable[SCollection[SByte.type]]
  64. type TaggedGroupElement = TaggedVariable[SGroupElement.type]
  65. type TaggedInt = TaggedVariable[SInt.type]
  66. type TaggedLong = TaggedVariable[SLong.type]
  67. type TaggedShort = TaggedVariable[SShort.type]
  68. type TaggedSigmaProp = TaggedVariable[SSigmaProp.type]
  69. trait TaggedVariable[T <: SType] extends Value[T] with ContextVariable[T]

    Reference a context variable by id.

  70. case class TaggedVariableNode[T <: SType](varId: Byte, tpe: T) extends Value[T] with TaggedVariable[T] with Product with Serializable
  71. case class Tuple(items: IndexedSeq[Value[SType]]) extends EvaluatedValue[STuple] with EvaluatedCollection[SAny.type, STuple] with Product with Serializable

    ErgoTree node which converts a collection of expressions into a tuple of data values of different types.

    ErgoTree node which converts a collection of expressions into a tuple of data values of different types. Each data value of the resulting collection is obtained by evaluating the corresponding expression in items. All items may have different types.

    items

    source collection of expressions

  72. case class UnparsedErgoTree(bytes: WrappedArray[Byte], error: ValidationException) extends Product with Serializable

    This is alternative representation of ErgoTree expression when it cannot be parsed due to error.

    This is alternative representation of ErgoTree expression when it cannot be parsed due to error. This is used by the nodes running old versions of code to recognize soft-fork conditions and skip validation of box propositions which are unparsable.

  73. case class ValDef(id: Int, tpeArgs: Seq[STypeVar], rhs: SValue) extends Value[SType] with BlockItem with Product with Serializable

    IR node for let-bound expressions let x = rhs which is ValDef, or let f[T] = rhs which is FunDef.

    IR node for let-bound expressions let x = rhs which is ValDef, or let f[T] = rhs which is FunDef. These nodes are used to represent ErgoTrees after common sub-expression elimination. This representation is more compact in serialized form.

    id

    unique identifier of the variable in the current scope.

  74. case class ValUse[T <: SType](valId: Int, tpe: T) extends Value[T] with NotReadyValue[T] with Product with Serializable

    Special node which represents a reference to ValDef it was introduced as result of CSE.

  75. abstract class Value[+S <: SType] extends SigmaNode

    Base class for all ErgoTree expression nodes.

    Base class for all ErgoTree expression nodes.

    See also

    sigmastate.Values.ErgoTree

  76. trait ValueCompanion extends SigmaNodeCompanion

    Base class for all companion objects which are used as operation descriptors.

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. val BoolArrayTypeCode: Byte
  5. val ByteArrayTypeCode: Byte
  6. val FalseSigmaProp: Constant[SSigmaProp.type]
  7. def GetVarBigInt(varId: Byte): GetVar[SBigInt.type]
  8. def GetVarBoolean(varId: Byte): GetVar[SBoolean.type]
  9. def GetVarBox(varId: Byte): GetVar[SBox.type]
  10. def GetVarByte(varId: Byte): GetVar[SByte.type]
  11. def GetVarByteArray(varId: Byte): GetVar[SCollection[SByte.type]]
  12. def GetVarInt(varId: Byte): GetVar[SInt.type]
  13. def GetVarIntArray(varId: Byte): GetVar[SCollection[SInt.type]]
  14. def GetVarLong(varId: Byte): GetVar[SLong.type]
  15. def GetVarShort(varId: Byte): GetVar[SShort.type]
  16. def GetVarSigmaProp(varId: Byte): GetVar[SSigmaProp.type]
  17. def TaggedAvlTree(id: Byte): Value[SAvlTree.type]
  18. def TaggedBox(id: Byte): Value[SBox.type]
  19. val TrueSigmaProp: Constant[SSigmaProp.type]
  20. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  21. implicit def boolToSigmaProp(b: BoolValue): SigmaPropValue
  22. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  23. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  24. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  25. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  26. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  27. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  28. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  29. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  30. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  31. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  32. val reflection: InterpreterReflection.type

    Force initialization of reflection.

  33. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  34. def toString(): String
    Definition Classes
    AnyRef → Any
  35. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  36. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  37. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  38. object AvlTreeConstant
  39. object BigIntArrayConstant
  40. object BigIntConstant
  41. object BlockItem
  42. object BlockValue extends ValueCompanion with Serializable
  43. object BoolArrayConstant
  44. object BooleanConstant
  45. object BoxConstant
  46. object ByteArrayConstant
  47. object ByteConstant
  48. object CollectionConstant
  49. object ConcreteCollection extends FixedCostValueCompanion with Serializable
  50. object ConcreteCollectionBooleanConstant extends ValueCompanion
  51. object Constant extends FixedCostValueCompanion
  52. object ConstantPlaceholder extends ValueCompanion with Serializable
  53. object ErgoTree extends Serializable
  54. object FalseLeaf extends ConstantNode[SBoolean.type] with ValueCompanion

    ErgoTree node which represents false literal.

  55. object FunDef extends ValueCompanion
  56. object FuncValue extends FixedCostValueCompanion with Serializable
  57. object GroupElementConstant
  58. object GroupGenerator extends EvaluatedValue[SGroupElement.type] with ValueCompanion with Product with Serializable

    ErgoTree node that represents the operation of obtaining the generator of elliptic curve group.

    ErgoTree node that represents the operation of obtaining the generator of elliptic curve group. The generator g of the group is an element of the group such that, when written multiplicative form, every element of the group is a power of g.

  59. object HeaderConstant
  60. object IntArrayConstant
  61. object IntConstant
  62. object LongArrayConstant
  63. object LongConstant
  64. object NoneValue extends ValueCompanion with Serializable
  65. object PreHeaderConstant
  66. object ShortArrayConstant
  67. object ShortConstant
  68. object SigmaBoolean
  69. object SigmaPropConstant
  70. object SomeValue extends ValueCompanion with Serializable
  71. object StringConstant
  72. object TaggedVariable extends ValueCompanion
  73. object TrueLeaf extends ConstantNode[SBoolean.type] with ValueCompanion

    ErgoTree node which represents true literal.

  74. object Tuple extends FixedCostValueCompanion with Serializable
  75. object UnitConstant

    High-level interface to internal representation of Unit constants in ErgoTree.

  76. object ValDef extends ValueCompanion with Serializable
  77. object ValUse extends FixedCostValueCompanion with Serializable
  78. object Value
  79. object ValueCompanion

Inherited from AnyRef

Inherited from Any

Ungrouped