All Types

com.r3corda.node.utilities.ANSIProgressObserver

This observes the StateMachineManager and follows the progress of ProtocolLogics until they complete in the order they are added to the StateMachineManager.

com.r3corda.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.

com.r3corda.node.api.APIServer

Top level interface to external interaction with the distributed ledger.

com.r3corda.node.internal.APIServerImpl
com.r3corda.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.

com.r3corda.contracts.clause.AbstractIssue

Standard issue clause for contracts that issue fungible assets.

com.r3corda.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.

com.r3corda.node.services.api.AbstractNodeService

Abstract superclass for services that a node can host, which provides helper functions.

com.r3corda.protocols.AbstractStateReplacementProtocol

Abstract protocol 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 protocols.

com.r3corda.node.services.api.AcceptsFileUpload

A service that implements AcceptsFileUpload can have new binary data provided to it via an HTTP upload.

com.r3corda.core.contracts.AccrualAdjustment

Simple enum for returning accurals adjusted or unadjusted. We dont actually do anything with this yet though, so its ignored for now.

com.r3corda.core.messaging.Ack

A general Ack message that conveys no content other than its 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.

com.r3corda.node.utilities.AddOrRemove

Enum for when adding/removing something, for example adding or removing an entry in a directory.

com.r3corda.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.

com.r3corda.core.messaging.AllPossibleRecipients

A special base class for the set of all possible recipients, without having to identify who they all are.

com.r3corda.core.testing.AlwaysSucceedContract
com.r3corda.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.

com.r3corda.core.protocols.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?

com.r3corda.node.services.messaging.ArtemisMessagingClient

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

com.r3corda.node.services.messaging.ArtemisMessagingComponent

The base class for Artemis services that defines shared data structures and transport configuration

com.r3corda.node.services.messaging.ArtemisMessagingServer

This class configures and manages an Apache Artemis message queue broker.

com.r3corda.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:

com.r3corda.node.servlets.AttachmentDownloadServlet

Allows the node administrator to either download full attachment zips, or individual files within those zips.

com.r3corda.core.testing.AttachmentResolutionException
com.r3corda.core.node.services.AttachmentStorage

An attachment store records potentially large binary objects, identified by their hash.

com.r3corda.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.

com.r3corda.core.contracts.AuthenticatedObject

Wraps an object that was signed by a public key, which may be a well known/recognised institutional key.

com.r3corda.demos.protocols.AutoOfferProtocol

This whole class is really part of a demo just to initiate the agreement of a deal with a simple API call from a single party without bi-directional access to the database of offers etc.

com.r3corda.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.

com.r3corda.core.contracts.BilateralNettableState

Interface for state objects that support being netted with other state objects.

com.r3corda.core.utilities.BriefLogFormatter

A Java logging formatter that writes more compact output than the default.

com.r3corda.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 com.r3corda.core.crypto)
kotlin.ByteArray (extensions in package com.r3corda.core.serialization)
com.r3corda.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 couldnt merge outputs of two colours together, but you COULD put them in the same transaction.

com.r3corda.node.services.wallet.CashBalanceAsMetricsObserver

This class observes the wallet and reflect current cash balances as exposed metrics in the monitoring service.

com.r3corda.node.services.api.Checkpoint
com.r3corda.node.services.api.CheckpointStorage

Thread-safe storage of fiber checkpoints.

com.r3corda.core.node.CityDatabase

A simple lookup table of city names to their coordinates. Lookups are case insensitive.

com.r3corda.core.contracts.clauses.Clause
com.r3corda.core.contracts.clauses.ClauseVerifier

Abstract superclass for clause-based contracts to extend, which provides a verify() function that delegates to the supplied list of clauses.

com.r3corda.demos.CliParams

Parsed command line parameters.

com.r3corda.demos.CliParamsSpec
java.time.Clock (extensions in package com.r3corda.node.utilities)
kotlin.collections.Collection (extensions in package com.r3corda.core.contracts)
com.r3corda.core.contracts.Command

Command data/content plus pubkey pair: the signature is stored at the end of the serialized bytes

com.r3corda.core.contracts.CommandData

Marker interface for classes that represent commands

com.r3corda.contracts.CommercialPaper
com.r3corda.contracts.CommercialPaperLegacy
com.r3corda.core.contracts.Commodity
com.r3corda.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).

com.r3corda.node.servlets.Config

Primary purpose is to install Kotlin extensions for Jackson ObjectMapper so data classes work and to organise serializers / deserializers for java.time.* classes as necessary.

com.r3corda.node.internal.ConfigurationException
com.r3corda.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.

com.r3corda.node.api.ContractClassRef
com.r3corda.node.api.ContractDefRef

Encapsulates the contract type. e.g. Cash or CommercialPaper etc.

com.r3corda.node.api.ContractLedgerRef
com.r3corda.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.

com.r3corda.core.node.CordaPluginRegistry

Implement this interface on a class advertised in a META-INF/services/com.r3corda.core.node.CordaPluginRegistry file to extend a Corda node with additional application services.

com.r3corda.core.math.CubicSplineInterpolator

Interpolates values between the given data points using a SplineFunction.

java.util.Currency (extensions in package com.r3corda.core.contracts)
com.r3corda.node.servlets.DataUploadServlet

Accepts binary streams, finds the right AcceptsFileUpload implementor and hands the stream off to it.

com.r3corda.node.services.persistence.DataVending
com.r3corda.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.

com.r3corda.core.contracts.DateRollDirection

This is utilised in the DateRollConvention class to determine which way we should initially step when finding a business day.

com.r3corda.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.

com.r3corda.core.contracts.DayCountBasisYear

This forms the year part of the "Day Count Basis" used for interest calculation.

com.r3corda.core.contracts.DealState

Interface representing an agreement that exposes various attributes that are common. Implementing it simplifies implementation of general protocols that manipulate many agreement types.

com.r3corda.demos.DemoClock

A Clock that can have the date advanced for use in demos.

com.r3corda.core.serialization.DeserializeAsKotlinObjectDef

Marker interface for kotlin object definitions so that they are deserialized as the singleton instance.

com.r3corda.core.crypto.DigitalSignature

A wrapper around a digital signature. The covering field is a generic tag usable by whatever is interpreting the signature. It isnt used currently, but experience from Bitcoin suggests such a feature is useful, especially when building partially signed transactions.

com.r3corda.protocols.DirectRequestMessage

A message which specifies reply destination as a specific endpoint such as a monitoring client. This is of particular use where we want to address a specific endpoint, not necessarily a specific user (for example if the same user logs in on two machines, we want to consistently deliver messages as part of a session, to the same machine the session started on).

kotlin.Double (extensions in package com.r3corda.core.contracts)
kotlin.Double (extensions in package com.r3corda.core)
com.r3corda.core.contracts.DummyContract
com.r3corda.core.testing.DummyLinearState
com.r3corda.core.crypto.DummyPublicKey
com.r3corda.core.contracts.DummyState

Dummy state for use in testing. Not part of any real contract.

com.r3corda.core.testing.DuplicateOutputLabel
com.r3corda.node.services.keys.E2ETestKeyManagementService

A simple in-memory KMS that doesnt bother saving keys to disk. A real implementation would:

com.r3corda.core.serialization.Ed25519PrivateKeySerializer

For serialising an ed25519 private key

com.r3corda.core.serialization.Ed25519PublicKeySerializer

For serialising an ed25519 public key

com.r3corda.core.utilities.Emoji

A simple wrapper class that contains icons and support for printing them only when were connected to a terminal.

com.r3corda.core.testing.EnforceVerifyOrFail

If you jumped here from a compiler error make sure the last line of your test tests for a transaction verify or fail. This is a dummy type that can only be instantiated by functions in this module. This way we can ensure that all tests will have as the last line either an accept or a failure test. The name is deliberately long to help make sense of the triggered diagnostic.

com.r3corda.contracts.Event

Event superclass - everything happens on a date.

com.r3corda.demos.protocols.ExitServerProtocol
com.r3corda.core.contracts.Expression

Represents a textual expression of e.g. a formula

com.r3corda.core.contracts.ExpressionDeserializer
com.r3corda.core.contracts.ExpressionSerializer
com.r3corda.protocols.FetchAttachmentsProtocol

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.

com.r3corda.protocols.FetchDataProtocol

An abstract protocol for fetching typed data from a remote peer.

com.r3corda.protocols.FetchTransactionsProtocol

Given a set of tx hashes (IDs), either loads them from local disk or asks the remote peer to provide them.

com.r3corda.node.utilities.FiberBox

Modelled on ThreadBox, but with support for waiting that is compatible with Quasar Fibers and MutableClocks.

com.r3corda.node.services.statemachine.FiberRequest
com.r3corda.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.

com.r3corda.core.contracts.FixOf

A FixOf identifies the question side of a fix: what day, tenor and type of fix ("LIBOR", "EURIBOR" etc)

com.r3corda.core.contracts.FixableDealState

Interface adding fixing specific methods.

com.r3corda.contracts.FixedRate

A very basic subclass to represent a fixed rate.

com.r3corda.contracts.FixedRatePaymentEvent

Basic class for the Fixed Rate Payments on the fixed leg - see RatePaymentEvent. Assumes that the rate is valid.

com.r3corda.node.services.clientapi.FixingSessionInitiation

This is a temporary handler required for establishing random sessionIDs for the Fixer and Floater as part of running scheduled fixings for the InterestRateSwap contract.

com.r3corda.contracts.FloatingRate

The parent class of the Floating rate classes.

com.r3corda.contracts.FloatingRatePaymentEvent

Basic class for the Floating Rate Payments on the floating leg - see RatePaymentEvent. If the rate is null returns a zero payment. // TODO: Is this the desired behaviour?

com.r3corda.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).

com.r3corda.node.services.config.FullNodeConfiguration
com.r3corda.contracts.asset.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.

com.r3corda.core.contracts.clauses.GroupClause
com.r3corda.core.contracts.clauses.GroupClauseVerifier
com.r3corda.core.contracts.clauses.GroupVerify
com.r3corda.demos.IRSDemoNode
com.r3corda.demos.IRSDemoPluginRegistry
com.r3corda.demos.IRSDemoRole

Roles. There are 4 modes this demo can be run:

com.r3corda.node.internal.testing.IRSSimulation

A simulation in which banks execute interest rate swaps with each other, including the fixing events.

com.r3corda.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.

com.r3corda.core.protocols.IllegalProtocolLogicException
com.r3corda.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.

com.r3corda.node.services.identity.InMemoryIdentityService

Simple identity service which caches parties and provides functionality for efficient lookup.

com.r3corda.node.services.network.InMemoryMessagingNetwork

An in-memory network allows you to manufacture InMemoryMessagings for a set of participants. Each InMemoryMessaging maintains a queue of messages it has received, and a background thread that dispatches messages one by one to registered handlers. Alternatively, a messaging system may be manually pumped, in which case no thread is created and a caller is expected to force delivery one at a time (this is useful for unit testing).

com.r3corda.node.services.network.InMemoryNetworkMapCache

Extremely simple in-memory cache of the network map.

com.r3corda.node.services.network.InMemoryNetworkMapService
com.r3corda.node.services.transactions.InMemoryUniquenessProvider

A dummy Uniqueness provider that stores the whole history of consumed states in memory

com.r3corda.core.testing.InMemoryWalletService

This class implements a simple, in memory wallet that tracks states that are owned by us, and also has a convenience method to auto-generate some self-issued cash states that can be used for test trading. A real wallet would persist states relevant to us into a database and once such a wallet is implemented, this scaffolding can be removed.

com.r3corda.contracts.asset.InsufficientBalanceException
kotlin.Int (extensions in package com.r3corda.core.contracts)
kotlin.Int (extensions in package com.r3corda.core)
kotlin.Int (extensions in package com.r3corda.contracts)
com.r3corda.core.contracts.clauses.InterceptorClause

A clause which intercepts calls to a wrapped clause, and passes them through verification only from a pre-clause. This is similar to an inceptor in aspect orientated programming.

com.r3corda.contracts.InterestRateSwap

The Interest Rate Swap class. For a quick overview of what an IRS is, see here - http://www.pimco.co.uk/EN/Education/Pages/InterestRateSwapsBasics1-08.aspx (no endorsement). This contract has 4 significant data classes within it, the "Common", "Calculation", "FixedLeg" and "FloatingLeg". It also has 4 commands, "Agree", "Fix", "Pay" and "Mature". Currently, we are not interested (excuse pun) in valuing the swap, calculating the PVs, DFs and all that good stuff (soon though). This is just a representation of a vanilla Fixed vs Floating (same currency) IRS in the R3 prototype model.

com.r3corda.demos.api.InterestRateSwapAPI

This provides a simplified API, currently for demonstration use only.

com.r3corda.core.math.Interpolator
com.r3corda.core.math.InterpolatorFactory
com.r3corda.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.

com.r3corda.core.contracts.IssueCommand

A common issue command, to enforce that issue commands have a nonce value.

com.r3corda.core.contracts.Issued

Definition for an issued product, which can be cash, a cash-like thing, assets, or generally anything else thats quantifiable with integer quantities.

kotlin.collections.Iterable (extensions in package com.r3corda.core.contracts)
kotlin.collections.Iterable (extensions in package com.r3corda.core.crypto)
kotlin.collections.Iterable (extensions in package com.r3corda.core)
kotlin.collections.Iterable (extensions in package com.r3corda.contracts.asset)
kotlin.collections.Iterable (extensions in package com.r3corda.node.internal.testing)
com.r3corda.node.utilities.JsonSupport

Utilities and serialisers for working with JSON representations of basic types. This adds Jackson support for the java.time API, some core types, and Kotlin data classes.

com.r3corda.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 com.r3corda.core.crypto)
com.r3corda.core.serialization.KotlinObjectSerializer

Serializer to deserialize kotlin object definitions marked with DeserializeAsKotlinObjectDef.

com.r3corda.core.testing.LedgerDSL

This is the class that defines the syntactic sugar of the ledger Test DSL and delegates to the contained interpreter, and what is actually used in ledger{(...)}. Add convenience functions here, or if you want to extend the DSL functionality then first add your primitive to LedgerDSLInterpreter and then add the convenience defaults/extension methods here.

com.r3corda.core.testing.LedgerDSLInterpreter

This interface defines the bare bone functionality that a Ledger DSL interpreter should implement.

com.r3corda.core.contracts.LedgerTransaction

A LedgerTransaction wraps the data needed to calculate one or more successor states from a set of input states. It is the first step after extraction from a WireTransaction. The signatures at this point have been lined up with the commands from the wire, and verified/looked up.

com.r3corda.core.math.LinearInterpolator

Interpolates values between the given data points using straight lines.

com.r3corda.core.contracts.LinearState

A state that evolves by superseding itself, all of which share the common "thread".

kotlin.collections.List (extensions in package com.r3corda.core.contracts)
kotlin.collections.List (extensions in package com.r3corda.core)
java.time.LocalDate (extensions in package com.r3corda.core.contracts)
kotlin.Long (extensions in package com.r3corda.core)
com.r3corda.core.contracts.clauses.MatchBehaviour
com.r3corda.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".

com.r3corda.core.messaging.MessageHandlerRegistration
com.r3corda.core.messaging.MessageRecipientGroup

A base class for a set of recipients specifically identified by the sender.

com.r3corda.core.messaging.MessageRecipients

The interface for a group of message recipients (which may contain only one recipient)

com.r3corda.core.messaging.MessagingService

A MessagingService sits at the boundary between a message routing / networking layer and the core platform code.

com.r3corda.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.

com.r3corda.node.services.api.MessagingServiceInternal
com.r3corda.core.serialization.MissingAttachmentsException

Thrown during deserialisation to indicate that an attachment needed to construct the WireTransaction is not found

com.r3corda.core.node.services.testing.MockAttachmentStorage
com.r3corda.core.node.services.testing.MockIdentityService
com.r3corda.core.node.services.testing.MockKeyManagementService
com.r3corda.node.internal.testing.MockNetwork

A mock node brings up a suite of in-memory services in a fast manner suitable for unit testing. Components that do IO are either swapped out for mocks, or pointed to a Jimfs in memory filesystem.

com.r3corda.node.services.network.MockNetworkMapCache

Network map cache with no backing map service.

com.r3corda.core.node.services.testing.MockServices

A singleton utility that only provides a mock identity, key and storage service. However, this is sufficient for building chains of transactions and verifying them. It isnt sufficient for testing protocols however.

com.r3corda.core.node.services.testing.MockStorageService
com.r3corda.core.node.services.testing.MockTransactionStorage
com.r3corda.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.

com.r3corda.core.contracts.MoveCommand

A common move command for contracts which can change owner.

com.r3corda.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 everyones amounts received are the same at the end, which is handled under the verify() function). In comparison to BilateralNetState, this doesnt 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.

com.r3corda.core.contracts.MultilateralNettableState

Interface for state objects that support being netted with other state objects.

com.r3corda.node.utilities.MutableClock

An abstract class with helper methods for a type of Clock that might have its concept of "now" adjusted externally.

com.r3corda.node.services.config.NameServiceConfig
com.r3corda.core.contracts.NamedByHash

Implemented by anything that can be named by a secure hash value (e.g. transactions, attachments).

com.r3corda.contracts.clause.NetClause

Clause for netting contract states. Currently only supports obligation contract.

com.r3corda.contracts.clause.NetState

Common interface for the state subsets used when determining nettability of two or more states. Exposes the underlying issued thing.

com.r3corda.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.

com.r3corda.core.contracts.NettableState
com.r3corda.core.node.services.NetworkCacheError
com.r3corda.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.

com.r3corda.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.

com.r3corda.core.serialization.NoReferencesSerializer
com.r3corda.contracts.clause.NoZeroSizedOutputs

Clause for fungible asset contracts, which enforces that no output state should have a balance of zero.

com.r3corda.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.

com.r3corda.node.services.persistence.NodeAttachmentService

Stores attachments in the specified local directory, which must exist. Doesnt allow new attachments to be uploaded.

com.r3corda.node.serialization.NodeClock

A Clock that tokenizes itself when serialized, and delegates to an underlying Clock implementation.

com.r3corda.node.services.config.NodeConfiguration
com.r3corda.node.services.config.NodeConfigurationFromConfig
com.r3corda.core.node.NodeInfo

Info about a network node that acts on behalf of some form of contract party.

com.r3corda.node.services.clientapi.NodeInterestRates

An interest rates service is an oracle that signs transactions which contain embedded assertions about an interest rate fix (e.g. LIBOR, EURIBOR ...).

com.r3corda.node.services.network.NodeMapError
com.r3corda.node.services.network.NodeRegistration

A node registration state in the network map.

com.r3corda.node.services.events.NodeSchedulerService

A first pass of a simple SchedulerService that works with MutableClocks for testing, demonstrations and simulations that also encompasses the Wallet observer for processing transactions.

com.r3corda.node.services.wallet.NodeWalletService

Currently, the node wallet service is just the in-memory wallet service until we have finished evaluating and selecting a persistence layer (probably an ORM over a SQL DB).

com.r3corda.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.

com.r3corda.core.utilities.NonEmptySetSerializer

Custom serializer which understands it has to read in an item before trying to construct the set.

com.r3corda.node.services.NotaryChange
com.r3corda.protocols.NotaryChangeProtocol

A protocol to be used for changing a states Notary. This is required since all input states to a transaction must point to the same notary.

com.r3corda.protocols.NotaryError
com.r3corda.protocols.NotaryException
com.r3corda.protocols.NotaryProtocol
com.r3corda.node.services.transactions.NotaryService

A Notary service acts as the final signer of a transaction ensuring two things:

com.r3corda.core.crypto.NullPublicKey
com.r3corda.core.crypto.NullSignature

A signature with a key and value of zero. Useful when you want a signature object that you know wont ever be used.

com.r3corda.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.

com.r3corda.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 couldnt merge outputs of two colours together, but you COULD put them in the same transaction.

com.r3corda.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 wont arrive for a few years yet

com.r3corda.core.testing.OutputStateLookup

This interface defines output state lookup by label. It is split from the interpreter interfaces so that outputs may be looked up both in ledger{..} and transaction{..} blocks.

com.r3corda.core.contracts.OwnableState

A contract state that can have a single owner.

com.r3corda.node.ParamsSpec
com.r3corda.core.crypto.Party

A Party is well known (name, pubkey) pair. In a real system this would probably be an X.509 certificate.

com.r3corda.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 its meaningless to anyone other than the party.

com.r3corda.protocols.PartyRequestMessage
java.nio.file.Path (extensions in package com.r3corda.core)
com.r3corda.contracts.PaymentEvent

Top level PaymentEvent class - represents an obligation to pay an amount on a given date, which may be either in the past or the future.

com.r3corda.core.contracts.PaymentRule

Whether the payment should be made before the due date, or after it.

com.r3corda.node.services.persistence.PerFileCheckpointStorage

File-based checkpoint storage, storing checkpoints per file.

com.r3corda.node.services.persistence.PerFileTransactionStorage

File-based transaction storage, storing transactions per file.

com.r3corda.contracts.PercentageRatioUnit

A class to reprecent a percentage in an unambiguous way.

com.r3corda.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.

com.r3corda.core.math.Polynomial

Represents a polynomial function of arbitrary degree.

java.security.PrivateKey (extensions in package com.r3corda.core.crypto)
com.r3corda.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).

com.r3corda.node.api.ProtocolClassRef
com.r3corda.node.api.ProtocolInstanceRef
com.r3corda.core.protocols.ProtocolLogic

A sub-class of ProtocolLogic implements a protocol flow using direct, straight line blocking code. Thus you can write complex protocol logic in an ordinary fashion, without having to think about callbacks, restarting after a node crash, how many instances of your protocol there are running and so on.

com.r3corda.core.protocols.ProtocolLogicRef

A class representing a ProtocolLogic instance which would be possible to safely pass out of the contract sandbox.

com.r3corda.core.protocols.ProtocolLogicRefFactory

A class for conversion to and from ProtocolLogic and ProtocolLogicRef instances.

com.r3corda.node.api.ProtocolRef

Encapsulates the protocol to be instantiated. e.g. TwoPartyTradeProtocol.Buyer.

com.r3corda.node.api.ProtocolRequiringAttention

Thinking that Instant is OK for short lived protocol deadlines.

com.r3corda.core.protocols.ProtocolStateMachine

The interface of ProtocolStateMachineImpl exposing methods and properties required by ProtocolLogic for compilation.

com.r3corda.node.services.statemachine.ProtocolStateMachineImpl

A ProtocolStateMachine instance is a suspendable fiber that delegates all actual logic to a ProtocolLogic instance. For any given flow there is only one PSM, even if that protocol invokes subprotocols.

java.security.PublicKey (extensions in package com.r3corda.core.crypto)
com.r3corda.contracts.Rate

Parent of the Rate family. Used to denote fixed rates, floating rates, reference rates etc.

com.r3corda.contracts.RatePaymentEvent

A RatePaymentEvent represents a dated obligation of payment. It is a specialisation / modification of a basic cash flow event (to be written) that has some additional assistance functions for interest rate swap legs of the fixed and floating nature. For the fixed leg, the rate is already known at creation and therefore the flows can be pre-determined. For the floating leg, the rate refers to a reference rate which is to be "fixed" at a point in the future.

com.r3corda.protocols.RatesFixProtocol

This protocol queries the given oracle for an interest rate fix, and if it is within the given tolerance embeds the fix in the transaction and then proceeds to get the oracle to sign it. Although the call method combines the query and signing step, you can run the steps individually by constructing this object and then using the public methods for each step.

com.r3corda.contracts.RatioUnit

A utility class to prevent the various mixups between percentages, decimals, bips etc.

com.r3corda.core.node.services.ReadOnlyTransactionStorage

Thread-safe storage of transactions.

com.r3corda.contracts.ReferenceRate

So a reference rate is a rate that takes its value from a source at a given date e.g. LIBOR 6M as of 17 March 2016. Hence it requires a source (name) and a value date in the getAsOf(..) method.

com.r3corda.core.serialization.ReferencesAwareJavaSerializer

Improvement to the builtin JavaSerializer by honouring the Kryo.getReferences setting.

com.r3corda.node.services.api.RegulatorService

Placeholder interface for regulator services.

com.r3corda.core.contracts.Requirements
com.r3corda.protocols.ResolveTransactionsProtocol

This protocol is used to verify the validity of a transaction by recursively checking the validity of all the dependencies. Once a transaction is checked its inserted into local storage so it can be relayed and wont be checked again.

com.r3corda.node.servlets.ResponseFilter

This adds headers needed for cross site scripting on API clients.

com.r3corda.core.RetryableException

This represents a transient exception or condition that might no longer be thrown if the operation is re-run or called again.

com.r3corda.demos.Role
com.r3corda.core.contracts.SchedulableState
com.r3corda.core.contracts.Scheduled

Something which is scheduled to happen at a point in time

com.r3corda.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 protocol.

com.r3corda.node.services.events.ScheduledActivityObserver

This observes the wallet and schedules and unschedules activities appropriately based on state production and consumption.

com.r3corda.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.

com.r3corda.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.

com.r3corda.core.crypto.SecureHash
com.r3corda.core.serialization.SerializationToken

This represents a token in the serialized stream for an instance of a type that implements SerializeAsToken.

com.r3corda.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).

com.r3corda.core.serialization.SerializeAsTokenContext

A context for mapping SerializationTokens to/from SerializeAsTokens.

com.r3corda.core.serialization.SerializeAsTokenSerializer

A Kryo serializer for SerializeAsToken implementations.

com.r3corda.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.

com.r3corda.core.serialization.SerializedBytesSerializer

A serialiser that avoids writing the wrapper class to the byte stream, thus ensuring SerializedBytes is a pure type safety hack.

com.r3corda.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 dont want to hard-code which types in the interface.

com.r3corda.node.services.api.ServiceHubInternal
com.r3corda.protocols.ServiceRequestMessage

Abstract superclass for request messages sent to services, which includes common fields such as replyTo and sessionID.

com.r3corda.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 dont need a declared service type.

com.r3corda.core.crypto.SignedData

A serialized piece of data and its signature. Enforces signature validity in order to deserialize the data contained within.

com.r3corda.core.contracts.SignedTransaction

Container for a WireTransaction and attached signatures.

com.r3corda.node.services.transactions.SimpleNotaryService

A simple Notary service that does not perform transaction validation

com.r3corda.node.internal.testing.Simulation

Base class for network simulations that are based on the unit test / mock environment.

com.r3corda.core.contracts.clauses.SingleClause
com.r3corda.core.messaging.SingleMessageRecipient

A base class for the case of point-to-point messages

com.r3corda.core.contracts.clauses.SingleVerify
com.r3corda.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.

com.r3corda.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.

com.r3corda.core.math.SplineFunction

A spline is function piecewise-defined by polynomial functions. Points at which polynomial pieces connect are known as knots.

com.r3corda.node.services.statemachine.StackSnapshot
com.r3corda.core.contracts.StateAndRef

A StateAndRef is simply a (state, ref) pair. For instance, a wallet (which holds available assets) contains these.

com.r3corda.node.services.statemachine.StateMachineManager

A StateMachineManager is responsible for coordination and persistence of multiple ProtocolStateMachine objects. Each such object represents an instantiation of a (two-party) protocol that has reached a particular point.

com.r3corda.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.

com.r3corda.protocols.StateReplacementException
com.r3corda.protocols.StateReplacementRefused

Thrown when a participant refuses the proposed state replacement

com.r3corda.node.api.StatesQuery

Extremely rudimentary query language which should most likely be replaced with a product.

com.r3corda.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 protocol state machines and so on. Again, this isnt intended to imply lack of SQL or anything like that, this interface is only big enough to support the prototyping work.

com.r3corda.node.services.persistence.StorageServiceImpl
kotlin.String (extensions in package com.r3corda.core)
kotlin.String (extensions in package com.r3corda.contracts)
java.time.temporal.Temporal (extensions in package com.r3corda.core)
com.r3corda.core.contracts.Tenor

Placeholder class for the Tenor datatype - which is a standardised duration of time until maturity

com.r3corda.node.internal.testing.TestClock

A Clock that can have the time advanced for use in testing.

com.r3corda.core.testing.TestLedgerDSLInterpreter
com.r3corda.core.testing.TestTransactionDSLInterpreter

This interpreter builds a transaction, and TransactionDSL.verifies that the resolved transaction is correct. Note that transactions corresponding to input states are not verified. Use LedgerDSL.verifies for that.

com.r3corda.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 itll be released if theres an exception.

com.r3corda.core.utilities.TimeWindow

A class representing a window in time from a particular instant, lasting a specified duration.

com.r3corda.core.node.services.TimestampChecker

Checks if the given timestamp falls within the allowed tolerance interval.

com.r3corda.core.contracts.TimestampCommand

If present in a transaction, contains a time that was verified by the timestamping authority/authorities whose public keys are identified in the containing Command object. The true time must be between (after, before).

com.r3corda.core.messaging.TopicSession

An identifier for the endpoint MessagingService message handlers listen at.

com.r3corda.core.messaging.TopicStringValidator

A singleton thats useful for validating topic strings

com.r3corda.node.internal.testing.TradeSimulation

Simulates a never ending series of trades that go pair-wise through the banks (e.g. A and B trade with each other, then B and C trade with each other, then C and A etc).

com.r3corda.node.api.TransactionBuildStep

Encapsulate a generateXXX method call on a contract.

com.r3corda.core.contracts.TransactionBuilder

A TransactionBuilder is a transaction class thats 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.

com.r3corda.core.contracts.TransactionConflictException
com.r3corda.core.testing.TransactionDSL
com.r3corda.core.testing.TransactionDSLInterpreter

This interface defines the bare bone functionality that a Transaction DSL interpreter should implement.

com.r3corda.core.contracts.TransactionForContract

A transaction to be passed as input to a contract verification function. Defines helper methods to simplify verification logic in contracts.

com.r3corda.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.

com.r3corda.core.contracts.TransactionResolutionException
com.r3corda.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.

com.r3corda.core.node.services.TransactionStorage

Thread-safe storage of transactions.

com.r3corda.core.contracts.TransactionType

Defines transaction build & validation logic for a specific transaction type

com.r3corda.core.contracts.TransactionVerificationException
com.r3corda.core.TransientProperty

A simple wrapper that enables the use of Kotlins "val x by TransientProperty { ... }" syntax. Such a property will not be serialized to disk, and if its missing (or the first time its accessed), the initializer will be used to set it up. Note that the initializer will be called with the TransientProperty object locked.

com.r3corda.protocols.TwoPartyDealProtocol

Classes for manipulating a two party deal or agreement.

com.r3corda.protocols.TwoPartyTradeProtocol

This asset trading protocol implements a "delivery vs payment" type swap. It has two parties (B and S for buyer and seller) and the following steps:

com.r3corda.core.node.services.TxWritableStorageService

Storage service, with extensions to allow validated transactions to be added to. For use only within ServiceHub.

com.r3corda.core.contracts.TypeOnlyCommandData

Commands that inherit from this are intended to have no data items: its only their presence that matters.

com.r3corda.core.node.services.UniquenessException
com.r3corda.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.

com.r3corda.contracts.UnknownType
com.r3corda.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:

com.r3corda.demos.protocols.UpdateBusinessDayProtocol

This is a less temporary, demo-oriented way of initiating processing of temporal events.

com.r3corda.protocols.ValidatingNotaryProtocol

A notary commit protocol 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.

com.r3corda.node.services.transactions.ValidatingNotaryService

A Notary service that validates the transaction chain of he submitted transaction before committing it

com.r3corda.core.testing.Verifies

This interface asserts that the DSL at hand is capable of verifying its underlying construct(ledger/transaction).

com.r3corda.core.node.services.Wallet

A wallet (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 wallet: it is guaranteed not to change out from underneath you, even though the canonical currently-best-known wallet may change as we learn about new transactions from our peers and generate new transactions that consume states ourselves.

com.r3corda.core.node.services.WalletService

A WalletService is responsible for securely and safely persisting the current state of a wallet to storage. The wallet service vends immutable snapshots of the current wallet for working with: if you build a transaction based on a wallet that isnt current, be aware that it may end up being invalid if the states that were used have been consumed by someone else first

com.r3corda.core.crypto.WhitelistTrustManager

Our TrustManager extension takes the standard certificate checker and first delegates all the chain checking to that. If everything is well formed we then simply add a check against our whitelist

com.r3corda.core.crypto.WhitelistTrustManagerProvider

Custom Security Provider that forces the TrustManagerFactory to be our custom one. Also holds the identity of the original TrustManager algorithm so that we can delegate most of the checking to the proper Java code. We simply add some more checks.

com.r3corda.core.crypto.WhitelistTrustManagerSpi

Registered TrustManagerFactorySpi

com.r3corda.node.services.network.WireNodeRegistration

A node registration and its signature as a pair.

com.r3corda.core.contracts.WireTransaction

Transaction ready for serialisation, without any signatures attached.

com.r3corda.core.serialization.WireTransactionSerializer

A serialisation engine that knows how to deserialise code inside a sandbox

com.r3corda.core.node.WorldCoordinate

A latitude/longitude pair.

com.r3corda.core.crypto.X509Utilities