### All Types

net.corda.node.utilities.ANSIProgressObserver | This observes the StateMachineManager and follows the progress of FlowLogics until they complete in the order they are added to the StateMachineManager.
net.corda.node.utilities.ANSIProgressRenderer | Knows how to render a ProgressTracker to the terminal using coloured, emoji-fied output. Useful when writing small command line tools, demos, tests etc. Just set the progressTracker field and it will go ahead and start drawing if the terminal supports it. Otherwise it just prints out the name of the step whenever it changes.
net.corda.flows.AbstractCashFlow | Initiates a flow that produces an Issue/Move or Exit Cash transaction.
net.corda.contracts.clause.AbstractConserveAmount | Standardised clause for checking input/output balances of fungible assets. Requires that a Move command is provided, and errors if absent. Must be the last clause under a grouping clause; errors on no-match, ends on match.
net.corda.contracts.clause.AbstractIssue | Standard issue clause for contracts that issue fungible assets.
net.corda.node.utilities.AbstractJDBCHashMap | A base class for a JDBC table backed hash map that iterates in insertion order by using an ever increasing sequence number on entries. Iterators supports remove() but entries are not really mutable and do not support setValue() method from MutableMap.MutableEntry.
net.corda.node.utilities.AbstractJDBCHashSet | Base class for JDBC backed hash set that delegates to a JDBC backed hash map where the values are all Unit and not actually persisted. Iteration order is order of insertion. Iterators can remove().
net.corda.node.services.network.AbstractNetworkMapService | Abstracted out core functionality as the basis for a persistent implementation, as well as existing in-memory implementation.
net.corda.node.internal.AbstractNode | A base node implementation that can be customised either for production (with real implementations that do real I/O), or a mock implementation suitable for unit test environments.
net.corda.node.services.api.AbstractNodeService | Abstract superclass for services that a node can host, which provides helper functions.
net.corda.core.crypto.AbstractParty | An AbstractParty contains the common elements of Party and AnonymousParty, specifically the owning key of the party. In most cases Party or AnonymousParty should be used, depending on use-case.
net.corda.flows.AbstractStateReplacementFlow | Abstract flow to be used for replacing one state with another, for example when changing the notary of a state. Notably this requires a one to one replacement of states, states cannot be split, merged or issued as part of these flows.
net.corda.node.services.api.AcceptsFileUpload | A service that implements AcceptsFileUpload can have new binary data provided to it via an HTTP upload.
net.corda.core.contracts.AccrualAdjustment | Simple enum for returning accurals adjusted or unadjusted. We don't actually do anything with this yet though, so it's ignored for now.
net.corda.core.messaging.Ack | A general Ack message that conveys no content other than it's presence for use when you want an acknowledgement from a recipient. Using Unit can be ambiguous as it is similar to Void and so could mean no response.
net.corda.node.utilities.AddOrRemove | Enum for when adding/removing something, for example adding or removing an entry in a directory.
net.corda.node.utilities.AffinityExecutor | An extended executor interface that supports thread affinity assertions and short circuiting. This can be useful for ensuring code runs on the right thread, and also for unit testing.
net.corda.client.fxutils.AggregatedList | Given an ObservableList<E> and a grouping key K, AggregatedList groups the elements by the key into a fresh ObservableList<E> for each group and exposes the groups as an observable list of As by calling assemble on each.
net.corda.core.contracts.clauses.AllComposition | Compose a number of clauses, such that all of the clauses must run for verification to pass.
net.corda.core.contracts.clauses.AllOf | Compose a number of clauses, such that all of the clauses must run for verification to pass.
net.corda.core.messaging.AllPossibleRecipients | A special base class for the set of all possible recipients, without having to identify who they all are.
net.corda.core.serialization.AllWhitelist |
net.corda.core.contracts.Amount | Amount represents a positive quantity of some token (currency, asset, etc.), measured in quantity of the smallest representable units. Note that quantity is not necessarily 1/100ths of a currency unit, but are the actual smallest amount used in whatever underlying thing the amount represents.
net.corda.client.fxutils.AmountBindings | Utility bindings for the Amount type, similar in spirit to Bindings
net.corda.core.testing.AmountGenerator |
net.corda.core.crypto.AnonymousParty | The AnonymousParty class contains enough information to uniquely identify a Party while excluding private information such as name. It is intended to represent a party on the distributed ledger.
net.corda.core.testing.AnonymousPartyGenerator |
net.corda.core.contracts.clauses.AnyComposition | Compose a number of clauses, such that any number of the clauses can run.
net.corda.core.contracts.clauses.AnyOf | Compose a number of clauses, such that one or more of the clauses can run.
net.corda.core.utilities.ApiUtils | Utility functions to reduce boilerplate when developing HTTP APIs
net.corda.core.flows.AppContext | This is just some way to track what attachments need to be in the class loader, but may later include some app properties loaded from the attachments. And perhaps the authenticated user for an API call?
net.corda.node.ArgsParser |
net.corda.node.services.messaging.ArtemisMessagingComponent | The base class for Artemis services that defines shared data structures and SSL transport configuration.
net.corda.node.services.messaging.ArtemisMessagingServer | This class configures and manages an Apache Artemis message queue broker.
net.corda.client.fxutils.AssociatedList | AssociatedList creates an ObservableMap from an ObservableList by associating each list element with a unique key. It is not allowed to have several elements map to the same value!
net.corda.core.contracts.Attachment | An attachment is a ZIP (or an optionally signed JAR) that contains one or more files. Attachments are meant to contain public static data which can be referenced from transactions and utilised from contracts. Good examples of how attachments are meant to be used include:
net.corda.core.contracts.AttachmentResolutionException |
net.corda.core.node.services.AttachmentStorage | An attachment store records potentially large binary objects, identified by their hash.
net.corda.core.node.AttachmentsClassLoader | A custom ClassLoader that knows how to load classes from a set of attachments. The attachments themselves only need to provide JAR streams, and so could be fetched from a database, local disk, etc. Constructing an AttachmentsClassLoader is somewhat expensive, as every attachment is scanned to ensure that there are no overlapping file paths.
net.corda.core.node.services.AttachmentsStorageService |
net.corda.core.contracts.AuthenticatedObject | Wraps an object that was signed by a public key, which may be a well known/recognised institutional key.
net.corda.node.services.transactions.BFTSmartClient |
net.corda.node.services.transactions.BFTSmartServer |
net.corda.node.services.transactions.BFTSmartUniquenessProvider | A UniquenessProvider based on the bft-smart library.
net.corda.node.services.transactions.BFTValidatingNotaryService | A validating notary service operated by a group of parties that don't necessarily trust each other.
net.corda.core.transactions.BaseTransaction | An abstract class defining fields shared by all transaction types in the system.
net.corda.contracts.clause.BilateralNetState | Subset of state, containing the elements which must match for two obligation transactions to be nettable. If two obligation state objects produce equal bilateral net states, they are considered safe to net directly. Bilateral states are used in close-out netting.
net.corda.core.contracts.BilateralNettableState | Interface for state objects that support being netted with other state objects.
net.corda.flows.BroadcastTransactionFlow | Notify the specified parties about a transaction. The remote peers will download this transaction and its dependency graph, verifying them all. The flow returns when all peers have acknowledged the transactions as valid. Normally you wouldn't use this directly, it would be called via FinalityFlow.
net.corda.core.serialization.BuiltInExceptionsWhitelist |
net.corda.core.contracts.BusinessCalendar | A business calendar performs date calculations that take into account national holidays and weekends. This is a typical feature of financial contracts, in which a business may not want a payment event to fall on a day when no staff are around to handle problems.
kotlin.ByteArray (extensions in package net.corda.core.crypto) |
kotlin.ByteArray (extensions in package net.corda.core.serialization) |
net.corda.contracts.asset.Cash | A cash transaction may split and merge money represented by a set of (issuer, depositRef) pairs, across multiple input and output states. Imagine a Bitcoin transaction but in which all UTXOs had a colour (a blend of issuer+depositRef) and you couldn't merge outputs of two colours together, but you COULD put them in the same transaction.
net.corda.node.services.vault.CashBalanceAsMetricsObserver | This class observes the vault and reflect current cash balances as exposed metrics in the monitoring service.
net.corda.flows.CashException |
net.corda.flows.CashExitFlow | Initiates a flow that produces an cash exit transaction.
net.corda.flows.CashFlowCommand | A command to initiate the Cash flow with.
net.corda.flows.CashIssueFlow | Initiates a flow that produces cash issuance transaction.
net.corda.flows.CashPaymentFlow | Initiates a flow that produces an cash move transaction.
net.corda.schemas.CashSchema | An object used to fully qualify the CashSchema family name (i.e. independent of version).
net.corda.schemas.CashSchemaV1 | First version of a cash contract ORM schema that maps all fields of the Cash contract state as it stood at the time of writing.
net.corda.node.utilities.registration.CertificateRequestException |
net.corda.core.crypto.CertificateStream |
net.corda.node.services.api.Checkpoint |
net.corda.node.services.api.CheckpointStorage | Thread-safe storage of fiber checkpoints.
net.corda.client.fxutils.ChosenList | ChosenList manages an ObservableList that may be changed by the wrapping ObservableValue. Whenever the underlying ObservableValue changes the exposed list changes to the new value. Changes to the list are simply propagated.
net.corda.core.node.CityDatabase | A simple lookup table of city names to their coordinates. Lookups are case insensitive.
net.corda.node.services.messaging.ClassSerializer |
net.corda.core.serialization.ClassWhitelist |
net.corda.core.contracts.clauses.Clause | A clause of a contract, containing a chunk of verification logic. That logic may be delegated to other clauses, or provided directly by this clause.
net.corda.node.services.messaging.ClientRPCRequestMessage | The contents of an RPC request message, separated from the MQ layer.
java.time.Clock (extensions in package net.corda.node.utilities) |
net.corda.node.CmdLineOptions |
kotlin.collections.Collection (extensions in package net.corda.core.contracts) |
kotlin.collections.Collection (extensions in package net.corda.client.fxutils) |
net.corda.core.contracts.Command | Command data/content plus pubkey pair: the signature is stored at the end of the serialized bytes
net.corda.core.contracts.CommandData | Marker interface for classes that represent commands
net.corda.contracts.testing.CommandDataGenerator |
net.corda.contracts.testing.CommandGenerator |
net.corda.contracts.CommercialPaper |
net.corda.contracts.CommercialPaperLegacy |
net.corda.schemas.CommercialPaperSchema | An object used to fully qualify the CommercialPaperSchema family name (i.e. independent of version).
net.corda.schemas.CommercialPaperSchemaV1 | First version of a commercial paper contract ORM schema that maps all fields of the CommercialPaper contract state as it stood at the time of writing.
net.corda.core.contracts.Commodity | Class representing a commodity, as an equivalent to the Currency class. This exists purely to enable the CommodityContract contract, and is likely to change in future.
net.corda.contracts.asset.CommodityContract | A commodity contract represents an amount of some commodity, tracked on a distributed ledger. The design of this contract is intentionally similar to the Cash contract, and the same commands (issue, move, exit) apply, the differences are in representation of the underlying commodity. Issuer in this context means the party who has the commodity, or is otherwise responsible for delivering the commodity on demand, and the deposit reference is use for internal accounting by the issuer (it might be, for example, a warehouse and/or location within a warehouse).
net.corda.core.contracts.clauses.CompositeClause | Abstract supertype for clauses which compose other clauses together in some logical manner.
net.corda.core.crypto.CompositeKey | A tree data structure that enables the representation of composite public keys.
net.corda.node.utilities.CompositeKeyColumnType | ColumnType for marshalling to/from database on behalf of CompositeKey.
net.corda.core.testing.CompositeKeyGenerator |
net.corda.core.serialization.CompositeKeyLeafSerializer | For serialising composite keys
net.corda.core.serialization.CompositeKeyNodeSerializer |
net.corda.client.fxutils.ConcatenatedList | ConcatenatedList takes a list of lists and concatenates them. Any change to the underlying lists or the outer list is propagated as expected.
com.typesafe.config.Config (extensions in package net.corda.node.services.config) |
com.typesafe.config.Config (extensions in package net.corda.node.utilities) |
net.corda.node.services.config.ConfigHelper |
net.corda.node.internal.ConfigurationException |
net.corda.core.contracts.Contract | Implemented by a program that implements business logic on the shared ledger. All participants run this code for every LedgerTransaction they see on the network, for every input and output state. All contracts must accept the transaction for it to be accepted: failure of any aborts the entire thing. The time is taken from a trusted timestamp attached to the transaction itself i.e. it is NOT necessarily the current time.
net.corda.core.contracts.ContractState | A contract state (or just "state") contains opaque data used by a contract program. It can be thought of as a disk file that the program can use to persist data across transactions. States are immutable: once created they are never updated, instead, any changes must generate a new successor state. States can be updated (consumed) only once: the notary is responsible for ensuring there is no "double spending" by only signing a transaction if the input states are all free.
net.corda.contracts.testing.ContractStateGenerator | This file contains generators for quickcheck style testing. The idea is that we can write random instance generators for each type we have in the code and test against those instead of predefined mock data. This style of testing can catch corner case bugs and test algebraic properties of the code, for example deserialize(serialize(generatedThing)) == generatedThing
net.corda.client.model.ContractStateModel | This model exposes the list of owned contract states.
net.corda.flows.ContractUpgradeFlow | A flow to be used for upgrading state objects of an old contract to a new contract.
net.corda.core.serialization.CordaClassResolver |
net.corda.core.serialization.CordaKryo | We need to disable whitelist checking during calls from our Kryo code to register a serializer, since it checks for existing registrations and then will enter our CordaClassResolver.getRegistration method.
net.corda.core.node.CordaPluginRegistry | Implement this interface on a class advertised in a META-INF/services/net.corda.core.node.CordaPluginRegistry file to extend a Corda node with additional application services.
net.corda.node.services.messaging.CordaRPCClient | An RPC client connects to the specified server and allows you to make calls to the server that perform various useful tasks. See the documentation for proxy or review the docsite to learn more about how this API works.
net.corda.node.services.messaging.CordaRPCClientImpl | Core RPC engine implementation, to learn how to use RPC you should be looking at CordaRPCClient.
net.corda.core.messaging.CordaRPCOps | RPC operations that the node exposes to clients using the Java client library. These can be called from client apps and are implemented by the node in the CordaRPCOpsImpl class.
net.corda.node.internal.CordaRPCOpsImpl | Server side implementations of RPCs available to MQ based client tools. Execution takes place on the server thread (i.e. serially). Arguments are serialised and deserialised automatically.
net.corda.core.serialization.CordaSerializable | This annotation is a marker to indicate that a class is permitted and intended to be serialized as part of Node messaging.
net.corda.core.math.CubicSplineInterpolator | Interpolates values between the given data points using a SplineFunction.
java.util.Currency (extensions in package net.corda.core.contracts) |
net.corda.core.testing.CurrencyGenerator |
net.corda.node.services.persistence.DBCheckpointStorage | Simple checkpoint key value storage in DB using the underlying JDBCHashMap and transactional context of the call sites.
net.corda.node.services.persistence.DBTransactionMappingStorage | Database storage of a txhash -> state machine id mapping.
net.corda.node.services.persistence.DBTransactionStorage |
net.corda.node.services.persistence.DataVending |
net.corda.core.contracts.DateRollConvention | This reflects what happens if a date on which a business event is supposed to happen actually falls upon a non-working day. Depending on the accounting requirement, we can move forward until we get to a business day, or backwards. There are some additional rules which are explained in the individual cases below.
net.corda.core.contracts.DateRollDirection | This is utilised in the DateRollConvention class to determine which way we should initially step when finding a business day.
net.corda.core.contracts.DayCountBasisDay | This forms the day part of the "Day Count Basis" used for interest calculation. Note that the first character cannot be a number (enum naming constraints), so we drop that in the toString lest some people get confused.
net.corda.core.contracts.DayCountBasisYear | This forms the year part of the "Day Count Basis" used for interest calculation.
net.corda.core.contracts.DealState | Interface representing an agreement that exposes various attributes that are common. Implementing it simplifies implementation of general flows that manipulate many agreement types.
net.corda.core.serialization.DefaultKryoCustomizer |
net.corda.node.serialization.DefaultWhitelist |
net.corda.core.serialization.DeserializeAsKotlinObjectDef | Marker interface for kotlin object definitions so that they are deserialized as the singleton instance.
net.corda.client.model.Diff |
net.corda.core.crypto.DigitalSignature | A wrapper around a digital signature. The covering field is a generic tag usable by whatever is interpreting the signature. It isn't used currently, but experience from Bitcoin suggests such a feature is useful, especially when building partially signed transactions.
net.corda.node.services.transactions.DistributedImmutableMap | A distributed map state machine that doesn't allow overriding values. The state machine is replicated across a Copycat Raft cluster.
kotlin.Double (extensions in package net.corda.core.contracts) |
kotlin.Double (extensions in package net.corda.core) |
net.corda.node.driver.DriverBasedTest |
net.corda.node.driver.DriverDSL |
net.corda.node.driver.DriverDSLExposedInterface | This is the interface that's exposed to DSL users.
net.corda.node.driver.DriverDSLInternalInterface |
net.corda.core.contracts.DummyContract |
net.corda.core.contracts.DummyContractV2 | Dummy contract state for testing of the upgrade process.
net.corda.contracts.testing.DummyDealContract |
net.corda.contracts.testing.DummyLinearContract |
net.corda.core.crypto.DummyPublicKey |
net.corda.core.contracts.DummyState | Dummy state for use in testing. Not part of any contract, not even the DummyContract.
net.corda.core.testing.DurationGenerator |
net.corda.node.services.keys.E2ETestKeyManagementService | A simple in-memory KMS that doesn't bother saving keys to disk. A real implementation would:
net.corda.core.serialization.Ed25519PrivateKeySerializer | For serialising an ed25519 private key
net.corda.core.serialization.Ed25519PublicKeySerializer | For serialising an ed25519 public key
net.corda.core.utilities.Emoji | A simple wrapper class that contains icons and support for printing them only when we're connected to a terminal.
net.corda.core.serialization.EmptyWhitelist |
net.corda.core.ErrorOr | Representation of an operation that may have thrown an error.
net.corda.node.services.statemachine.ErrorSessionEnd |
net.corda.client.mock.EventGenerator | Generators for incoming/outgoing events to/from the WalletMonitorService. Internally it keeps track of owned state/ref pairs, but it doesn't necessarily generate "correct" events!
net.corda.client.model.ExchangeRate |
net.corda.client.model.ExchangeRateModel | This model provides an exchange rate from arbitrary currency to arbitrary currency. TODO hook up an actual oracle
net.corda.node.services.statemachine.ExistingSessionMessage |
net.corda.contracts.testing.ExitGenerator |
net.corda.core.contracts.Expression | Represents a textual expression of e.g. a formula
net.corda.core.contracts.ExpressionDeserializer |
net.corda.core.contracts.ExpressionSerializer |
net.corda.flows.FetchAttachmentsFlow | Given a set of hashes either loads from from local storage or requests them from the other peer. Downloaded attachments are saved to local storage automatically.
net.corda.flows.FetchDataFlow | An abstract flow for fetching typed data from a remote peer.
net.corda.flows.FetchTransactionsFlow | Given a set of tx hashes (IDs), either loads them from local disk or asks the remote peer to provide them.
net.corda.node.utilities.FiberBox | Modelled on ThreadBox, but with support for waiting that is compatible with Quasar Fibers and MutableClocks.
net.corda.core.node.services.FileUploader | An interface that denotes a service that can accept file uploads.
net.corda.core.contracts.clauses.FilterOn | Filter the states that are passed through to the wrapped clause, to restrict them to a specific type.
net.corda.core.transactions.FilteredLeaves | Class that holds filtered leaves for a partial Merkle transaction. We assume mixed leaf types, notice that every field from WireTransaction can be used in PartialMerkleTree calculation.
net.corda.core.transactions.FilteredTransaction | Class representing merkleized filtered transaction.
net.corda.flows.FinalityFlow | Verifies the given transactions, then sends them to the named notaries. If the notary agrees that the transactions are acceptable then they are from that point onwards committed to the ledger, and will be written through to the vault. Additionally they will be distributed to the parties reflected in the participants list of the states.
net.corda.core.contracts.clauses.FirstComposition | Compose a number of clauses, such that the first match is run, and it errors if none is run.
net.corda.core.contracts.clauses.FirstOf | Compose a number of clauses, such that the first match is run, and it errors if none is run.
net.corda.core.contracts.Fix | A Fix represents a named interest rate, on a given day, for a given duration. It can be embedded in a tx.
net.corda.core.contracts.FixOf | A FixOf identifies the question side of a fix: what day, tenor and type of fix ("LIBOR", "EURIBOR" etc)
net.corda.core.contracts.FixableDealState | Interface adding fixing specific methods.
net.corda.client.fxutils.FlattenedList | FlattenedList flattens the passed in list of ObservableValues so that changes in individual updates to the values are reflected in the exposed list as expected.
net.corda.core.flows.FlowException | Exception which can be thrown by a FlowLogic at any point in its logic to unexpectedly bring it to a permanent end. The exception will propagate to all counterparty flows and will be thrown on their end the next time they wait on a FlowLogic.receive or FlowLogic.sendAndReceive. Any flow which no longer needs to do a receive, or has already ended, will not receive the exception (if this is required then have them wait for a confirmation message).
net.corda.core.messaging.FlowHandle | FlowHandle is a serialisable handle for the started flow, parameterised by the type of the flow's return value.
net.corda.node.services.statemachine.FlowIORequest |
net.corda.core.flows.FlowLogic | A sub-class of FlowLogic implements a flow using direct, straight line blocking code. Thus you can write complex flow logic in an ordinary fashion, without having to think about callbacks, restarting after a node crash, how many instances of your flow there are running and so on.
net.corda.core.flows.FlowLogicRef | A class representing a FlowLogic instance which would be possible to safely pass out of the contract sandbox.
net.corda.core.flows.FlowLogicRefFactory | A class for conversion to and from FlowLogic and FlowLogicRef instances.
net.corda.node.services.statemachine.FlowSession |
net.corda.node.services.statemachine.FlowSessionException |
net.corda.node.services.statemachine.FlowSessionState | FlowSessionState describes the session's state.
net.corda.core.flows.FlowStateMachine | This is an internal interface that is implemented by code in the node module. You should look at FlowLogic.
net.corda.node.services.statemachine.FlowStateMachineImpl |
net.corda.client.model.FlowStatus |
net.corda.core.contracts.Frequency | Frequency at which an event occurs - the enumerator also casts to an integer specifying the number of times per year that would divide into (eg annually = 1, semiannual = 2, monthly = 12 etc).
net.corda.node.services.config.FullNodeConfiguration | baseDirectory is not retrieved from the config file but rather from a command line argument.
kotlin.Function1 (extensions in package net.corda.client.fxutils) |
kotlin.Function2 (extensions in package net.corda.client.fxutils) |
kotlin.Function3 (extensions in package net.corda.client.fxutils) |
kotlin.Function4 (extensions in package net.corda.client.fxutils) |
net.corda.core.contracts.FungibleAsset | Interface for contract states representing assets which are fungible, countable and issued by a specific party. States contain assets which are equivalent (such as cash of the same currency), so records of their existence can be merged or split as needed where the issuer is the same. For instance, dollars issued by the Fed are fungible and countable (in cents), barrels of West Texas crude are fungible and countable (oil from two small containers can be poured into one large container), shares of the same class in a specific company are fungible and countable, and so on.
java.util.concurrent.Future (extensions in package net.corda.core) |
net.corda.client.model.GatheredTransactionData |
com.pholser.junit.quickcheck.generator.Generator (extensions in package net.corda.core.testing) |
net.corda.client.mock.Generator | This file defines a basic Generator library for composing random generators of objects.
net.corda.core.serialization.GlobalTransientClassWhiteList |
net.corda.core.contracts.clauses.GroupClauseVerifier |
net.corda.node.utilities.registration.HTTPNetworkRegistrationService |
net.corda.node.services.schema.HibernateObserver | A vault observer that extracts Object Relational Mappings for contract states that support it, and persists them with Hibernate.
net.corda.core.node.services.IdentityService | An identity service maintains an bidirectional map of Partys to their associated public keys and thus supports lookup of a party given its key. This is obviously very incomplete and does not reflect everything a real identity service would provide.
net.corda.core.flows.IllegalFlowLogicException |
net.corda.core.serialization.ImmutableClassSerializer | Serializes properties and deserializes by using the constructor. This assumes that all backed properties are set via the constructor and the class is immutable.
net.corda.node.services.identity.InMemoryIdentityService | Simple identity service which caches parties and provides functionality for efficient lookup.
net.corda.node.services.network.InMemoryNetworkMapCache | Extremely simple in-memory cache of the network map.
net.corda.node.services.network.InMemoryNetworkMapService |
net.corda.node.services.persistence.InMemoryStateMachineRecordedTransactionMappingStorage | This is a temporary in-memory storage of a state machine id -> txhash mapping
net.corda.node.services.transactions.InMemoryUniquenessProvider | A dummy Uniqueness provider that stores the whole history of consumed states in memory
com.esotericsoftware.kryo.io.Input (extensions in package net.corda.core.serialization) |
java.io.InputStream (extensions in package net.corda.core) |
net.corda.core.serialization.InputStreamSerializer |
net.corda.node.utilities.InstantColumnType | ColumnType for marshalling to/from database on behalf of java.time.Instant.
net.corda.core.schemas.requery.converters.InstantConverter | Converts from a Instant to a java.sql.Timestamp for Java 8. Note that when converting between the time type and the database type all times will be converted to the UTC zone offset.
net.corda.core.testing.InstantGenerator |
net.corda.core.contracts.InsufficientBalanceException |
kotlin.Int (extensions in package net.corda.core.contracts) |
kotlin.Int (extensions in package net.corda.core) |
net.corda.core.math.Interpolator |
net.corda.core.math.InterpolatorFactory |
net.corda.core.contracts.IssuanceDefinition | Marker interface for data classes that represent the issuance state for a contract. These are intended as templates from which the state object is initialised.
net.corda.core.contracts.IssueCommand | A common issue command, to enforce that issue commands have a nonce value.
net.corda.contracts.testing.IssueGenerator |
net.corda.core.contracts.Issued | Definition for an issued product, which can be cash, a cash-like thing, assets, or generally anything else that's quantifiable with integer quantities.
net.corda.core.testing.IssuedGenerator |
net.corda.flows.IssuerFlow | This flow enables a client to request issuance of some FungibleAsset from a server acting as an issuer (see Issued) of FungibleAssets.
kotlin.collections.Iterable (extensions in package net.corda.core.contracts) |
kotlin.collections.Iterable (extensions in package net.corda.core.crypto) |
kotlin.collections.Iterable (extensions in package net.corda.core.node.services) |
kotlin.collections.Iterable (extensions in package net.corda.core) |
kotlin.collections.Iterable (extensions in package net.corda.contracts.asset) |
net.corda.node.utilities.JDBCHashMap | A convenient JDBC table backed hash map with iteration order based on insertion order. See AbstractJDBCHashMap for further implementation details.
net.corda.node.utilities.JDBCHashSet | A convenient JDBC table backed hash set with iteration order based on insertion order. See AbstractJDBCHashSet and AbstractJDBCHashMap for further implementation details.
net.corda.node.utilities.JDBCHashedTable |
net.corda.core.node.services.KeyManagementService | The KMS is responsible for storing and using private keys to sign things. An implementation of this may, for example, call out to a hardware security module that enforces various auditing and frequency-of-use requirements.
java.security.KeyPair (extensions in package net.corda.core.crypto) |
net.corda.node.services.database.KotlinConfigurationTransactionWrapper | Requery KotlinConfiguration wrapper class to enable us to pass in an existing database connection and associated transaction context.
net.corda.core.serialization.KotlinObjectSerializer | Serializer to deserialize kotlin object definitions marked with DeserializeAsKotlinObjectDef.
com.esotericsoftware.kryo.Kryo (extensions in package net.corda.core.serialization) |
net.corda.core.serialization.KryoSerializationCustomization |
net.corda.node.services.network.LastAcknowledgeInfo |
net.corda.core.transactions.LedgerTransaction | A LedgerTransaction is derived from a WireTransaction. It is the result of doing the following operations:
net.corda.client.fxutils.LeftOuterJoinedMap | LeftOuterJoinedMap implements a special case of a left outer join where we're matching on primary keys of both tables.
net.corda.core.math.LinearInterpolator | Interpolates values between the given data points using straight lines.
net.corda.core.contracts.LinearState | A state that evolves by superseding itself, all of which share the common "linearId".
kotlin.collections.List (extensions in package net.corda.core) |
com.google.common.util.concurrent.ListenableFuture (extensions in package net.corda.core) |
java.time.LocalDate (extensions in package net.corda.core.contracts) |
net.corda.node.utilities.LocalDateColumnType | ColumnType for marshalling to/from database on behalf of java.time.LocalDate.
net.corda.node.utilities.LocalDateTimeColumnType | ColumnType for marshalling to/from database on behalf of java.time.LocalDateTime.
net.corda.core.utilities.LogHelper | A configuration helper that allows modifying the log level for specific loggers
org.slf4j.Logger (extensions in package net.corda.core.utilities) |
org.slf4j.Logger (extensions in package net.corda.core) |
net.corda.core.serialization.LoggingWhitelist | This class is not currently used, but can be installed to log a large number of missing entries from the whitelist and was used to track down the initial set.
kotlin.Long (extensions in package net.corda.core) |
net.corda.client.fxutils.MapValuesList | MapValuesList takes an ObservableMap and returns its values as an ObservableList. The order of returned elements is deterministic but unspecified.
net.corda.client.fxutils.MappedList | This is a variant of EasyBind.map where the mapped list is backed, therefore the mapping function will only be run when an element is inserted or updated. Use this instead of EasyBind.map to trade off memory vs CPU, or if (god forbid) the mapped function is side-effecting.
net.corda.core.schemas.MappedSchema | A database schema that might be configured for this node. As well as a name and version for identifying the schema, also list the classes that may be used in the generated object graph in order to configure the ORM tool.
net.corda.node.services.messaging.MarshalledObservation | Used in the RPC wire protocol to wrap an observation with the handle of the observable it's intended for.
net.corda.core.crypto.MerkleTree | Creation and verification of a Merkle Tree for a Wire Transaction.
net.corda.core.crypto.MerkleTreeException |
net.corda.core.messaging.Message | A message is defined, at this level, to be a (topic, timestamp, byte arrays) triple, where the topic is a string in Java-style reverse dns form, with "platform." being a prefix reserved by the platform for its own use. Vendor specific messages can be defined, but use your domain name as the prefix e.g. "uk.co.bigbank.messages.SomeMessage".
net.corda.core.messaging.MessageHandlerRegistration |
net.corda.core.messaging.MessageRecipientGroup | A base class for a set of recipients specifically identified by the sender.
net.corda.core.messaging.MessageRecipients | The interface for a group of message recipients (which may contain only one recipient)
net.corda.core.messaging.MessagingService | A MessagingService sits at the boundary between a message routing / networking layer and the core platform code.
net.corda.node.services.api.MessagingServiceBuilder | This class lets you start up a MessagingService. Its purpose is to stop you from getting access to the methods on the messaging service interface until you have successfully started up the system. One of these objects should be the only way to obtain a reference to a MessagingService. Startup may be a slow process: some implementations may let you cast the returned future to an object that lets you get status info.
net.corda.node.services.api.MessagingServiceInternal |
net.corda.core.serialization.MissingAttachmentsException | Thrown during deserialisation to indicate that an attachment needed to construct the WireTransaction is not found
net.corda.client.model.Models |
net.corda.node.services.api.MonitoringService | Provides access to various metrics and ways to notify monitoring services of things, for sysadmin purposes. This is not an interface because it is too lightweight to bother mocking out.
net.corda.core.contracts.MoveCommand | A common move command for contract states which can change owner.
net.corda.contracts.testing.MoveGenerator |
net.corda.contracts.clause.MultilateralNetState | Subset of state, containing the elements which must match for two or more obligation transactions to be candidates for netting (this does not include the checks to enforce that everyone's amounts received are the same at the end, which is handled under the verify() function). In comparison to BilateralNetState, this doesn't include the parties' keys, as ensuring balances match on input and output is handled elsewhere. Used in cases where all parties (or their proxies) are signing, such as central clearing.
net.corda.core.contracts.MultilateralNettableState | Interface for state objects that support being netted with other state objects.
net.corda.core.serialization.MutableClassWhitelist |
net.corda.node.utilities.MutableClock | An abstract class with helper methods for a type of Clock that might have it's concept of "now" adjusted externally.
net.corda.core.contracts.NamedByHash | Implemented by anything that can be named by a secure hash value (e.g. transactions, attachments).
net.corda.contracts.clause.NetClause | Clause for netting contract states. Currently only supports obligation contract.
net.corda.core.contracts.NetCommand | A common netting command for contracts whose states can be netted.
net.corda.contracts.clause.NetState | Common interface for the state subsets used when determining nettability of two or more states. Exposes the underlying issued thing.
net.corda.core.contracts.NetType | Enum for the types of netting that can be applied to state objects. Exact behaviour for each type of netting is left to the contract to determine.
net.corda.core.contracts.NettableState |
net.corda.core.node.services.NetworkCacheError |
net.corda.client.model.NetworkIdentityModel |
net.corda.core.node.services.NetworkMapCache | A network map contains lists of nodes on the network along with information about their identity keys, services they provide and host names or IP addresses where they can be connected to. The cache wraps around a map fetched from an authoritative service, and adds easy lookup of the data stored within it. Generally it would be initialised with a specified network map service, which it fetches data from and then subscribes to updates of.
net.corda.node.internal.NetworkMapInfo |
net.corda.node.services.network.NetworkMapService | A network map contains lists of nodes on the network along with information about their identity keys, services they provide and host names or IP addresses where they can be connected to. This information is cached locally within nodes, by the NetworkMapCache. Currently very basic consensus controls are applied, using signed changes which replace each other based on a serial number present in the change.
net.corda.node.utilities.registration.NetworkRegistrationHelper | This checks the config.certificatesDirectory for certificates required to connect to a Corda network. If the certificates are not found, a PKCS10CertificationRequest will be submitted to Corda network permissioning server using NetworkRegistrationService. This process will enter a polling loop until the request has been approved, and then the certificate chain will be downloaded and stored in Keystore reside in config.certificatesDirectory.
net.corda.node.utilities.registration.NetworkRegistrationService |
net.corda.core.serialization.NoReferencesSerializer |
net.corda.contracts.clause.NoZeroSizedOutputs | Clause for fungible asset contracts, which enforces that no output state should have a balance of zero.
net.corda.node.internal.Node | A Node manages a standalone server that takes part in the P2P network. It creates the services found in ServiceHub, loads important data off disk and starts listening for connections.
net.corda.node.services.persistence.NodeAttachmentService | Stores attachments in the specified local directory, which must exist. Doesn't allow new attachments to be uploaded.
net.corda.node.serialization.NodeClock | A Clock that tokenizes itself when serialized, and delegates to an underlying Clock implementation.
net.corda.node.services.config.NodeConfiguration |
net.corda.node.driver.NodeHandle |
net.corda.core.node.NodeInfo | Info about a network node that acts on behalf of some form of contract party.
net.corda.node.services.messaging.NodeLoginModule | Clients must connect to us with a username and password and must use TLS. If a someone connects with ArtemisMessagingComponent.NODE_USER then we confirm it's just us as the node by checking their TLS certificate is the same as our one in our key store. Then they're given full access to all valid queues. If they connect with ArtemisMessagingComponent.PEER_USER then we confirm they belong on our P2P network by checking their root CA is the same as our root CA. If that's the case the only access they're given is the ablility send to our P2P address. In both cases the messages these authenticated nodes send to us are tagged with their subject DN and we assume the CN within that is their legal name. Otherwise if the username is neither of the above we assume it's an RPC user and authenticate against our list of valid RPC users. RPC clients are given permission to perform RPC and nothing else.
net.corda.node.services.network.NodeMapError |
net.corda.node.services.messaging.NodeMessagingClient | This class implements the MessagingService API using Apache Artemis, the successor to their ActiveMQ product. Artemis is a message queue broker and here we run a client connecting to the specified broker instance ArtemisMessagingServer. It's primarily concerned with peer-to-peer messaging.
net.corda.client.model.NodeMonitorModel | This model exposes raw event streams to and from the node.
net.corda.node.services.network.NodeRegistration | A node registration state in the network map.
net.corda.node.services.network.NodeRegistrationInfo |
net.corda.node.services.events.NodeSchedulerService | A first pass of a simple SchedulerService that works with MutableClocks for testing, demonstrations and simulations that also encompasses the Vault observer for processing transactions.
net.corda.node.services.schema.NodeSchemaService | Most basic implementation of SchemaService.
net.corda.node.services.vault.NodeVaultService | Currently, the node vault service is a very simple RDBMS backed implementation. It will change significantly when we add further functionality as the design for the vault and vault service matures.
net.corda.core.utilities.NonEmptySet | A set which is constrained to ensure it can never be empty. An initial value must be provided at construction, and attempting to remove the last element will cause an IllegalStateException. The underlying set is exposed for Kryo to access, but should not be accessed directly.
net.corda.core.utilities.NonEmptySetSerializer | Custom serializer which understands it has to read in an item before trying to construct the set.
net.corda.flows.NonValidatingNotaryFlow |
net.corda.node.services.statemachine.NormalSessionEnd |
net.corda.node.services.NotaryChange |
net.corda.flows.NotaryChangeFlow | A flow to be used for changing a state's Notary. This is required since all input states to a transaction must point to the same notary.
net.corda.flows.NotaryError |
net.corda.flows.NotaryException |
net.corda.flows.NotaryFlow |
net.corda.node.services.transactions.NotaryService | A Notary service acts as the final signer of a transaction ensuring two things:
net.corda.core.crypto.NullPublicKey |
net.corda.core.crypto.NullSignature | A signature with a key and value of zero. Useful when you want a signature object that you know won't ever be used.
net.corda.contracts.asset.Obligation | An obligation contract commits the obligor to delivering a specified amount of a fungible asset (for example the Cash contract) at a specified future point in time. Settlement transactions may split and merge contracts across multiple input and output states. The goal of this design is to handle amounts owed, and these contracts are expected to be netted/merged, with settlement only for any remainder amount.
rx.Observable (extensions in package net.corda.core) |
rx.Observable (extensions in package net.corda.client.fxutils) |
rx.Observable (extensions in package net.corda.node.utilities) |
javafx.collections.ObservableList (extensions in package net.corda.client.fxutils) |
javafx.collections.ObservableMap (extensions in package net.corda.client.fxutils) |
javafx.beans.value.ObservableValue (extensions in package net.corda.client.fxutils) |
rx.Observer (extensions in package net.corda.core) |
rx.Observer (extensions in package net.corda.node.utilities) |
net.corda.contracts.asset.OnLedgerAsset | An asset transaction may split and merge assets represented by a set of (issuer, depositRef) pairs, across multiple input and output states. Imagine a Bitcoin transaction but in which all UTXOs had a colour (a blend of issuer+depositRef) and you couldn't merge outputs of two colours together, but you COULD put them in the same transaction.
net.corda.core.serialization.OpaqueBytes | A simple class that wraps a byte array and makes the equals/hashCode/toString methods work as you actually expect. In an ideal JVM this would be a value type and be completely overhead free. Project Valhalla is adding such functionality to Java, but it won't arrive for a few years yet!
net.corda.node.services.config.OptionalConfig | Helper class for optional configurations
net.corda.core.serialization.OrderedSerializer |
com.esotericsoftware.kryo.io.Output (extensions in package net.corda.core.serialization) |
net.corda.core.contracts.OwnableState | A contract state that can have a single owner.
net.corda.core.crypto.PartialMerkleTree | Building and verification of Partial Merkle Tree. Partial Merkle Tree is a minimal tree needed to check that a given set of leaves belongs to a full Merkle Tree.
net.corda.client.model.PartiallyResolvedTransaction | PartiallyResolvedTransaction holds a SignedTransaction that has zero or more inputs resolved. The intent is to prepare clients for cases where an input can only be resolved in the future/cannot be resolved at all (for example because of permissioning)
net.corda.core.crypto.Party | The Party class represents an entity on the network, which is typically identified by a legal name and public key that it can sign transactions under. As parties may use multiple keys for signing and, for example, have offline backup keys, the "public key" of a party is represented by a composite construct – a CompositeKey, which combines multiple cryptographic public key primitives into a tree structure.
net.corda.core.contracts.PartyAndReference | Reference to something being stored or issued by a party e.g. in a vault or (more likely) on their normal ledger. The reference is intended to be encrypted so it's meaningless to anyone other than the party.
net.corda.core.testing.PartyAndReferenceGenerator |
net.corda.node.utilities.PartyColumns |
net.corda.core.testing.PartyGenerator |
net.corda.core.node.services.PartyInfo | Holds information about a Party, which may refer to either a specific node or a service.
java.nio.file.Path (extensions in package net.corda.core) |
net.corda.core.contracts.PaymentRule | Whether the payment should be made before the due date, or after it.
net.corda.node.services.messaging.PermissionException |
net.corda.node.services.keys.PersistentKeyManagementService | A persistent re-implementation of E2ETestKeyManagementService to support node re-start.
net.corda.node.services.network.PersistentNetworkMapService | A network map service backed by a database to survive restarts of the node hosting it.
net.corda.core.schemas.PersistentState | A super class for all mapped states exported to a schema that ensures the StateRef appears on the database row. The StateRef will be set to the correct value by the framework (there's no need to set during mapping generation by the state itself).
net.corda.core.schemas.PersistentStateRef | Embedded StateRef representation used in state mapping.
net.corda.node.services.transactions.PersistentUniquenessProvider | A RDBMS backed Uniqueness provider
net.corda.core.node.PhysicalLocation | A labelled WorldCoordinate, where the label is human meaningful. For example, the name of the nearest city. Labels should not refer to non-landmarks, for example, they should not contain the names of organisations.
net.corda.core.node.PluginServiceHub | A service hub to be used by the CordaPluginRegistry
net.corda.core.math.Polynomial | Represents a polynomial function of arbitrary degree.
net.corda.node.driver.PortAllocation |
java.security.PrivateKey (extensions in package net.corda.core.crypto) |
net.corda.core.testing.PrivateKeyGenerator |
net.corda.core.utilities.ProgressTracker | A progress tracker helps surface information about the progress of an operation to a user interface or API of some kind. It lets you define a set of steps that represent an operation. A step is represented by an object (typically a singleton).
net.corda.client.model.ProgressTrackingEvent |
java.security.PublicKey (extensions in package net.corda.core.crypto) |
net.corda.node.utilities.PublicKeyColumnType | ColumnType for marshalling to/from database on behalf of PublicKey.
net.corda.core.testing.PublicKeyGenerator |
net.corda.core.schemas.QueryableState | A contract state that may be mapped to database schemas configured for this node to support querying for, or filtering of, states.
net.corda.node.services.messaging.RPCDispatcher | Intended to service transient clients only (not p2p nodes) for short-lived, transient request/response pairs. If you need robustness, this is the wrong system. If you don't want a response, this is probably the wrong system (you could just send a message). If you want complex customisation of how requests/responses are handled, this is probably the wrong system.
net.corda.node.services.messaging.RPCException | Thrown to indicate a fatal error in the RPC system itself, as opposed to an error generated by the invoked method.
net.corda.core.messaging.RPCOps | Base interface that all RPC servers must implement. Note: in Corda there's only one RPC interface. This base interface is here in case we split the RPC system out into a separate library one day.
net.corda.core.messaging.RPCReturnsObservables | If an RPC is tagged with this annotation it may return one or more observables anywhere in its response graph. Calling such a method comes with consequences: it's slower, and consumes server side resources as observations will buffer up on the server until they're consumed by the client.
net.corda.node.services.messaging.RPCSinceVersion | Records the protocol version in which this RPC was added.
net.corda.node.services.RPCUserService | Service for retrieving User objects representing RPC users who are authorised to use the RPC system. A User contains their login username and password along with a set of permissions for RPC services they are allowed access to. These permissions are represented as Strings to allow RPC implementations to add their own permissioning.
net.corda.node.services.RPCUserServiceImpl |
net.corda.node.services.transactions.RaftUniquenessProvider | A uniqueness provider that records committed input states in a distributed collection replicated and persisted in a Raft cluster, using the Copycat framework (http://atomix.io/copycat/).
net.corda.node.services.transactions.RaftValidatingNotaryService | A validating notary service operated by a group of mutually trusting parties, uses the Raft algorithm to achieve consensus.
net.corda.client.fxutils.ReadOnlyBackedObservableMapBase | ReadOnlyBackedObservableMapBase is a base class implementing all abstract functions required for an ObservableMap using a backing HashMap that subclasses should modify.
net.corda.core.node.services.ReadOnlyTransactionStorage | Thread-safe storage of transactions.
net.corda.node.services.statemachine.ReceiveOnly |
net.corda.node.services.statemachine.ReceiveRequest |
net.corda.core.messaging.ReceivedMessage |
net.corda.node.services.statemachine.ReceivedSessionMessage |
net.corda.core.serialization.ReferencesAwareJavaSerializer | Improvement to the builtin JavaSerializer by honouring the Kryo.getReferences setting.
net.corda.node.services.api.RegulatorService | Placeholder interface for regulator services.
net.corda.client.fxutils.ReplayedList | This list type just replays changes propagated from the underlying source list. Used for testing changes and backing a non-backed observable
net.corda.core.schemas.requery.Requery |
net.corda.node.services.database.RequeryConfiguration |
net.corda.node.services.transactions.Request | Sent from BFTSmartClient to BFTSmartServer
net.corda.node.services.transactions.RequestType |
net.corda.core.contracts.Requirements |
net.corda.flows.ResolveTransactionsFlow | This flow is used to verify the validity of a transaction by recursively checking the validity of all the dependencies. Once a transaction is checked it's inserted into local storage so it can be relayed and won't be checked again.
net.corda.core.RetryableException | This represents a transient exception or condition that might no longer be thrown if the operation is re-run or called again.
net.corda.node.services.config.SSLConfiguration |
net.corda.core.contracts.SchedulableState |
net.corda.core.contracts.Scheduled | Something which is scheduled to happen at a point in time
net.corda.core.contracts.ScheduledActivity | This class represents the lifecycle activity that a contract state of type LinearState would like to perform at a given point in time. e.g. run a fixing flow.
net.corda.node.services.events.ScheduledActivityObserver | This observes the vault and schedules and unschedules activities appropriately based on state production and consumption.
net.corda.core.contracts.ScheduledStateRef | Represents a contract state (unconsumed output) of type LinearState and a point in time that a lifecycle event is expected to take place for that contract state.
net.corda.core.node.services.SchedulerService | Provides access to schedule activity at some point in time. This interface might well be expanded to increase the feature set in the future.
net.corda.node.services.api.SchemaService | A configuration and customisation point for Object Relational Mapping of contract state objects.
net.corda.core.crypto.SecureHash | Container for a cryptographically secure hash value. Provides utilities for generating a cryptographic hash using different algorithms (currently only SHA-256 supported).
net.corda.node.utilities.SecureHashColumnType | ColumnType for marshalling to/from database on behalf of SecureHash.
net.corda.core.testing.SecureHashGenerator |
net.corda.node.services.statemachine.SendAndReceive |
net.corda.node.services.statemachine.SendOnly |
net.corda.node.services.statemachine.SendRequest |
net.corda.core.serialization.SerializationCustomization |
net.corda.core.serialization.SerializationToken | This represents a token in the serialized stream for an instance of a type that implements SerializeAsToken.
net.corda.core.serialization.SerializeAsToken | This interface should be implemented by classes that want to substitute a token representation of themselves if they are serialized because they have a lot of internal state that does not serialize (well).
net.corda.core.serialization.SerializeAsTokenContext | A context for mapping SerializationTokens to/from SerializeAsTokens.
net.corda.core.serialization.SerializeAsTokenSerializer | A Kryo serializer for SerializeAsToken implementations.
net.corda.core.serialization.SerializedBytes | A type safe wrapper around a byte array that contains a serialised object. You can call SerializedBytes.deserialize to get the original object back.
net.corda.core.serialization.SerializedBytesSerializer | A serialiser that avoids writing the wrapper class to the byte stream, thus ensuring SerializedBytes is a pure type safety hack.
net.corda.core.node.ServiceEntry | Information for an advertised service including the service specific identity information. The identity can be used in flows and is distinct from the Node's legalIdentity
net.corda.core.node.ServiceHub | A service hub simply vends references to the other services a node has. Some of those services may be missing or mocked out. This class is useful to pass to chunks of pluggable code that might have need of many different kinds of functionality and you don't want to hard-code which types in the interface.
net.corda.node.services.api.ServiceHubInternal |
net.corda.node.utilities.ServiceIdentityGenerator |
net.corda.core.node.services.ServiceInfo | A container for additional information for an advertised service.
net.corda.flows.ServiceRequestMessage | Abstract superclass for request messages sent to services which expect a reply.
net.corda.core.node.services.ServiceType | Identifier for service types a node can expose over the network to other peers. These types are placed into network map advertisements. Services that are purely local and are not providing functionality to other parts of the network don't need a declared service type.
net.corda.core.node.ServicesForResolution | Subset of node services that are used for loading transactions from the wire into fully resolved, looked up forms ready for verification.
net.corda.node.services.statemachine.SessionConfirm |
net.corda.node.services.statemachine.SessionData |
net.corda.node.services.statemachine.SessionEnd |
net.corda.node.services.statemachine.SessionInit |
net.corda.node.services.statemachine.SessionInitResponse |
net.corda.node.services.statemachine.SessionMessage |
net.corda.node.services.statemachine.SessionReject |
net.corda.node.services.statemachine.SessionedFlowIORequest |
com.google.common.util.concurrent.SettableFuture (extensions in package net.corda.core) |
net.corda.core.crypto.SignedData | A serialized piece of data and its signature. Enforces signature validity in order to deserialize the data contained within.
net.corda.core.transactions.SignedTransaction | SignedTransaction wraps a serialized WireTransaction. It contains one or more signatures, each one for a public key that is mentioned inside a transaction command. SignedTransaction is the top level transaction type and the type most frequently passed around the network and stored. The identity of a transaction is the hash of a WireTransaction, therefore if you are storing data keyed by WT hash be aware that multiple different STs may map to the same key (and they could be different in important ways, like validity!). The signatures on a SignedTransaction might be invalid or missing: the type does not imply validity. A transaction ID should be the hash of the WireTransaction Merkle tree root. Thus adding or removing a signature does not change it.
net.corda.contracts.testing.SignedTransactionGenerator |
net.corda.node.services.transactions.SimpleNotaryService | A simple Notary service that does not perform transaction validation
net.corda.core.messaging.SingleMessageRecipient | A base class for the case of point-to-point messages
net.corda.core.serialization.SingletonSerializationToken | A class representing a SerializationToken for some object that is not serializable but can be looked up (when deserialized) via just the class name.
net.corda.core.serialization.SingletonSerializeAsToken | A base class for implementing large objects / components / services that need to serialize themselves to a string token to indicate which instance the token is a serialized form of.
net.corda.core.math.SplineFunction | A spline is function piecewise-defined by polynomial functions. Points at which polynomial pieces connect are known as knots.
net.corda.node.services.statemachine.StackSnapshot |
net.corda.core.contracts.StateAndRef | A StateAndRef is simply a (state, ref) pair. For instance, a vault (which holds available assets) contains these.
net.corda.client.model.StateMachineData |
net.corda.core.messaging.StateMachineInfo |
net.corda.node.services.statemachine.StateMachineManager | A StateMachineManager is responsible for coordination and persistence of multiple FlowStateMachine objects. Each such object represents an instantiation of a (two-party) flow that has reached a particular point.
net.corda.core.node.services.StateMachineRecordedTransactionMappingStorage | This is the interface to storage storing state machine -> recorded tx mappings. Any time a transaction is recorded during a flow run addMapping should be called.
net.corda.core.flows.StateMachineRunId | A unique identifier for a single state machine run, valid across node restarts. Note that a single run always has at least one flow, but that flow may also invoke sub-flows: they all share the same run id.
net.corda.client.model.StateMachineStatus |
net.corda.core.node.services.StateMachineTransactionMapping |
net.corda.core.messaging.StateMachineUpdate |
net.corda.core.contracts.StateRef | A stateref is a pointer (reference) to a state, this is an equivalent of an "outpoint" in Bitcoin. It records which transaction defined the state and where in that transaction it was.
net.corda.node.utilities.StateRefColumns |
net.corda.core.schemas.requery.converters.StateRefConverter | Converts from a StateRef to a Composite Key defined by a String txnHash and an Int index
net.corda.core.testing.StateRefGenerator |
net.corda.flows.StateReplacementException |
net.corda.core.node.services.StorageService | A sketch of an interface to a simple key/value storage system. Intended for persistence of simple blobs like transactions, serialised flow state machines and so on. Again, this isn't intended to imply lack of SQL or anything like that, this interface is only big enough to support the prototyping work.
net.corda.node.services.persistence.StorageServiceImpl |
net.corda.node.utilities.StrandLocalTransactionManager | A relatively close copy of the ThreadLocalTransactionManager in Exposed but with the following adjustments to suit our environment:
kotlin.String (extensions in package net.corda.core.crypto) |
kotlin.String (extensions in package net.corda.core.serialization) |
kotlin.String (extensions in package net.corda.core) |
org.jetbrains.exposed.sql.Table (extensions in package net.corda.node.utilities) |
java.time.temporal.Temporal (extensions in package net.corda.core) |
net.corda.core.contracts.Tenor | Placeholder class for the Tenor datatype - which is a standardised duration of time until maturity
net.corda.node.utilities.TestClock | A Clock that can have the date advanced for use in demos.
net.corda.core.ThreadBox | A threadbox is a simple utility that makes it harder to forget to take a lock before accessing some shared state. Simply define a private class to hold the data that must be grouped under the same lock, and then pass the only instance to the ThreadBox constructor. You can now use the locked method with a lambda to take the lock in a way that ensures it'll be released if there's an exception.
kotlin.Throwable (extensions in package net.corda.core) |
net.corda.core.utilities.TimeWindow | A class representing a window in time from a particular instant, lasting a specified duration.
net.corda.core.contracts.Timestamp | If present in a transaction, contains a time that was verified by the uniqueness service. The true time must be between (after, before).
net.corda.core.node.services.TimestampChecker | Checks if the given timestamp falls within the allowed tolerance interval.
net.corda.core.testing.TimestampGenerator |
net.corda.core.messaging.TopicSession | An identifier for the endpoint MessagingService message handlers listen at.
net.corda.core.messaging.TopicStringValidator | A singleton that's useful for validating topic strings
net.corda.client.model.TrackedDelegate |
net.corda.core.transactions.TransactionBuilder | A TransactionBuilder is a transaction class that's mutable (unlike the others which are all immutable). It is intended to be passed around contracts that may edit it by adding new states/commands. Then once the states and commands are right, this class can be used as a holding bucket to gather signatures from multiple parties.
net.corda.core.contracts.TransactionConflictException |
net.corda.client.model.TransactionCreateStatus |
net.corda.client.model.TransactionDataModel | This model provides an observable list of transactions and what state machines/flows recorded them
net.corda.core.contracts.TransactionForContract | A transaction to be passed as input to a contract verification function. Defines helper methods to simplify verification logic in contracts.
net.corda.core.contracts.TransactionGraphSearch | Given a map of transaction id to SignedTransaction, performs a breadth first search of the dependency graph from the starting point down in order to find transactions that match the given query criteria.
net.corda.core.contracts.TransactionResolutionException |
net.corda.core.contracts.TransactionState | A wrapper for ContractState containing additional platform-level state information. This is the definitive state that is stored on the ledger and used in transaction outputs.
net.corda.core.testing.TransactionStateGenerator |
net.corda.core.node.services.TransactionStorage | Thread-safe storage of transactions.
net.corda.core.contracts.TransactionType | Defines transaction build & validation logic for a specific transaction type
net.corda.core.contracts.TransactionVerificationException |
net.corda.core.TransientProperty | A simple wrapper that enables the use of Kotlin's "val x by TransientProperty { ... }" syntax. Such a property will not be serialized to disk, and if it's missing (or the first time it's accessed), the initializer will be used to set it up. Note that the initializer will be called with the TransientProperty object locked.
net.corda.core.transactions.TraversableTransaction | Implemented by WireTransaction and FilteredLeaves. A TraversableTransaction allows you to iterate over the flattened components of the underlying transaction structure, taking into account that some may be missing in the case of this representing a "torn" transaction. Please see the user guide section "Transaction tear-offs" to learn more about this feature.
net.corda.flows.TwoPartyDealFlow | Classes for manipulating a two party deal or agreement.
net.corda.flows.TwoPartyTradeFlow | This asset trading flow implements a "delivery vs payment" type swap. It has two parties (B and S for buyer and seller) and the following steps:
net.corda.core.node.services.TxWritableStorageService | Storage service, with extensions to allow validated transactions to be added to. For use only within ServiceHub.
net.corda.node.utilities.TxnNoteColumns |
net.corda.core.contracts.TypeOnlyCommandData | Commands that inherit from this are intended to have no data items: it's only their presence that matters.
net.corda.node.utilities.UUIDStringColumnType | ColumnType for marshalling to/from database on behalf of UUID, always using a string representation.
net.corda.core.contracts.UniqueIdentifier | This class provides a truly unique identifier of a trade, state, or other business object, bound to any existing external ID. Equality and comparison are based on the unique ID only; if two states somehow have the same UUID but different external IDs, it would indicate a problem with handling of IDs.
net.corda.core.node.services.UniquenessException |
net.corda.core.node.services.UniquenessProvider | A service that records input states of the given transaction and provides conflict information if any of the inputs have already been used in another transaction.
net.corda.core.utilities.UntrustworthyData | A small utility to approximate taint tracking: if a method gives you back one of these, it means the data came from a remote source that may be incentivised to pass us junk that violates basic assumptions and thus must be checked first. The wrapper helps you to avoid forgetting this vital step. Things you might want to check are:
net.corda.core.contracts.UpgradeCommand | Indicates that this transaction replaces the inputs contract state to another contract state
net.corda.core.contracts.UpgradedContract | Interface which can upgrade state objects issued by a contract to a new state object issued by a different contract.
net.corda.node.services.User |
net.corda.flows.ValidatingNotaryFlow | A notary commit flow that makes sure a given transaction is valid before committing it. This does mean that the calling party has to reveal the whole transaction history; however, we avoid complex conflict resolution logic where a party has its input states "blocked" by a transaction from another party, and needs to establish whether that transaction was indeed valid.
net.corda.node.services.transactions.ValidatingNotaryService | A Notary service that validates the transaction chain of the submitted transaction before committing it
net.corda.core.node.services.Vault | A vault (name may be temporary) wraps a set of states that are useful for us to keep track of, for instance, because we own them. This class represents an immutable, stable state of a vault: it is guaranteed not to change out from underneath you, even though the canonical currently-best-known vault may change as we learn about new transactions from our peers and generate new transactions that consume states ourselves.
net.corda.core.node.services.VaultService | A VaultService is responsible for securely and safely persisting the current state of a vault to storage. The vault service vends immutable snapshots of the current vault for working with: if you build a transaction based on a vault that isn't current, be aware that it may end up being invalid if the states that were used have been consumed by someone else first!
net.corda.core.schemas.requery.converters.VaultStateStatusConverter | Converter which persists a Vault.StateStatus enum using its enum ordinal representation
net.corda.node.services.messaging.VerifyingNettyConnectorFactory |
net.corda.node.services.statemachine.WaitForLedgerCommit |
net.corda.node.services.statemachine.WaitingRequest |
net.corda.node.services.network.WireNodeRegistration | A node registration and its signature as a pair.
net.corda.core.transactions.WireTransaction | A transaction ready for serialisation, without any signatures attached. A WireTransaction is usually wrapped by a SignedTransaction that carries the signatures over this payload. The hash of the wire transaction is the identity of the transaction, that is, it's possible for two SignedTransactions with different sets of signatures to have the same identity hash.
net.corda.core.serialization.WireTransactionSerializer | A serialisation engine that knows how to deserialise code inside a sandbox
net.corda.contracts.testing.WiredTransactionGenerator |
net.corda.core.node.WorldCoordinate | A latitude/longitude pair.
org.bouncycastle.asn1.x500.X500Name (extensions in package net.corda.core.crypto) |
net.corda.core.crypto.X509Utilities |