Query to request details of the server
A response to querying for the profile details of a user.
An abstract Bytes value that provides implementations of #equals(Object), #hashCode() and #toString().
State of an account as stored on chain.
An Ethereum account address.
Util dedicated for AES-GCM encoding with key size equal 16 bytes
Authenticated Encryption with Additional Data using AES-GCM.
Allocated objects track allocation of memory using Sodium.
(extensions in package org.apache.tuweni.concurrent.coroutines)
A completion that will be complete at a future time.
A MerkleStorage implementation using AsyncResult's.
(extensions in package org.apache.tuweni.concurrent.coroutines)
A result that will be available at a future time.
Secret-key authentication.
A post author
Utility methods for encoding and decoding base32 strings.
Utility methods for encoding and decoding base58 strings.
Utility methods for encoding and decoding base64 strings.
Utility methods for encoding and decoding base64 URL safe strings.
Base class for UInt256Value.
Base class for UInt32Value.
Base class for UInt384Value.
Base class for UInt64Value.
An Ethereum block.
An Ethereum block body.
A Lucene-backed indexer capable of indexing blocks and block headers.
Reader of a blockchain index.
Indexer for blockchain elements.
Blockchain information to be shared over the network with peers
Repository housing blockchain information.
An Ethereum block header.
Block header index fields.
Block statistics reported to ethnetstats.
This Boneh-Lynn-Shacham (BLS) signature implementation is constructed from a pairing friendly elliptic curve, the BLS12-381 curve. It uses parameters as defined in https://z.cash/blog/new-snark-curve and the points in groups G1 and G2 are defined https://github.com/zkcrypto/pairing/blob/master/src/bls12_381/README.md
A junit5 extension, that installs a BouncyCastle security provider.
Public-key authenticated encryption.
(extensions in package org.apache.tuweni.kademlia)
A value made of bytes.
A Bytes value that is guaranteed to contain exactly 32 bytes.
A Bytes value that is guaranteed to contain exactly 48 bytes.
Types of EVM calls
Handler managing a stream over SecureScuttlebutt originating from the Vert.x client
Factory creating stream handlers, managing client-side connections.
Exception thrown when a JSON-RPC request is denied.
Compact (Hex-prefix) encoding and decoding.
An AsyncCompletion that can later be completed successfully or with a provided exception.
An AsyncResult that can be later completed successfully with a provided value, or completed with an exception.
Concatenate elements allocated to Sodium memory.
Represents collection of configuration properties, optionally validated against a schema.
Provides details regarding an error in the configuration.
Factory methods for collections of ConfigurationError.
A validator for a configuration.
(extensions in package org.apache.tuweni.concurrent.coroutines)
A stateful connection between two peers under the Devp2p wire protocol.
(extensions in package org.apache.tuweni.concurrent.coroutines)
A class that holds and delegates all operations to its inner bytes field.
A class that holds and delegates all operations to its inner bytes field.
A class that holds and delegates all operations to its inner bytes field.
The result from a detached encryption.
Sodium provides an API to perform scalar multiplication of elliptic curve points.
Enumeration of all reasons disconnect may happen.
An Ethereum ÐΞVp2p discovery service.
A creator of discovery service objects.
Service executes network discovery, according to discv5 specification
(https://github.com/ethereum/devp2p/blob/master/discv5/discv5.md)
Wrapper for running a DNS daemon with configuration.
Resolves DNS records over time, refreshing records.
Callback listening to updates of the DNS records.
Intermediate format to write DNS entries
Resolves a set of ENR nodes from a host name.
Reads ENR (Ethereum Node Records) entries passed in from DNS.
A position in an input document.
Indicates the end of the RLP source has been reached unexpectedly.
Indicates the end of the SSZ source has been reached unexpectedly.
An Ethereum node endpoint.
The components of an enode URI.
Storage of node records
JPA-backed key value store.
An in-memory peer repository.
In-memory peer repository.
Client of the ETH subprotocol, allowing to request block and node data
Controller managing the state of the ETH or LES subprotocol handlers.
Top-level class to run an Ethereum client.
Configuration of EthereumClient. Can be provided via file or over the wire.
Support class for constructing integrated encryption ciphers for doing basic message exchanges on top of key agreement ciphers. Follows the description given in IEEE Std 1363a.
Ethereum Node Record (ENR) as described in EIP-778.
An Ethereum Virtual Machine.
Implementation of EthHash utilities for Ethereum mining algorithms.
Requests manager used to request and check requests of block data
ETHNetStats reporting service.
EVM execution status codes
Result of EVM execution
A concurrent hash map that stores values along with an expiry. Values are stored in the map until their expiry is reached, after which they will no longer be available and will appear as if removed. The actual removal is done lazily whenever the map is accessed, or when the #purgeExpired() method is invoked.
A concurrent hash set that stores values along with an expiry. Elements are stored in the set until their expiry is reached, after which they will no longer be available and will appear as if removed. The actual removal is done lazily whenever the set is accessed, or when the #purgeExpired() method is invoked.
A scuttlebutt feed message
A service for operations that concern scuttlebutt feeds. Should be accessed via a ScuttlebuttClient instance.
The metadata and contents of a message
Utility methods for working with files.
Repository of remote peer fingerprints.
A unit measure of Gas as used by the Ethereum VM.
Generic hashing utility (BLAKE2b).
Utility to read genesis config files and translate them to a block.
Application running a gossip client, taking configuration from command line or a configuration file.
Exceptions thrown during handshake because of invalid messages or different network identifiers.
Contents of a message sent as part of a RLPx handshake.
Known hard fork revisions to execute against.
Various utilities for providing hashes (digests) of arbitrary data. Requires the BouncyCastleProvider to be loaded and available. See https://www.bouncycastle.org/wiki/display/JA1/Provider+Installation for detail.
An Ethereum hash.
Message authentication code support for HMAC-SHA-256.
Message authentication code support for HMAC-SHA-512.
Message authentication code support for HMAC-SHA-512-256.
Hobbits is a peer-to-peer transport stack specified at https://www.github.com/deltap2p/hobbits.
A Scuttlebutt identity, backed by a public key. Currently supported: Ed25519 and SECP256K1.
A key-value store backed by Infinispan
An exception thrown when an invalid type is encountered.
Exception thrown when the message contents do not match the Message Authentication Code.
Indicates that invalid RLP encoding was encountered.
Indicates that an unexpected type was encountered when decoding RLP.
Exception thrown when reading a store that contains an invalid SEC256K1 private keys.
Indicates that an unexpected type was encountered when decoding SSZ.
An invite code as defined by the Secure Scuttlebutt protocol guide.
Represents an operation that accepts a single input argument and returns no result.
(extensions in package org.apache.tuweni.concurrent.coroutines)
JSON-RPC client to send requests to an Ethereum client.
A Kademlia Routing Table
Key derivation.
Key exchange.
Utility class for loading scuttlebutt keys from the file system.
KeyPair represents a public and private key.
A key-value store.
The LES subprotocol entry point class, to be used in conjunction with RLPxService
A key-value store backed by LevelDB.
Representation of an identity associated with an IP and port, used for Scuttlebutt local discovery.
A log entry is a tuple of a logger’s address (the address of the contract that added the logs), a series of 32-bytes log topics, and some number of bytes of data.
Bloom filter implementation for storing persistent logs, describes a 2048-bit representation of all log entries of a transaction, except data. Sets the bits of the 2048 byte array, where indices are given by: The lower order 11-bits, of the first three double-bytes, of the SHA3, of each value. For instance the address "0x0F572E5295C57F15886F9B263E2F6D2D6C7B5EC6" results in the KECCAK256 hash "bd2b01afcd27800b54d2179edc49e2bffde5078bb6d0b204694169b1643fb108", of which the corresponding double-bytes are: bd2b, 01af, cd27, corresponding to the following bits in the bloom filter: 1323, 431, 1319
A parameter annotation for injecting a Lucene index directory into junit5 tests.
A parameter annotation for injecting a Lucene index writer into junit5 tests.
A junit5 extension, that provides a memory-backed Lucene index writer for tests. The index writer is created for the test suite and injected into any tests with parameters annotated by LuceneIndexWriter.
A key-value store backed by a MapDB instance.
A key-value store backed by an in-memory Map.
Memory-backed peer repository.
In-memory implementation of the wire connections repository.
An in-memory MerkleTrie.
Storage for use in a StoredMerklePatriciaTrie.
This exception is thrown when there is an issue retrieving or decoding values from MerkleStorage.
A Merkle Trie.
Hobbits message.
Produces an identifiable footprint for a message (generally a hash) that can be passed on to other peers to identify uniquely a message being propagated.
Listens to an incoming message, along with its attributes.
Interface to sending messages to other peers.
Validator for a message and a peer. This validator is called prior to gossiping the message from that peer to other peers.
Multiplexes asynchronous requests and streams across a connection to a node. Handles multiple active requests and streams across one connection.
A mutable Bytes value.
A mutable Bytes32, that is a mutable Bytes value of exactly 32 bytes.
A mutable Bytes48, that is a mutable Bytes value of exactly 48 bytes.
(extensions in package org.apache.tuweni.kademlia)
A service for operations that connect nodes together and other network related operations
An exception thrown when a requested configuration property is not found.
The Argon2 memory-hard hashing function.
An Ethereum P2P network peer.
A peer in a peer-to-peer system.
A peer part of the gossip system.
Interface to decide whether to prune peers when they send messages late. Pruned peers become "lazy peers". They send message attestations (IHAVE).
A repository of peers in an Ethereum network.
A repository of peers, organized for Ethereum and other blockchain and peer-to-peer systems.
Repository of active peers associating with a gossip tree.
A routing table for ÐΞVp2p peers.
Represents a user profile.
Ethereum ProgPoW mining algorithm, based on revision 0.9.2. This implements the ProgPoW algorithm (https://github.com/ifdefelse/ProgPOW). This algorithm is licensed under CC0 1.0 Universal (CC0 1.0) Public Domain Dedication (https://creativecommons.org/publicdomain/zero/1.0/) See the specification at https://github.com/ifdefelse/ProgPOW
A validator associated with a specific configuration property.
Subprotocols supported by the hobbits protocol.
A store used as a proxy for another store.
This class represents a BLS12-381 public key.
Intended to make RPC requests which aren't supported by the higher level services possible. We cannot support every desired RPC request with higher level abstractions because it's possible to define custom plugins with custom endpoints.
A key-value store backed by Redis.
A parameter annotation for injecting the running Redis server port into junit5 tests.
A junit5 extension, that sets up an ephemeral Redis server for tests. The ephemeral Redis server is created with a random free port for the test suite and injected into any tests with parameters of type Integer annotated with RedisPort NOTE: Redis does not support picking a random port on its own. This extension tries its best to test free ports and avoid collisions.
Relays messages between two endpoints, with an interceptor reading passed messages.
Relayer application, allowing to set a relay between two hobbits endpoints.
A data request handle, matching the connection on which the request was made.
Methods for resolving resources. Supports recursive discovery and glob matching on the filesystem and in jar archives.
Recursive Length Prefix (RLP) encoding and decoding.
Base type for all RLP encoding and decoding exceptions.
A reader for consuming values from an RLP encoded source.
A writer for encoding values to RLP.
Connection between 2 peers over the RLPx protocol.
Factory creating RLPxConnection, either from initiating a handshake or responding to a handshake request.
Message exchanged over a RLPx connection.
Service allowing connections to remote peers over RLPx connections.
A key-value store backed by RocksDB.
Encoder responsible for encoding requests.
An RPC message response body which contains an error
Defines constants for dealing with SecureScuttlebutt RPC flags.
A scuttlebutt RPC function namespace and name representation.
Handles RPC requests and responses from an active connection to a scuttlebutt node.
Decoded RPC message, making elements of the message available directly.
The request payload of an RPC request to another node. The fields are as specified in the scuttlebutt protocol docs
The available type of Scuttlebutt RPC requests
A successful RPC response.
A request which returns a 'source' type result (e.g. opens up a stream that is followed by the request ID.)
A schema for a configuration, providing default values and validation rules.
This interface allows customers to determine a schema to associate with a configuration to validate the entries read from configuration files, and provide default values if no value is present in the configuration file.
Discovery scraper that will continue asking peers for peers, and iterate over them, until told to stop.
Discovery scraper that will continue asking peers for peers, and iterate over them, until told to stop.
Wrapper to run the scraper as an app.
Wrapper to run the scraper as an app.
A client for making requests to a scuttlebutt instance with. This is the entry point for accessing service classes which perform operations related to different logical areas. Should be constructed using the ScuttlebuttClientFactory factory class.
A factory for constructing a new instance of ScuttlebuttClient with the given configuration parameters
Scuttlebutt local discovery service, based on the Scuttlebutt network protocol defined here. This service offers two functions:
Classes that are to be posted to the scuttlebutt feed should implement this interface
Handles incoming items from a result stream
An Elliptic Curve Digital Signature using parameters as used by Bitcoin, and defined in Standards for Efficient Cryptography (SEC) (Certicom Research, http://www.secg.org/sec2-v2.pdf).
Secret-key authenticated encryption.
Used to decrypt a sequence of messages, or a single message split into arbitrary chunks.
Used to encrypt a sequence of messages, or a single message split into arbitrary chunks.
This class represents a BLS12-381 private key.
Class responsible for performing a Secure Scuttlebutt handshake with a remote peer, as defined in the Secure Scuttlebutt protocol guide
Class responsible for performing a Secure Scuttlebutt handshake with a remote peer, as defined in the Secure Scuttlebutt protocol guide
Interface used to encrypt and decrypt messages to and from a server.
Interface used to encrypt and decrypt messages to and from a client.
Secure Scuttlebutt client using Vert.x to manage persistent TCP connections.
Secure Scuttlebutt server using Vert.x to manage persistent TCP connections.
Handler managing a stream over SecureScuttlebutt originating from the Vert.x server
Factory creating stream handlers, managing server-side connections.
SHA-256 hashing. The SHA-256 and SHA-512 functions are provided for interoperability with other applications. If you are looking for a generic hash function and not specifically SHA-2, using crypto_generichash() (BLAKE2b) might be a better choice.
This class represents a Signature on G2
Public-key signatures.
This class represents a signature and a public key
POJO - constant representation of the blockchain information
Operations for querying the follow graph, and fetching the profiles of users. Assumes that the standard 'ssb-about' and 'ssb-friends' plugins are installed on the target instance (or that RPC functions meeting their manifests' contracts are available.) Should not be instantiated directly - an instance should be acquired via the ScuttlebuttClient instance
Access to the sodium native library.
An exception that is thrown when an error occurs using the native sodium library.
Details of a sodium native library version.
A key-value store backed by a relational database.
Simple Serialize (SSZ) encoding and decoding.
Base type for all SSZ encoding and decoding exceptions.
A reader for consuming values from an SSZ encoded source.
A writer for encoding values to SSZ.
Local state to our peer, representing the make-up of the tree of peers.
Peer status information
A MerkleTrie that persists trie nodes to a MerkleStorage key/value store.
A handler consuming a stream.
Utilities for working with streams.
Defines a subprotocol to be used for wire connections
Subprotocol client allowing outside users to call functions associated with the subprotocol.
Handler managing messages and new connections of peers related for a given subprotocol.
Identifier of a subprotocol, comprised of a name and version.
A parameter annotation for injecting a temporary directory into junit5 tests.
A junit5 extension, that provides a temporary directory for tests. The temporary directory is created for the test suite and injected into any tests with parameters annotated by TempDirectory.
Common utilities for TLS.
Methods for parsing data stored in Tom's Obvious, Minimal Language (TOML).
An array of TOML values.
An exception thrown when an invalid type is encountered.
An error that occurred while parsing.
This class provides an empty implementation of TomlParserListener, 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 TomlParserVisitor, which can be extended to create a visitor which only needs to handle a subset of the available methods.
The result from parsing a TOML document.
This interface defines a complete listener for a parse tree produced by TomlParser.
This interface defines a complete generic visitor for a parse tree produced by TomlParser.
A position in an input document.
An interface for accessing data stored in Tom's Obvious, Minimal Language (TOML).
Supported TOML specification versions.
An Ethereum transaction.
EVM context that records changes to the world state, so they can be applied atomically.
A transaction receipt, containing information pertaining a transaction execution.
Transaction receipt index fields.
Transport types supported.
Trust manager factories for fingerprinting clients and servers.
Stats reported to ethnetstats representing the hash of a transaction.
An unsigned 256-bit precision number. This is a raw UInt256Value - a 256-bit precision unsigned number of no particular unit.
Static utility methods on UInt256 values.
Represents a 256-bit (32 bytes) unsigned integer value.
An unsigned 32-bit precision number.
Static utility methods on UInt32 values.
Represents a 32-bit (8 bytes) unsigned integer value.
An unsigned 384-bit precision number. This is a raw UInt384Value - a 384-bit precision unsigned number of no particular unit.
Static utility methods on UInt384 values.
Represents a 384-bit (48 bytes) unsigned integer value.
An unsigned 64-bit precision number. This is a raw UInt64Value - a 64-bit precision unsigned number of no particular unit.
Static utility methods on UInt64 values.
Represents a 64-bit (8 bytes) unsigned integer value.
A message that when persisted to the feed updates the name of the given user
A junit5 extension, that provides a Vert.X instance for tests. The Vert.X instance created for the test suite and injected into any tests with parameters annotated by VertxInstance.
Vert.x implementation of the plumtree gossip. This implementation is provided as an example and relies on a simplistic JSON serialization of messages.
A parameter annotation for injecting a temporary Vert.X instance into junit5 tests.
Implementation of RLPx service using Vert.x.
Vert.x TrustOptions for fingerprinting clients and servers.
Wallet containing a private key that is secured with symmetric encryption.
A unit measure of Wei as used by the Ethereum VM.
A stateful connection between two peers under the Devp2p wire protocol.
A repository managing wire connections.
Authenticated Encryption with Additional Data using XChaCha20-Poly1305.