All Classes

Class	Description
AArrayBlob	Abstract base class for binary data stored in Java arrays.
ABlob	Abstract base class for data objects containing immutable chunks of binary data.
ABlobMap<K extends ABlob,V extends ACell>	Abstract base class for a sorted radix-tree map of Blobs to values.
AccountKey	Immutable class representing an Ed25519 Public Key for an Account
AccountStatus	Class representing the current on-chain status of an account.
ACell	Abstract base class for Cells.
AClosure<T extends ACell>	Abstract base class for functions that can close over a lexical environment.
ACollection<T extends ACell>	Abstract base class for Persistent Merkle Collections
ACountable<E extends ACell>	Abstract base class for Countable objects.
ADataFn<T extends ACell>	Abstract base class for data structure lookup functions.
ADataStructure<E extends ACell>	Abstract base class for Persistent data structures.
Address	Immutable class representing an Address, generally used to uniquely identify an Account.
AddressType	Type that represents CVM Byte values
AExceptional	Abstract base class for exceptional return values.
AFn<T extends ACell>	Base class for functions expressed as values "You know what's web-scale? The Web.
AHashMap<K extends ACell,V extends ACell>
AHashSet<T extends ACell>
AInitConfig
AKeyPair	Abstract base class for key pairs in Convex.
AList<T extends ACell>	Abstract base class for lists.
ALongBlob
AMap<K extends ACell,V extends ACell>	Abstract base class for maps.
AMapEntry<K extends ACell,V extends ACell>
AMultiOp<T extends ACell>	Abstract base class for Ops with multiple nested operations MultiOps may selectively evaluate sub-expressions.
AntlrReader
AntlrReader.CRListener
ANumericBlob	Base class for Blobs which represent an integral numeric value
ANumericType<T extends APrimitive>
Any	Type that represents any CVM value
AObject
AOp<T extends ACell>	Abstract base class for CVM operations "...that was the big revelation to me when I was in graduate school—when I finally understood that the half page of code on the bottom of page 13 of the Lisp 1.5 manual was Lisp in itself.
APrimitive	Abstract base class for small CVM primitive values.
ARecord	Base class for record data types.
ARecordGeneric	Abstract base class for generic records.
AReturn	Abstract base class for exceptional returns
ASequence<T extends ACell>	Abstract base class for persistent lists and vectors
ASet<T extends ACell>	Abstract based class for sets.
ASignature	Class representing a cryptographic signature
AStandardType<T extends ACell>	Base type for standard types mapped directly to a branch of ACell hierarchy
AStore	Abstract base class for object storage subsystems "The perfect kind of architecture decision is the one which never has to be made" ― Robert C.
AString	Class representing a CVM String
ASymbolic	Abstract based class for symbolic objects (Keywords, Symbols)
ATrampoline	Abstract base class for trampolining function return values
ATransaction	Abstract base class for immutable transactions Transactions may modify the on-chain State according to the rules of the specific transaction type.
AType	Abstract base class for CVM value types
AVector<T extends ACell>	Abstract base class for vectors.
BadFormatException	Class representing errors in format encountered when trying to read data from a serialised form.
BadSignatureException
BaseException	Abstract base class for exceptions that we expect to encounter and need to handle.
Belief	Class representing a Peer's view of the overall network consensus state.
Bits	Static utility function for bitwise functions
Blob	General purpose immutable wrapper for byte array data.
Blob	Type that represents any Blob
BlobBuilder	Similar to Java StringBuilder designed for adding small Blobs
BlobCache	In-memory cache for Blob decoding.
BlobMap<K extends ABlob,V extends ACell>	BlobMap node implementation supporting: An optional prefix string An optional entry with this prefix Up to 16 child entries at the next level of depth
BlobMaps
BlobMapType	Type that represents any CVM map
Blobs
BlobTree	Implementation of a large Blob data structure consisting of 2 or more chunks.
Block	A Block contains an ordered collection of signed transactions that may be applied collectively as part of a state update.
BlockResult	Class representing the result of applying a Block to a State.
Boolean	Type that represents CVM Long values
Byte	Type that represents CVM Byte values
Call	Transaction representing a Call to an Actor.
CharacterType	Type that represents CVM Byte values
Coin	Static Constants for Coin sizes and total supply
Collection	Type that represents any CVM collection
Compiler	Compiler class responsible for transforming forms (code as data) into an Op tree for execution.
Cond<T extends ACell>	Op representing a conditional expression.
Constant<T extends ACell>	Operation representing a constant value "One man's constant is another man's variable." - Alan Perlis
Constants	Static class for global configuration constants that affect protocol behaviour
Context<T extends ACell>	Representation of CVM execution context.
Context.CompilerState	Inner class compiler state.
ConvexBaseListener	This class provides an empty implementation of ConvexListener, which can be extended to create a listener which only needs to handle a subset of the available methods.
ConvexLexer
ConvexListener	This interface defines a complete listener for a parse tree produced by ConvexParser.
ConvexParser
ConvexParser.AddressContext
ConvexParser.BlobContext
ConvexParser.BoolContext
ConvexParser.CharacterContext
ConvexParser.CommentedContext
ConvexParser.DataStructureContext
ConvexParser.DoubleValueContext
ConvexParser.FormContext
ConvexParser.FormsContext
ConvexParser.KeywordContext
ConvexParser.ListContext
ConvexParser.LiteralContext
ConvexParser.LongValueContext
ConvexParser.MapContext
ConvexParser.NilContext
ConvexParser.PathSymbolContext
ConvexParser.QuotedContext
ConvexParser.SetContext
ConvexParser.SingleFormContext
ConvexParser.SpecialLiteralContext
ConvexParser.StringContext
ConvexParser.SymbolContext
ConvexParser.SyntaxContext
ConvexParser.VectorContext
Core	This class builds the core runtime environment at startup.
CoreFn<T extends ACell>	Abstract base class for core language functions implemented in the Runtime Core functions are tagged using their symbols in on-chain representation
CorePred	Abstract base class for core predicate functions
Counters	Some event counters, for debugging and general metrics
CVMBool	Class for CVM Boolean types.
CVMByte	Class for CVM Byte instances.
CVMChar	Class for CVM Character values.
CVMDouble	Class for CVM double floating-point values.
CVMLong	Class for CVM long values.
DataStructure	Type that represents any CVM sequence
Def<T extends ACell>	Op that creates a definition in the current environment.
Do<T extends ACell>	Op for executing a sequence of child operations in order "Design is to take things apart in such a way that they can be put back together" - Rich Hickey
Double	Type that represents CVM Double values
Economics	Utility function for Convex Cryptoeconomics
Ed25519KeyPair	Class representing an Ed25519 Key Pair
Ed25519Signature	Immutable data value class representing an Ed25519 digital signature.
Encoding	Class for crypto encoding constants
ErrorCodes	Standard codes used for CVM Exceptional Conditions.
Errors	Utility class for generating appropriate error messages "I keep a list of all unresolved bugs I've seen on the forum.
ErrorValue	Class representing an Error value produced by the CVM.
Etch	A stupid, fast database for immutable data you want carved in stone.
EtchStore	Class implementing on-disk memory-mapped storage of Convex data.
Fn<T extends ACell>	Value class representing a instantiated closure / lambda function.
Format	Static utility class for message format encoding "Standards are always out of date.
Function	Type that represents any CVM collection
HaltValue<T extends ACell>	Class representing a halt return value "Computers are useless.
Hash	Class used to represent an immutable 32-byte Hash value.
Hashing	Class for static Hashing functionality
Huge	A 128-bit integer
IAssociative<K extends ACell,V extends ACell>	Interface for associative data structures
ICoreDef	Interface for objects that act as definitions in the core environment.
IFn<T extends ACell>	Interface for invokable objects with function interface.
Init	Static class for generating the initial Convex State "The beginning is the most important part of the work." - Plato, The Republic
InsecureRandom	A SecureRandom instance that returns deterministic values given an initial seed.
INumeric	Interface for CVM Numeric types
InvalidDataException	Class representing errors encountered during data validation.
Invoke<T extends ACell>	Op representing the invocation of a function.
Invoke	Transaction class representing the Invoke of an on-chain operation.
IRefFunction	Functional interface for operations on Cell Refs that may throw a MissingDataException In general, IRefFunction is used to provide a visitor for data objects containing nested Refs.
IValidated	Interface for classes that can be validated
IWriteable
Juice	Static class defining juice costs for executable operations.
Keyword	Keyword data type.
KeywordFn<T extends ACell>
Keywords	Static Keyword values for configuration maps, records etc.
KeywordType	Type that represents CVM Byte values
Lambda<T extends ACell>	Op responsible for creating a new function (closure).
Let<T extends ACell>	Op for executing a body after lexically binding one or more symbols.
List<T extends ACell>	Implementation of a list wrapping a vector.
List	Type that represents any CVM collection
Lists
Local<T extends ACell>	Op to look up a local value from the lexical environment
Long	Type that represents CVM Long values
LongBlob	Wrapper for an 8-byte long as a Blob We use this mainly for efficient management of indexes using Longs in BlobMaps.
Lookup<T extends ACell>	Op to look up a Symbol in the current execution context.
Map	Type that represents any CVM map
MapEntry<K extends ACell,V extends ACell>	Map.Entry implementation for persistent maps.
MapFn<K extends ACell,T extends ACell>
MapLeaf<K extends ACell,V extends ACell>	Limited size Persistent Merkle Map implemented as a small sorted list of Key/Value pairs Must be sorted by Key hash value to ensure uniqueness of representation
Maps	Utility class for map functions
MapTree<K extends ACell,V extends ACell>	Persistent Map for large hash maps requiring tree structure.
MemoryStore	Class implementing caching and storage of hashed node data Persists refs as direct refs, i.e.
MergeContext	Class representing the context to be used for a Belief merge/update function.
MergeFunction<V>
MissingDataException	Exception thrown when an attempt is made to dereference a value that is not present in the current data store.
Mnemonic	Static utility functions for Mnemonic encoding
MultiFn<T extends ACell>
Nil	The Type representing the single value 'nil'
Number
OpCode	Type that represents CVM Long values
Ops	Static utility class for coded operations.
Order	Class representing an Ordering of transactions, along with the consensus position.
ParseException	Class for reader parse exceptions
PBE
Peer	Immutable class representing the encapsulated state of a Peer
PeerStatus	Class describing the on-chain state of a Peer declared on the network.
PEMTools
PFXTools
Providers
Query<T extends ACell>	Op for executing a sequence of child operations in order "Design is to take things apart in such a way that they can be put back together" - Rich Hickey
Reader	Parboiled Parser implementation which reads source code and produces a tree of parsed objects.
ReaderUtils
Record	Type that represents any CVM collection
RecordFormat
RecurValue	Class representing a function return value.
Reduced
Ref<T extends ACell>	Class representing a smart reference to a decentralised data value.
RefDirect<T extends ACell>	Ref subclass for direct in-memory references.
RefSoft<T extends ACell>	Reference class implemented via a soft reference and store lookup.
Result	Class representing the result of a Query or Transaction.
ReturnValue<T extends ACell>	Class representing a function return value "Computers are useless.
RollbackValue<T extends ACell>	Class representing a function return value "Computers are useless.
RT	Static utility class for Runtime functions.
SeqFn<T extends ACell>	Wrapper for interpreting a sequence object as an invokable function
Sequence	Type that represents any CVM sequence
Set	Type that represents any CVM collection
Set<T extends ACell>	Op to set a lexical value in the local execution context.
SetFn<T extends ACell>
SetLeaf<T extends ACell>	Limited size Persistent Merkle Set implemented as a small sorted list of Values Must be sorted by Key hash value to ensure uniqueness of representation
Sets
SetTree<T extends ACell>	Persistent Set for large hash sets requiring tree structure.
Shutdown	So the JVM doesn't give us a nice way to run shutdown hooks in a defined order.
SignedData<T extends ACell>	Node representing a signed data object.
Special<T extends ACell>
State	Class representing the immutable state of the CVM State transitions are represented by blocks of transactions, according to the logic: s[n+1] = s[n].applyBlock(b[n]) State contains the following elements - Map of AccountStatus for every Address - Map of PeerStatus for every Peer Address - Global values - Schedule data structure "State.
Stores
Strings
StringShort	Class representing a short CVM string.
StringSlice	AString subclass representing a subsequence of some Blob data
StringTree
StringType	Type that represents CVM Byte values
Symbol	Class representing a Symbol.
Symbols	Static class for Symbol constants.
SymbolType	Type that represents CVM Byte values
Symmetric	Class providing symmetric encryption functionality using AES
Syntax	Class representing a Syntax Object.
SyntaxType	Type that represents CVM Syntax Object values
Tag	Class containing constant Tag values.
TailcallValue	Class representing a function return value.
Text
TODOException
Transaction
Transfer	Transaction class representing a coin Transfer from one account to another
Types	Static base class for Type system functionality NOTE: Currently Types are not planned for support in 1.0 runtime, but included here to support testing
UMath	Functions for unsigned maths.
Utils
ValidationException	Class representing a validation failure
Vector	Type that represents any CVM collection
VectorArray<T extends ACell>	Experimental: implementation of AVector backed by a Java array for temporary usage purposes.
VectorLeaf<T extends ACell>	A Persistent Vector implementation representing 0-16 elements with a packed Vector prefix.
Vectors
VectorTree<T extends ACell>	Persistent Vector implemented as a merkle tree of chunks shift indicates the level of the tree: 4 = 1st level, 8 = second etc.
Wallet
WalletEntry	Class implementing a Wallet Entry.