All Classes and Interfaces
Class
Description
Abstract base class for binary data stored in Java arrays.
Abstract base class for data objects containing immutable chunks of binary
data.
Abstract base class for BlobMaps: a sorted radix-tree map of Blobs to Values.
Immutable class representing an Ed25519 Public Key for an Account
Class representing the current on-chain status of an account.
Abstract base class for Cells.
Abstract base class for functions that can close over a lexical environment.
Abstract base class for Persistent Merkle Collections
Abstract base class for Countable objects.
Abstract base class for data structure lookup functions.
Abstract base class for Persistent data structures.
Immutable class representing an Address, generally used to uniquely identify an Account.
Type that represents CVM Byte values
Abstract base class for exceptional return values.
Base class for functions expressed as values
"You know what's web-scale? The Web.
Abstract base class for key pairs in Convex.
Abstract base class for lists.
Abstract base class for maps.
Abstract base class for Ops with multiple nested operations
MultiOps may selectively evaluate sub-expressions.
Type that represents any CVM value
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.
Abstract base class for small CVM primitive values.
Base class for Record data types.
Abstract base class for generic records.
Abstract base class for exceptional returns
Abstract base class for concrete sequential data structure (immutable persistent lists and vectors etc.)
Abstract based class for sets.
Class representing a cryptographic signature
Base type for standard types mapped directly to a branch of ACell hierarchy
Abstract base class for object storage subsystems
"The perfect kind of architecture decision is the one which never has to be
made" ― Robert C.
Class representing a CVM String.
Abstract based class for symbolic objects (Keywords, Symbols)
Abstract base class for trampolining function return values
Abstract base class for immutable transactions
Transactions may modify the on-chain State according to the rules of the
specific transaction type.
Abstract base class for CVM value types
Abstract base class for vectors.
Class representing errors in format encountered when trying to read data from
a serialised form.
Abstract base class for exceptions that we expect to encounter and need to
handle.
Class representing a Peer's view of the overall network consensus state.
Static utility function for bitwise functions
General purpose immutable wrapper for byte array data.
Type that represents any Blob
Similar to Java StringBuilder designed for concatenating multiple small Blobs to produce a larger
Blob.
In-memory cache for Blob decoding.
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
Type that represents any CVM map
Implementation of a large Blob data structure consisting of 2 or more chunks.
A Block contains an ordered collection of signed transactions that may be applied
collectively as part of a state update.
Class representing the result of applying a Block to a State.
Type that represents CVM Long values
Type that represents CVM Byte values
Transaction representing a Call to an Actor.
Type that represents CVM Byte values
Static Constants for Coin sizes and total supply
Type that represents any CVM collection
Compiler class responsible for transforming forms (code as data) into an
Op tree for execution.
Op representing a conditional expression.
Operation representing a constant value
"One man's constant is another man's variable." - Alan Perlis
Static class for global configuration constants that affect protocol
behaviour
Representation of CVM execution context.
Inner class compiler state.
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.This interface defines a complete listener for a parse tree produced by
ConvexParser.This class builds the core runtime environment at startup.
Abstract base class for core language functions implemented in the Runtime
Core functions are tagged using their symbols in on-chain representation
Abstract base class for core predicate functions
Some event counters, for debugging and general metrics
Class for CVM Boolean types.
Class for CVM Byte instances.
Class for CVM Character values.
Class for CVM double floating-point values.
Class for CVM long values.
Type that represents any CVM sequence
Op that creates a definition in the current environment.
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
Type that represents CVM Double values
Utility function for Convex Cryptoeconomics
Class representing an Ed25519 Key Pair
Immutable data value class representing an Ed25519 digital signature.
Class for crypto encoding constants
Standard codes used for CVM Exceptional Conditions.
Utility class for generating appropriate error messages
"I keep a list of all unresolved bugs I've seen on the forum.
Class representing an Error value produced by the CVM.
A stupid, fast database for immutable data you want carved in stone.
Class implementing on-disk memory-mapped storage of Convex data.
Value class representing a instantiated closure / lambda function.
Static utility class for message format encoding
"Standards are always out of date.
Type that represents any CVM collection
Class representing a halt return value
"Computers are useless.
Class used to represent an immutable 32-byte Hash value.
Class for static Hashing functionality
A 128-bit integer
Interface for associative data structures
Interface for objects that act as definitions in the core environment.
Interface for invokable objects with function interface.
Static class for generating the initial Convex State
"The beginning is the most important part of the work." - Plato, The Republic
A SecureRandom instance that returns deterministic values given an initial seed.
Interface for CVM Numeric types
Class representing errors encountered during data validation.
Op representing the invocation of a function.
Transaction class representing the Invoke of an on-chain operation.
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.
Interface for classes that can be validated
Static class defining juice costs for executable operations.
Keyword data type.
Static Keyword values for configuration maps, records etc.
Type that represents CVM Byte values
Op responsible for creating a new function (closure).
Op for executing a body after lexically binding one or more symbols.
Implementation of a list wrapping a vector.
Type that represents any CVM collection
Op to look up a local value from the lexical environment
Type that represents CVM Long values
Wrapper for an 8-byte long as a Blob
We use this mainly for efficient management of indexes using Longs in BlobMaps.
Op to look up a Symbol in the current execution context.
Type that represents any CVM map
Map.Entry implementation for persistent maps.
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
Utility class for map functions
Persistent Map for large hash maps requiring tree structure.
Class implementing caching and storage of hashed node data
Persists refs as direct refs, i.e.
Class representing the context to be used for a Belief merge/update function.
Exception thrown when an attempt is made to dereference a value that is not
present in the current data store.
Static utility functions for Mnemonic encoding
The Type representing the single value 'nil'
Type that represents CVM Long values
Static utility class for coded operations.
Class representing an Ordering of transactions, along with the consensus position.
Class for parse exceptions
Immutable class representing the encapsulated state of a Peer
Class describing the on-chain state of a Peer declared on the network.
Utility class for working with Java Key Stores
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
Parboiled Parser implementation which reads source code and produces a tree
of parsed objects.
Type that represents any CVM collection
Class representing a function return value.
Class representing a smart reference to a decentralised data value.
Ref subclass for direct in-memory references.
Reference class implemented via a soft reference and store lookup.
Class representing the result of a Query or Transaction.
Class representing a function return value
"Computers are useless.
Class representing a function return value
"Computers are useless.
Static utility class for Runtime functions.
Wrapper for interpreting a sequence object as an invokable function
Type that represents any CVM sequence
Type that represents any CVM collection
Op to set a lexical value in the local execution context.
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
Persistent Set for large hash sets requiring tree structure.
So the JVM doesn't give us a nice way to run shutdown hooks in a defined order.
Node representing a signed data object.
Op representing special Symbols like *address* and *caller*
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.
Class representing a short CVM string, backed by a flat Blob
USed for most small strings, and acts as the leaf chunk for StringTrees
AString subclass representing a subsequence of some Blob data
Type that represents CVM Byte values
Class representing a Symbol.
Static class for Symbol constants.
Type that represents CVM Byte values
Class providing symmetric encryption functionality using AES
Class representing a Syntax Object.
Type that represents CVM Syntax Object values
Class containing constant Tag values.
Class representing a function return value.
Transaction class representing a coin Transfer from one account to another
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
Functions for unsigned maths.
Class representing a validation failure
Type that represents any CVM collection
Experimental: implementation of AVector backed by a Java array for temporary usage purposes.
Similar to Java StringBuilder designed for concatenating multiple small Vectors to produce a larger
Vector.
A Persistent Vector implementation representing 0-16 elements with a
packed Vector prefix.
Static utility functions for working with Vectors
Persistent Vector implemented as a merkle tree of chunks
shift indicates the level of the tree: 4 = 1st level, 8 = second etc.
Class implementing a Wallet Entry.