sigmastate
package sigmastate
- Alphabetic
- By Inheritance
- sigmastate
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
case class
AND(input: Value[SCollection[SBoolean.type]]) extends Transformer[SCollection[SBoolean.type], SBoolean.type] with NotReadyValueBoolean with Product with Serializable
AND logical conjunction
-
case class
ArgInfo(name: String, description: String) extends Product with Serializable
Meta information which can be attached to each argument of SMethod.
Meta information which can be attached to each argument of SMethod.
- name
name of the argument
- description
argument description.
- case class ArithOp[T <: SType](left: Value[T], right: Value[T], opCode: OpCode) extends TwoArgumentsOperation[T, T, T] with NotReadyValue[T] with Product with Serializable
-
class
ArithOpCompanion extends TwoArgumentOperationCompanion
NOTE: by-name argument is required for correct initialization order.
-
case class
AtLeast(bound: Value[SInt.type], input: Value[SCollection[SSigmaProp.type]]) extends Transformer[SCollection[SSigmaProp.type], SSigmaProp.type] with NotReadyValue[SSigmaProp.type] with Product with Serializable
Logical threshold.
Logical threshold. AtLeast has two inputs: integer bound and children same as in AND/OR. The result is true if at least bound children are true.
-
case class
AvlTreeData(digest: ADDigest, treeFlags: AvlTreeFlags, keyLength: Int, valueLengthOpt: Option[Int] = None) extends Product with Serializable
Type of data which efficiently authenticates potentially huge dataset having key-value dictionary interface.
Type of data which efficiently authenticates potentially huge dataset having key-value dictionary interface. Only root hash of dynamic AVL+ tree, tree height, key length, optional value length, and access flags are stored in an instance of the datatype.
Please note that standard hash function from CryptoConstants is used, and height is stored along with root hash of the tree, thus
digest
size is always CryptoConstants.hashLength + 1 bytes.- digest
authenticated tree digest: root hash along with tree height
- treeFlags
- allowed modifications. See AvlTreeFlags description for details
- keyLength
- all the elements under the tree have the same length
- valueLengthOpt
- if non-empty, all the values under the tree are of the same length
- case class AvlTreeFlags(insertAllowed: Boolean, updateAllowed: Boolean, removeAllowed: Boolean) extends Product with Serializable
-
case class
BinAnd(left: BoolValue, right: BoolValue) extends Relation[SBoolean.type, SBoolean.type] with Product with Serializable
Logical AND with lazy right argument which is evaluated only if left == true.
Logical AND with lazy right argument which is evaluated only if left == true. If left argument is false, the right is guaranteed to NOT be evaluated
-
case class
BinOr(left: BoolValue, right: BoolValue) extends Relation[SBoolean.type, SBoolean.type] with Product with Serializable
Logical OR with lazy right argument which is evaluated only if left == false.
Logical OR with lazy right argument which is evaluated only if left == false. If left argument is true, the right is guaranteed to NOT be evaluated
- case class BinXor(left: BoolValue, right: BoolValue) extends Relation[SBoolean.type, SBoolean.type] with Product with Serializable
- case class BitInversion[T <: SNumericType](input: Value[T]) extends OneArgumentOperation[T, T] with Product with Serializable
- case class BitOp[T <: SNumericType](left: Value[T], right: Value[T], opCode: OpCode) extends TwoArgumentsOperation[T, T, T] with NotReadyValue[T] with Product with Serializable
-
class
BitOpCompanion extends TwoArgumentOperationCompanion
NOTE: by-name argument is required for correct initialization order.
-
case class
BoolToSigmaProp(value: BoolValue) extends SigmaPropValue with Product with Serializable
Embedding of Boolean values to SigmaProp values.
Embedding of Boolean values to SigmaProp values. As an example, this operation allows boolean experesions to be used as arguments of
atLeast(..., sigmaProp(boolExpr), ...)
operation. During execution results to eitherTrueProp
orFalseProp
values of SigmaProp type. -
case class
ByteArrayToBigInt(input: Value[SByteArray]) extends Transformer[SByteArray, SBigInt.type] with NotReadyValueBigInt with Product with Serializable
Convert SByteArray to SBigInt
-
case class
ByteArrayToLong(input: Value[SByteArray]) extends Transformer[SByteArray, SLong.type] with NotReadyValueLong with Product with Serializable
Convert SByteArray to SLong
-
case class
CAND(sigmaBooleans: Seq[SigmaBoolean]) extends SigmaBoolean with Product with Serializable
AND conjunction for sigma propositions
- case class CAndUncheckedNode(challenge: Challenge, children: Seq[UncheckedSigmaTree]) extends UncheckedConjecture with Product with Serializable
- case class CAndUnproven(proposition: CAND, challengeOpt: Option[Challenge] = None, simulated: Boolean, children: Seq[ProofTree]) extends UnprovenConjecture with Product with Serializable
-
case class
COR(sigmaBooleans: Seq[SigmaBoolean]) extends SigmaBoolean with Product with Serializable
OR disjunction for sigma propositions
- case class COrUncheckedNode(challenge: Challenge, children: Seq[UncheckedSigmaTree]) extends UncheckedConjecture with Product with Serializable
- case class COrUnproven(proposition: COR, challengeOpt: Option[Challenge] = None, simulated: Boolean, children: Seq[ProofTree]) extends UnprovenConjecture with Product with Serializable
-
case class
CTHRESHOLD(k: Int, sigmaBooleans: Seq[SigmaBoolean]) extends SigmaBoolean with Product with Serializable
THRESHOLD connector for sigma propositions
- case class CThresholdUncheckedNode(challenge: Challenge, children: Seq[UncheckedSigmaTree], k: Integer, polynomialOpt: Option[GF2_192_Poly]) extends UncheckedConjecture with Product with Serializable
- case class CThresholdUnproven(proposition: CTHRESHOLD, challengeOpt: Option[Challenge] = None, simulated: Boolean, k: Integer, children: Seq[ProofTree], polynomialOpt: Option[GF2_192_Poly]) extends UnprovenConjecture with Product with Serializable
-
case class
CalcBlake2b256(input: Value[SByteArray]) extends CalcHash with Product with Serializable
Calculate Blake2b hash from
input
- trait CalcHash extends Transformer[SByteArray, SByteArray] with NotReadyValueByteArray
-
case class
CalcSha256(input: Value[SByteArray]) extends CalcHash with Product with Serializable
Calculate Sha256 hash from
input
-
case class
Coster(selector: (RuntimeCosting) ⇒ eval.RuntimeCosting.CostingHandler[_]) extends CosterFactory with Product with Serializable
An instance of this class is created in each
STypeCompaion.coster
property implementation.An instance of this class is created in each
STypeCompaion.coster
property implementation.- See also
SBox, SContext
-
trait
CosterFactory extends AnyRef
Special interface to access CostingHandler.
Special interface to access CostingHandler. Each
STypeCompanion.coster
property optionally defines an instance of this interface to provide access to Coster for its methods. If not specified (which is default) then generic costing mechanism is not used for methods of the corresponding type. (e.g. SInt, SLong) -
case class
CreateAvlTree(operationFlags: ByteValue, digest: Value[SByteArray], keyLength: IntValue, valueLengthOpt: Value[SIntOption]) extends AvlTreeValue with Product with Serializable
Construct a new authenticated dictionary with given parameters and tree root digest.
-
case class
CreateProveDHTuple(gv: Value[SGroupElement.type], hv: Value[SGroupElement.type], uv: Value[SGroupElement.type], vv: Value[SGroupElement.type]) extends SigmaPropValue with Product with Serializable
ErgoTree operation to create a new SigmaProp value representing public key of Diffie Hellman signature protocol.
ErgoTree operation to create a new SigmaProp value representing public key of Diffie Hellman signature protocol. Common input: (g,h,u,v)
-
case class
CreateProveDlog(value: Value[SGroupElement.type]) extends SigmaPropValue with Product with Serializable
ErgoTree operation to create a new SigmaProp value representing public key of discrete logarithm signature protocol.
-
case class
DecodePoint(input: Value[SByteArray]) extends Transformer[SByteArray, SGroupElement.type] with NotReadyValueGroupElement with Product with Serializable
Convert SByteArray to SGroupElement using CryptoConstants.dlogGroup.curve.decodePoint(bytes)
-
case class
Downcast[T <: SNumericType, R <: SNumericType](input: Value[T], tpe: R) extends Transformer[T, R] with Product with Serializable
Down cast for Numeric types
-
case class
EQ[S <: SType](left: Value[S], right: Value[S]) extends SimpleRelation[S] with Product with Serializable
Equals operation for SType todo: make EQ to really accept only values of the same type, now EQ(TrueLeaf, IntConstant(5)) is valid
- case class Exponentiate(left: Value[SGroupElement.type], right: Value[SBigInt.type]) extends TwoArgumentsOperation[SGroupElement.type, SBigInt.type, SGroupElement.type] with NotReadyValueGroupElement with Product with Serializable
-
case class
GE[T <: SType](left: Value[T], right: Value[T]) extends SimpleRelation[T] with Product with Serializable
Greater or equals operation for SInt
-
case class
GT[T <: SType](left: Value[T], right: Value[T]) extends SimpleRelation[T] with Product with Serializable
Greater operation for SInt
-
case class
If[T <: SType](condition: Value[SBoolean.type], trueBranch: Value[T], falseBranch: Value[T]) extends Quadruple[SBoolean.type, T, T, T] with Product with Serializable
If conditional function.
If conditional function. Non-lazy - evaluate both branches.
- condition
- condition to check
- trueBranch
- branch that will be used if condition is true
- falseBranch
- branch that will be used if condition is false
-
case class
LE[T <: SType](left: Value[T], right: Value[T]) extends SimpleRelation[T] with Product with Serializable
Less or equals operation for SInt
-
case class
LT[T <: SType](left: Value[T], right: Value[T]) extends SimpleRelation[T] with Product with Serializable
Less operation for SInt
- case class LogicalNot(input: Value[SBoolean.type]) extends NotReadyValueBoolean with Product with Serializable
- trait LogicalTransformerCompanion extends ValueCompanion
-
case class
LongToByteArray(input: Value[SLong.type]) extends Transformer[SLong.type, SByteArray] with NotReadyValueByteArray with Product with Serializable
Convert SLong to SByteArray
- trait MethodByNameUnapply extends STypeCompanion
-
case class
MethodIRInfo(irBuilder: Option[PartialFunction[(SigmaBuilder, SValue, SMethod, Seq[SValue], STypeSubst), SValue]]) extends Product with Serializable
Meta information connecting SMethod with ErgoTree.
Meta information connecting SMethod with ErgoTree.
- irBuilder
optional recognizer and ErgoTree node builder.
- case class ModQ(input: Value[SBigInt.type]) extends NotReadyValue[SBigInt.type] with Product with Serializable
- case class ModQArithOp(left: Value[SBigInt.type], right: Value[SBigInt.type], opCode: OpCode) extends NotReadyValue[SBigInt.type] with Product with Serializable
- abstract class ModQArithOpCompanion extends ValueCompanion
- case class MultiplyGroup(left: Value[SGroupElement.type], right: Value[SGroupElement.type]) extends TwoArgumentsOperation[SGroupElement.type, SGroupElement.type, SGroupElement.type] with NotReadyValueGroupElement with Product with Serializable
-
case class
NEQ[S <: SType](left: Value[S], right: Value[S]) extends SimpleRelation[S] with Product with Serializable
Non-Equals operation for SType
-
case class
Negation[T <: SNumericType](input: Value[T]) extends OneArgumentOperation[T, T] with Product with Serializable
Negation operation on numeric type T.
- trait NumericCastCompanion extends ValueCompanion
-
case class
OR(input: Value[SCollection[SBoolean.type]]) extends Transformer[SCollection[SBoolean.type], SBoolean.type] with NotReadyValueBoolean with Product with Serializable
OR logical conjunction
- sealed trait OneArgumentOperation[IV <: SType, OV <: SType] extends NotReadyValue[OV]
- trait OneArgumentOperationCompanion extends ValueCompanion
- trait OpGroup[C <: ValueCompanion] extends AnyRef
-
case class
OperationInfo(opDesc: Option[ValueCompanion], description: String, args: Seq[ArgInfo]) extends Product with Serializable
Meta information which can be attached to SMethod.
Meta information which can be attached to SMethod.
- description
human readable description of the method
- args
one item for each argument
- trait ProofTree extends Product
- trait ProofTreeConjecture extends ProofTree
- trait ProofTreeLeaf extends ProofTree
-
sealed
trait
Quadruple[IV1 <: SType, IV2 <: SType, IV3 <: SType, OV <: SType] extends NotReadyValue[OV]
A tree node with three descendants
- trait QuadrupleCompanion extends ValueCompanion
- sealed trait Relation[LIV <: SType, RIV <: SType] extends Triple[LIV, RIV, SBoolean.type] with NotReadyValueBoolean
- trait RelationCompanion extends ValueCompanion
- trait SCollection[T <: SType] extends SProduct with SGenericType
- case class SCollectionType[T <: SType](elemType: T) extends SCollection[T] with Product with Serializable
-
trait
SEmbeddable extends SType
Base trait for all embeddable types.
- case class SFunc(tDom: IndexedSeq[SType], tRange: SType, tpeParams: Seq[STypeParam] = Nil) extends SType with SGenericType with Product with Serializable
-
trait
SGenericType extends AnyRef
Base trait implemented by all generic types (those which has type parameters, e.g.
Base trait implemented by all generic types (those which has type parameters, e.g. Coll[T], Option[T], etc.)
- trait SLogical extends SType
-
case class
SMethod(objType: STypeCompanion, name: String, stype: SFunc, methodId: Byte, irInfo: MethodIRInfo, docInfo: Option[OperationInfo]) extends Product with Serializable
Method info including name, arg type and result type.
Method info including name, arg type and result type. Here stype.tDom - arg type and stype.tRange - result type.
methodId
should be unique among methods of the same objType. -
trait
SMonoType extends SType with STypeCompanion
Monomorphic type descriptor i.e.
Monomorphic type descriptor i.e. a type without generic parameters.
- See also
SGenericType
-
trait
SNumericType extends SProduct
Marker trait for all numeric types.
-
case class
SOption[ElemType <: SType](elemType: ElemType) extends SProduct with SGenericType with Product with Serializable
Type description of optional values.
Type description of optional values. Instances of
Option
are either constructed bySome
or byNone
constructors. -
trait
SPredefType extends SType
Base trait for all pre-defined types which are not necessary primitive (e.g.
Base trait for all pre-defined types which are not necessary primitive (e.g. Box, AvlTree).
-
trait
SPrimType extends SType with SPredefType
Base trait for all primitive types (aka atoms) which don't have internal type items.
Base trait for all primitive types (aka atoms) which don't have internal type items. All primitive types can occupy a reserved interval of codes from 1 to MaxPrimTypeCode.
-
trait
SProduct extends SType
Base trait for all types which have methods (and properties)
- case class STuple(items: IndexedSeq[SType]) extends SCollection[SAny.type] with Product with Serializable
-
sealed
trait
SType extends SigmaNode
Every type descriptor is a tree represented by nodes in SType hierarchy.
Every type descriptor is a tree represented by nodes in SType hierarchy. In order to extend type family: - Implement concrete class derived from SType - Implement serializer (see SCollectionSerializer) and register it in STypeSerializer.table Each SType is serialized to array of bytes by: - emitting typeCode of each node (see special case for collections below) - then recursively serializing subtrees from left to right on each level - for each collection of primitive type there is special type code to emit single byte instead of two bytes Types code intervals - (1 .. MaxPrimTypeCode) // primitive types - (CollectionTypeCode .. CollectionTypeCode + MaxPrimTypeCode) // collections of primitive types - (MaxCollectionTypeCode ..) // Other types Collection of non-primitive type is serialized as (CollectionTypeCode, serialize(elementType))
- case class STypeApply(name: String, args: IndexedSeq[SType] = IndexedSeq()) extends SType with Product with Serializable
-
trait
STypeCompanion extends AnyRef
Basic interface for all type companions.
Basic interface for all type companions. This is necessary to make distinction between concrete type descriptor of a type like Coll[Int] and generic descriptor of Coll[T] type constructor. Some simple types like Int, GroupElement inherit from both SType and STypeCompanion.
- See also
SInt, SGroupElement, SType
-
case class
STypeVar(name: String) extends SType with Product with Serializable
Type variable which is used in generic method/func signatures.
-
case class
SigmaAnd(items: Seq[SigmaPropValue]) extends SigmaTransformer[SigmaPropValue, SigmaPropValue] with Product with Serializable
AND conjunction for sigma propositions
-
trait
SigmaNode extends Product
Base type for all AST nodes of sigma lang.
-
trait
SigmaNodeCompanion extends AnyRef
Base type for all companions of AST nodes of sigma lang.
-
case class
SigmaOr(items: Seq[SigmaPropValue]) extends SigmaTransformer[SigmaPropValue, SigmaPropValue] with Product with Serializable
OR disjunction for sigma propositions
- trait SigmaProofOfKnowledgeTree[SP <: SigmaProtocol[SP], S <: SigmaProtocolPrivateInput[SP, _]] extends SigmaBoolean with SigmaProtocolCommonInput[SP]
- trait SigmaTransformer[IV <: SigmaPropValue, OV <: SigmaPropValue] extends SigmaPropValue
- trait SigmaTransformerCompanion extends ValueCompanion
- trait SimpleRelation[T <: SType] extends Relation[T, T]
-
case class
SubstConstants[T <: SType](scriptBytes: Value[SByteArray], positions: Value[SIntArray], newValues: Value[SCollection[T]]) extends NotReadyValueByteArray with Product with Serializable
Transforms serialized bytes of ErgoTree with segregated constants by replacing constants at given positions with new values.
Transforms serialized bytes of ErgoTree with segregated constants by replacing constants at given positions with new values. This operation allow to use serialized scripts as pre-defined templates. The typical usage is "check that output box have proposition equal to given script bytes, where minerPk (constants(0)) is replaced with currentMinerPk". Each constant in original scriptBytes have SType serialized before actual data (see ConstantSerializer). During substitution each value from newValues is checked to be an instance of the corresponding type. This means, the constants during substitution cannot change their types.
- scriptBytes
serialized ErgoTree with ConstantSegregationFlag set to 1.
- positions
zero based indexes in ErgoTree.constants array which should be replaced with new values
- newValues
new values to be injected into the corresponding positions in ErgoTree.constants array
- returns
original scriptBytes array where only specified constants are replaced and all other bytes remain exactly the same
-
case class
TreeLookup(tree: Value[SAvlTree.type], key: Value[SByteArray], proof: Value[SByteArray]) extends Quadruple[SAvlTree.type, SByteArray, SByteArray, SOption[SByteArray]] with Product with Serializable
Perform a lookup of key
key
in a tree with roottree
using proofproof
.Perform a lookup of key
key
in a tree with roottree
using proofproof
. Throws exception if proof is incorrect Return Some(bytes) of leaf with keykey
if it exists Return None if leaf with provided key does not exist. -
sealed
trait
Triple[LIV <: SType, RIV <: SType, OV <: SType] extends NotReadyValue[OV]
A tree node with left and right descendants
-
abstract
class
TrivialProp extends SigmaBoolean with Product1[Boolean]
Represents boolean values (true/false) in SigmaBoolean tree.
Represents boolean values (true/false) in SigmaBoolean tree. Participates in evaluation of CAND, COR, THRESHOLD connectives over SigmaBoolean values. See CAND.normalized, COR.normalized and AtLeast.reduce.
- trait TwoArgumentOperationCompanion extends ValueCompanion
- sealed trait TwoArgumentsOperation[LIV <: SType, RIV <: SType, OV <: SType] extends Triple[LIV, RIV, OV]
- trait UncheckedConjecture extends UncheckedSigmaTree with ProofTreeConjecture
- case class UncheckedDiffieHellmanTuple(proposition: ProveDHTuple, commitmentOpt: Option[FirstDiffieHellmanTupleProverMessage], challenge: Challenge, secondMessage: SecondDiffieHellmanTupleProverMessage) extends UncheckedLeaf[ProveDHTuple] with Product with Serializable
- trait UncheckedLeaf[SP <: SigmaBoolean] extends UncheckedSigmaTree with ProofTreeLeaf
- case class UncheckedSchnorr(proposition: ProveDlog, commitmentOpt: Option[FirstDLogProverMessage], challenge: Challenge, secondMessage: SecondDLogProverMessage) extends UncheckedLeaf[ProveDlog] with Product with Serializable
- sealed trait UncheckedSigmaTree extends UncheckedTree
- sealed trait UncheckedTree extends ProofTree
- sealed trait UnprovenConjecture extends UnprovenTree with ProofTreeConjecture
- case class UnprovenDiffieHellmanTuple(proposition: ProveDHTuple, commitmentOpt: Option[FirstDiffieHellmanTupleProverMessage], randomnessOpt: Option[BigInteger], challengeOpt: Option[Challenge] = None, simulated: Boolean) extends UnprovenLeaf with Product with Serializable
- sealed trait UnprovenLeaf extends UnprovenTree with ProofTreeLeaf
- case class UnprovenSchnorr(proposition: ProveDlog, commitmentOpt: Option[FirstDLogProverMessage], randomnessOpt: Option[BigInteger], challengeOpt: Option[Challenge] = None, simulated: Boolean) extends UnprovenLeaf with Product with Serializable
- sealed trait UnprovenTree extends ProofTree
-
case class
Upcast[T <: SNumericType, R <: SNumericType](input: Value[T], tpe: R) extends Transformer[T, R] with Product with Serializable
Up cast for Numeric types
-
case class
Xor(left: Value[SByteArray], right: Value[SByteArray]) extends TwoArgumentsOperation[SByteArray, SByteArray, SByteArray] with NotReadyValueByteArray with Product with Serializable
XOR for two SByteArray
-
case class
XorOf(input: Value[SCollection[SBoolean.type]]) extends Transformer[SCollection[SBoolean.type], SBoolean.type] with NotReadyValueBoolean with Product with Serializable
Similar to allOf, but performing logical XOR operation instead of
&&
Value Members
-
def
Divide[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
SInt division
- def Max[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
- def Min[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
-
def
Minus[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
SInt subtraction
- def MinusModQ(left: Value[SBigInt.type], right: Value[SBigInt.type]): Value[SBigInt.type]
-
def
Modulo[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
SInt modulo
-
def
Multiply[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
SInt multiplication
-
def
Plus[T <: SNumericType](left: Value[T], right: Value[T]): Value[T]
SInt addition
- def PlusModQ(left: Value[SBigInt.type], right: Value[SBigInt.type]): Value[SBigInt.type]
- object AND extends LogicalTransformerCompanion with Serializable
- object ArithOp extends Serializable
- object AtLeast extends ValueCompanion with Serializable
- object AvlTreeData extends Serializable
- object AvlTreeFlags extends Serializable
- object BinAnd extends RelationCompanion with Serializable
- object BinOr extends RelationCompanion with Serializable
- object BinXor extends RelationCompanion with Serializable
- object BitInversion extends OneArgumentOperationCompanion with Serializable
- object BitOp extends Serializable
- object BoolToSigmaProp extends ValueCompanion with Serializable
- object ByteArrayToBigInt extends SimpleTransformerCompanion with Serializable
- object ByteArrayToLong extends SimpleTransformerCompanion with Serializable
- object CAND extends Serializable
- object COR extends Serializable
- object CalcBlake2b256 extends SimpleTransformerCompanion with Serializable
- object CalcSha256 extends SimpleTransformerCompanion with Serializable
- object ConjectureType extends Enumeration
- object CreateAvlTree extends ValueCompanion with Serializable
- object CreateProveDHTuple extends ValueCompanion with Serializable
- object CreateProveDlog extends ValueCompanion with Serializable
- object DecodePoint extends SimpleTransformerCompanion with Serializable
- object Downcast extends NumericCastCompanion with Serializable
- object EQ extends RelationCompanion with Serializable
- object EcPointFunctions
- object Exponentiate extends TwoArgumentOperationCompanion with Serializable
-
object
FiatShamirTree
Prover Step 7: Convert the tree to a string s for input to the Fiat-Shamir hash function.
Prover Step 7: Convert the tree to a string s for input to the Fiat-Shamir hash function. The conversion should be such that the tree can be unambiguously parsed and restored given the string. For each non-leaf node, the string should contain its type (OR or AND). For each leaf node, the string should contain the Sigma-protocol statement being proven and the commitment. The string should not contain information on whether a node is marked "real" or "simulated", and should not contain challenges, responses, or the real/simulated flag for any node.
- object GE extends RelationCompanion with Serializable
- object GT extends RelationCompanion with Serializable
- object If extends QuadrupleCompanion with Serializable
- object LE extends RelationCompanion with Serializable
- object LT extends RelationCompanion with Serializable
- object LogicalNot extends ValueCompanion with Serializable
- object LongToByteArray extends SimpleTransformerCompanion with Serializable
- object ModQ extends ValueCompanion with Serializable
- object ModQArithOp extends OpGroup[ModQArithOpCompanion] with Serializable
- object MultiplyGroup extends TwoArgumentOperationCompanion with Serializable
- object NEQ extends RelationCompanion with Serializable
- object Negation extends OneArgumentOperationCompanion with Serializable
- object NoProof extends UncheckedTree with Product with Serializable
-
object
NoType extends SType with Product with Serializable
Special type to represent untyped values.
Special type to represent untyped values. Interpreter raises an error when encounter a Value with this type. All Value nodes with this type should be elimitanted during typing. If no specific type can be assigned statically during typing, then either error should be raised or type SAny should be assigned which is interpreted as dynamic typing.
- object OR extends LogicalTransformerCompanion with Serializable
- object OperationInfo extends Serializable
-
object
Operations
WARNING: This file is generated by GenInfoObjects tool.
WARNING: This file is generated by GenInfoObjects tool. Don't edit it directly, use the tool instead to regenerate. The operations are alphabetically sorted.
-
object
SAny extends SPrimType with Product with Serializable
Any other type is implicitly subtype of this type.
- object SAvlTree extends SProduct with SPredefType with SMonoType with Product with Serializable
-
object
SBigInt extends SPrimType with SEmbeddable with SNumericType with SMonoType with Product with Serializable
Type of 256 bit integet values.
Type of 256 bit integet values. Implemented using java.math.BigInteger.
- object SBoolean extends SPrimType with SEmbeddable with SLogical with SProduct with SMonoType with Product with Serializable
- object SBox extends SProduct with SPredefType with SMonoType with Product with Serializable
- object SByte extends SPrimType with SEmbeddable with SNumericType with SMonoType with Product with Serializable
- object SCollection extends STypeCompanion with MethodByNameUnapply
- object SCollectionType extends Serializable
- object SContext extends SProduct with SPredefType with SMonoType with Product with Serializable
- object SFunc extends Serializable
-
object
SGlobal extends SProduct with SPredefType with SMonoType with Product with Serializable
This type is introduced to unify handling of global and non-global (i.e.
This type is introduced to unify handling of global and non-global (i.e. methods) operations. It unifies implementation of global operation with implementation of methods and avoids code duplication (following DRY principle https://en.wikipedia.org/wiki/Don%27t_repeat_yourself). The WrappedType is
special.sigma.SigmaDslBuilder
, which is an interface implemented by the singleton sigmastate.eval.CostingSigmaDslBuilderThe Constant(...) tree node of this type are not allowed, as well as using it in register and context variables (aka ContextExtension)
When new methods are added to this type via a soft-fork, they will be serialized as part of ErgoTree using MethodCallSerializer, where SGlobal.typeCode will be used.
- See also
sigmastate.lang.SigmaPredef
-
object
SGroupElement extends SProduct with SPrimType with SEmbeddable with SMonoType with Product with Serializable
NOTE: this descriptor both type and type companion
- object SHeader extends SProduct with SPredefType with SMonoType with Product with Serializable
- object SInt extends SPrimType with SEmbeddable with SNumericType with SMonoType with Product with Serializable
- object SLong extends SPrimType with SEmbeddable with SNumericType with SMonoType with Product with Serializable
- object SMethod extends Serializable
- object SNumericType extends STypeCompanion
- object SOption extends STypeCompanion with Serializable
- object SPreHeader extends SProduct with SPredefType with SMonoType with Product with Serializable
-
object
SPrimType
Primitive type recognizer to pattern match on TypeCode
- object SShort extends SPrimType with SEmbeddable with SNumericType with SMonoType with Product with Serializable
- object SSigmaProp extends SProduct with SPrimType with SEmbeddable with SLogical with SMonoType with Product with Serializable
-
object
SString extends SProduct with SMonoType with Product with Serializable
NOTE: this descriptor both type and type companion
- object STuple extends STypeCompanion with Serializable
- object SType
- object STypeApply extends Serializable
- object STypeVar extends Serializable
-
object
SUnit extends SPrimType with Product with Serializable
The type with single inhabitant value
()
- object SigSerializer
- object SigmaAnd extends SigmaTransformerCompanion with Serializable
- object SigmaOr extends SigmaTransformerCompanion with Serializable
- object SubstConstants extends ValueCompanion with Serializable
- object TreeLookup extends QuadrupleCompanion with Serializable
- object TrivialProp
- object Upcast extends NumericCastCompanion with Serializable
- object Values
- object Xor extends TwoArgumentOperationCompanion with Serializable
- object XorOf extends LogicalTransformerCompanion with Serializable