Data Structures

Here are the data structures with brief descriptions:

[detail level 12345]

▼Ncbdc
►Narchiver
Cclient	Retrieves blocks from a remote archiver via the network
Ccontroller	Wrapper for the archiver executable implementation
CleveldbWriteOptions	Wrapper for leveldb::WriteOptions to provide a constructor to set base class member "sync"
►Natomizer
Caggregate_tx_notification	Transaction notification message with a full set of input attestations
Caggregate_tx_notify_request	Batch of aggregate transaction notifications
Catomizer	Atomizer implementation
Catomizer_raft	Manager for an atomizer raft node
Cblock	Batch of compact transactions settled by the atomizer
Ccontroller	Wrapper for the atomizer raft executable implementation
Cget_block_request	Retrieve cached block request
Cget_block_response	Atomizer state machine response from get block request
Cmake_block_request	Placeholder struct for a make block state machine request
Cmake_block_response	Response from atomizer state machine to a make block request
Cprune_request	Prune blocks request for RPC and state machine
►Cstate_machine	Raft state machine for managing a replicated atomizer
Csnapshot	Represents a snapshot of the state machine with associated metadata
Ctx_notify_request	Transaction notification message
►Nconfig
Coptions	Project-wide configuration options
Cparser	Reads configuration parameters line-by-line from a file
►Ncoordinator
►Nrpc
Cclient	RPC client for a coordinator
Cserver	RPC server for a coordinator
►Ccontroller	Replicated coordinator node
Ccoordinator_state	Current state of distributed transactions managed by a coordinator
Csm_command	A full command for the state machine to process
Csm_command_header	Metadata of a command for the state machine
Cdistributed_tx	Class to manage a single distributed transaction (dtx) batch between shards
Cinterface	Interface for a coordinator
►Cstate_machine	Raft state machine for managing a replicated coordinator
Ccoordinator_state	Used to store dtxs, which phase they are in and relevant data require for recovery
►Nhashing
Cconst_sip_hash	SipHash function to generate STL data structure hash keys for system IDs
Cconst_sip_hash< buffer >
Cnull	Uses the raw value of a provided hash as an STL data structure hash key
►Nlocking_shard
►Nrpc
Capply_response	Empty type for the apply response
Cclient	RPC client for the mutable interface to a locking shard raft cluster
Cdiscard_params	Empty type for discard command parameters
Cdiscard_response	Empty type for the discard response
Crequest	Request to a shard
Cstatus_client	Client for interacting with the read-only port on 2PC shards
Cstatus_server	Server for handling TX and UHS ID status requests
Ctx_status_request	RPC message for clients to use to request the status of a TX ID
Cuhs_status_request	RPC message for clients to use to request the status of a UHS ID
Ccontroller	Manages a replicated locking shard using Raft
Cinterface	Interface for a locking shard
Clocking_shard	In-memory implementation of interface and status_interface
Cstate_machine	Raft state machine for handling locking shard RPC requests
Cstatus_interface	Interface for querying the read-only state of a locking shard
Ctx	Transaction type processed by locking shards
►Nlogging
Clog	Generalized logging class
Cnull_stream	No-op stream destination for log output
►Nnetwork
Cconnection_manager	Manages a group of peer s
Cmessage_t	Received message type
Cpeer	Maintains a TCP socket
Csocket	Generic superclass for network sockets
Csocket_selector	Waits on a group of blocking sockets to be ready for read operations
Ctcp_listener	Listens for incoming TCP connections on a given endpoint
Ctcp_socket	Wrapper for a TCP socket
►Nparsec
►Nagent
►Nrpc
Cclient	RPC client for an agent
Cexec_request	Agent contract execution RPC request message
Chttp_server	RPC server for a agent
Cserver	RPC server for an agent running a Lua exector
Cserver_interface	Server interface for an agent
►Nrunner
Ccode_key
Cevm_access_tuple	Type for tracking storage key accesses between accounts
Cevm_account	EVM account type
Cevm_dryrun_tx	Dry-run EVM transaction type
Cevm_host	Implementation of the evmc::Host interface using PARSEC as the backend database
Cevm_log	EVM log output type
Cevm_log_index	Index data for evm logs
Cevm_log_query	Describes the parameters of a query on EVM logs - used to transfer these parameters from the getLogs API method to the runner
Cevm_pretend_block	EVM pretend block is a pairing of the blocknumber (equal to the ticket number) and the transactions (currently always a single one) "inside the block" (executed by that ticket)
Cevm_runner	Executes EVM transactions, implementing the runner interface
Cevm_sig	EVM signature type
Cevm_tx	EVM transaction type
Cevm_tx_receipt	EVM transaction receipt type
Cfactory	Runner factory for agents to intiantiate new runners of a particular type while only worrying about the runner interface
Cinterface	Interface for a contract runner
Clua_runner	Lua function executor
Cstorage_key	Type for account storage keys
Cimpl	Implementation of an agent
Cinterface	Interface for an agent
►Nbroker
Cimpl	Implementation of a broker
Cinterface	Interface for a broker
►Ndirectory
Cimpl	Implementation of a directory which map keys to shard IDs. Thread-safe
Cinterface	Interface for a directory. Maps keys to shard IDs
►Nruntime_locking_shard
►Nrpc
Cclient	RPC client for a runtime locking shard cluster
Ccommit_request	Commit request message
Cfinish_request	Finish request message
Cget_tickets_request	Get tickets request message
Cprepare_request	Prepare request message
Creplicated_get_tickets_request	Message for retrieving unfinished tickets from the replicated state machine
Creplicated_prepare_request	Message for replicating a prepare request
Crollback_request	Rollback request message
Cserver	RPC server for a runtime locking shard
Ctry_lock_request	Try lock request message
Ccontroller	Manages a replicated runtime locking shard using Raft
Cimpl	Implementation of a runtime locking shard
Cinterface	Interface for a runtime locking shard
Creplicated_shard	Implementation of the replicated shard interface
Creplicated_shard_client	Client for asynchronously interacting with a raft replicated shard on the leader node of the cluster
►Creplicated_shard_interface	Interface for replicating internal state for prepared and committed tickets managed by a locking shard
Cticket_type	Ticket date stored in the replicated state machine
Cshard_error
Cstate_machine	NuRaft state machine implementation for a runtime locking shard
Cwounded_details	Details about wounded error code
►Nticket_machine
►Nrpc
Cclient	RPC client for a remote ticket machine
Ccontroller	Manages a replicated ticket machine using Raft
Cimpl	Thread-safe ticket machine implementation
Cinterface	Ticket machine interface
Cstate_machine	NuRaft state machine implementation for a replicated ticket machine
Cconfig	Configuration parameters for a phase two system
►Nraft
►Nrpc
Cserver	Generic RPC server for raft nodes for which the replicated state machine handles the request processing logic
Cconsole_logger	Nuraft::logger implementation using logging::log
Cindex_comparator	LevelDB comparator for ordering NuRaft log indices
Clog_store	NuRaft log_store implementation using LevelDB
Cnode	A node in a raft cluster
Cstate_manager	Implementation of nuraft::state_mgr using a file
►Nrpc
Casync_server	Generic asynchronous RPC server
Cblocking_server	Generic synchronous RPC server
Cclient	Generic RPC client
Ccurl_initializer	Class for performing libcurl global initialization
Cepoll_event_handler	Event handler implementation using Linux epoll
Cevent_handler	Event handler interface for tracking events on non-blocking file descriptors
Cheader	RPC request and response header
Cjson_rpc_http_client	Asynchronous HTTP JSON-RPC client implemented using libcurl
Cjson_rpc_http_server	Asynchrounous HTTP JSON-RPC server implemented using libmicrohttpd and libjsoncpp
Ckqueue_event_handler	Event handler implementation using BSD kqueue
Crequest	RPC request message
Cresponse	RPC response message
Cserver	Generic RPC server
Ctcp_client	Implements an RPC client over TCP sockets
Ctcp_server	Implements an RPC server over a TCP socket
►Nsentinel
►Nrpc
Casync_server	Asynchronous RPC server for a sentinel
Cclient	TCP RPC client for sentinels
Cserver	RPC server for a sentinel
Casync_interface	Interface for an asynchronous sentinel
Ccontroller	Sentinel implementation
Cexecute_request	Sentinel request message
Cexecute_response	Sentinel response message
Cinterface	Interface for a sentinel
Cshard_info	Sentinel-specific representation of shard network information
Cvalidate_request	Request type for transaction validation and attestation
►Nsentinel_2pc
Ccontroller	Manages a sentinel server for the two-phase commit architecture
►Nshard
Ccontroller	Wrapper for the shard executable implementation
Cshard	Database shard representing a fraction of the UTXO set
►Ntransaction
►Nvalidation
Cinput_error	An error that may occur when sentinels validate inputs
Coutput_error	An error that may occur when sentinels validate transaction outputs
Cwitness_error	An error that may occur when sentinels validate witness commitments
Ccompact_tx	A condensed, hash-only transaction representation
Ccompact_tx_hasher
Cfull_tx	A complete transaction
Cinput	An input for a new transaction
Cout_point	The unique identifier of a specific output from a transaction
Coutput	An output of a transaction
Cwallet	Cryptographic wallet for digital currency assets and secrets
►Nwatchtower
Casync_client	Client to asynchronously request information from the watchtower
Cbest_block_height_request	Request the watchtower's known best block height
Cbest_block_height_response	Contains the watchtower's known best block height
Cblock_cache	Stores a set of blocks in memory and maintains an index of the UHS IDs contained therein
Cblocking_client	Client to synchronously request information from the watchtower
Ccontroller	Wrapper for the watchtower executable implementation
Cerror_cache	Stores a set of internal transaction errors in memory, indexed by Tx ID and UHS ID
Crequest	RPC request message to the watchtower external endpoint
Cresponse	RPC response message from the watchtower external endpoint
Cstatus_request_check_success	Indicates a successful check request, sent with a StatusUpdateResponse
Cstatus_update_request	Network request to interact with the Watchtower's status update service
Cstatus_update_state	Represents the internal state of an ongoing status update request
Ctx_error	Wrapper for transaction errors
Ctx_error_incomplete	Indicates that the atomizer did not receive enough attestations for a particular transaction from shards before it had to clean up the transaction and free up space for others
Ctx_error_inputs_dne	Indicates a shard that tried to process a given transaction could not locate one or more of the transaction's inputs it expected to possess
Ctx_error_inputs_spent	Indicates that the given transaction contains one or more inputs that have already been spent in other transactions sent to the atomizer
Ctx_error_stxo_range	Indicates that a shard did not attest to this transaction recently enough for the atomizer to check it against the STXO cache
Ctx_error_sync	Indicates a shard that tried to process a given transaction was out of sync with the atomizer, and the transaction should be retried
Cwatchtower	Service to answer client requests for processing status updates on submitted transactions
Catomizer_client	Client for interacting with the atomizer architecture
Cblocking_queue_internal	Thread-safe producer-consumer FIFO queue supporting multiple concurrent producers and consumers
Cbuffer	Buffer to store and retrieve byte data
Cbuffer_serializer	Serializer implementation for buffer
Ccache_set	Thread-safe set with a maximum size
Cclient	External client for sending new transactions to the system
Cistream_serializer	Implementation of serializer for reading from a std::istream
Cnuraft_serializer	Implements serializer for nuraft::buffer
Costream_serializer	Implementation of serializer for writing to a std::ostream
Coverloaded	Variant handler template
Crandom_source	Generates pseudo-random numbers from a given entropy source
Crlp_value	This class contains a value that can be serialized into, or was deserialized from, a Recursive Length Prefix (RLP) encoded representation
Cserializer	Interface for serializing objects into and out of raw bytes representations
Csize_serializer	Utility class for determining the size of a buffer needed to serialize a sequence of objects
Cstream_serializer	Implementation of serializer for std::ios
Cthread_pool
Ctwophase_client	Client for interacting with the 2PC architecture