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 Blob-like objects, which conceptually behave as a sequence of bytes.
Abstract base class for Byte Flags
0xb0 to 0xbf in CAD3 encoding
Abstract base class for stores implementing an in-memory cache of cells
Abstract base class for non-CVM CAD3 Records values.
Immutable class representing an Ed25519 public key.
Class representing the current on-chain status of an account.
Abstract base class for Cells in CAD3 data format.
Abstract base class for Persistent Merkle Collections
Abstract base class for Countable objects, supporting `count`, `nth`, `empty?
Abstract base class for CVM code constructs
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 dense records CAD3 types 0xD0 - 0xDF
Abstract base class for encoders, which convert data to / from Blob instances
Abstract base class for exceptional return values.
Abstract base class for 8-byte bloblike extension Values such as Address and CAD Extension Values 0xE0 - 0xEF
Abstract base class for ops encoded as dense records of ops
Base class for functions expressed as values
"You know what's web-scale?
Base class for Convex-specific formats.
Abstract base class for Indexes: a sorted radix-tree map of Blobs to Values.
Abstract base class for CVM Integer values
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.
BAse class for CVM numeric types
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 CVM primitive values.
Abstract base class for Custom Convex security providers
Base class for CVM 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 class for sparse records, implementing CAD3 tags 0xA0-0xAF
BAse class for specialised vector implementations
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.
Abstract base 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.
Base class for wallet implementations.
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.
Class representing the context to be used for a Belief merge/update function.
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.
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
Class implementing the CAD3 extended byte flags `0xB2` to `0xBF`
Base Encoder for CAD3 data / stores.
Type for CAD3 Values not recognised by CVM
Transaction representing a Call to an Actor.
Static utility class for dealing with cells
Type that represents CVM Byte values
Static utilities and functions for CVM code generation
In general, these are helper functions which:
- Abstract away from complexity and specific details of code generation
- Are more efficient than most alternative approaches e.g. going via the Reader
Static Constants for Coin sizes and total supply
These denominations are intended to provide more sensible human-scale units for better understanding.
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.
Immutable inner class for less-frequently changing CVM state
Should save some allocation / GC on average, since it will change less
frequently than the surrounding Context and can be cheaply copied by reference.
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 class provides an empty implementation of
ConvexVisitor,
which can be extended to create a visitor 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 interface defines a complete generic visitor for a parse tree produced
by
ConvexParser.This class builds the core runtime environment at startup.
Some event counters, for debugging and general metrics
Arbitrary precision Integer implementation for the CVM.
Class for CVM Boolean types.
Class for CVM Character values.
Class for CVM double floating-point values.
Encoder for CVM values and data structures
Class for CVM long values.
Class defining tags for CVM CAD3 extension types
Type that represents any CVM sequence
Op that creates a definition in the current environment.
Base class for Data Lattice FileSystems.
Static API for DLFS
Static utility class for working with DLFS Node structures
DLFS filesystem provider.
A DLFS Path
Path components are Strings, separated by "/"
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
Immutable data value class representing an Ed25519 digital signature.
Class for crypto encoding constants and utility functions
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.
An Etch validator that checks every index entry
Exceptional value representing a CVM condition the CVM should not catch in user code
Typically unrecoverable failure, e.g.
Generic file handling utilities.
Static utility class for CAD3 encoding format
"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
Class implementing a Hot Wallet Entry.
Interface for associative data structures
Visitor for Etch index
Interface for invokable objects with function interface.
Index node implementation, providing an efficient radix tree based immutable data structure for indexed access and sorting.
Type that represents any CVM map
Static class for generating the initial Convex Genesis 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.
Type that represents CVM Integer values of arbitrary length
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
This class provides an empty implementation of
JSONListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
JSONVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.This interface defines a complete listener for a parse tree produced by
JSONParser.Static utility class for some standard JSON utility functions
Note than JSON is a strict subset of CAD3 data, so we expect to encode all valid JSON perfectly in CAD3 / CVM data structures
This interface defines a complete generic visitor for a parse tree produced
by
JSONParser.Static class defining juice costs for executable operations.
Class implementing a Hot Wallet Entry.
Keyword data type.
Static intenral Keyword values for configuration maps, records etc.
Type that represents CVM Byte values
Op responsible for creating a new function (closure).
Non-blocking Queue implementation that overwrites the queued item in a non-blocking manner.
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
lightweight load monitor class.
Op to look up a local value from the lexical environment
Constants and utility functions for CVM log
See CAD33
Type that represents CVM Long values
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 direct in-memory caching and storage of hashed node data.
Class representing a message to / from a network participant
Constant tags used to identify general purpose messages
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 Multi class enables multiple child transactions to be grouped into a single
wrapper transaction with useful joint execution semantics.
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 representing an unexpected error that should halt the system
Should not usually be caught
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
Utility class for handling crypto providers for Convex.
Op for executing a sequence of child operations in order in query mode (no state changes)
"Design is to take things apart in such a way that they can be put back
together"
- Rich Hickey
Reader implementation which reads source code and produces a tree
of parsed objects.
Type that represents any CVM collection
Defines the format of a Record structure, as an ordered vector of keys.
Class representing a function return value.
Class representing a smart reference to a decentralised data value.
In-memory cache for Blob decoding.
Ref subclass for direct in-memory references.
Static utilities for working with Refs
Reference class implemented via a soft reference and store lookup.
Class representing the result of a Convex interaction (typically a query or transaction).
Class for preparation of transaction results from the CVM
Mutable so that results can be accumulated efficiently while processing proceeds.
Exception class representing a Result failure
Useful in code where a successful Result is expected, but an error is received instead.
Class representing a function return value
"Computers are useless.
Class representing a function return value
"Computers are useless.
Static utility class for Runtime functions.
Type that represents any CVM sequence
Op to set a lexical value in the local execution context. i.e.
Type that represents any CVM collection
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.
Class implementing SLIP-0010 private key generations for Ed25519 private keys
See: https://github.com/satoshilabs/slips/blob/master/slip-0010.md
Cache with weak keys and soft referenced values
Standard codes used for CVM Result sources.
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 view some String data.
String implementation class wrapping a BlobTree.
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 for CAD3 encoding of Convex values
All of this is critical to the wire format and hash calculation.
Class representing a function return value.
Utilities for threading and concurrency
Transaction class representing a coin Transfer from one account to another
Utility class for tree handling functions
Op for executing a sequence of child operations until one succeeds
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.
Miscellaneous utility functions used in Convex, mostly bit fiddling
Class representing a validation failure
Type that represents any CVM collection
Non-canonical vector implementation designed to make operations on small temporary vectors more efficient.
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.