All Types

net.corda.finance.flows.AbstractCashFlow

Initiates a flow that produces an Issue/Move or Exit Cash transaction.

net.corda.finance.contracts.asset.cash.selection.AbstractCashSelection

Pluggable interface to allow for different cash selection provider implementations Default implementation CashSelectionH2Impl uses H2 database and a custom function within H2 to perform aggregation. Custom implementations must implement this interface and declare their implementation in META-INF/services/net.corda.contracts.asset.CashSelection

net.corda.core.identity.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.core.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.finance.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.context.Actor

Models an initiator in Corda, can be a user, a service, etc.

net.corda.core.node.services.vault.AggregateFunctionType
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.contracts.AlwaysAcceptAttachmentConstraint

An AttachmentConstraint where isSatisfiedBy always returns true.

net.corda.core.contracts.Amount

Amount represents a positive quantity of some token (currency, asset, etc.), measured in quantity of the smallest representable units. The nominal quantity represented by each individual token is equal to the displayTokenSize. The scale property of the displayTokenSize should correctly reflect the displayed decimal places and is used when rounding conversions from indicative/displayed amounts in BigDecimal to Amount occur via the Amount.fromDecimal method.

net.corda.core.contracts.AmountTransfer

This class represents a possibly negative transfer of tokens from one vault state to another, possibly at a future date.

net.corda.core.identity.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.

kotlin.Any (extensions in package net.corda.core.utilities)
net.corda.core.node.AppServiceHub

A CordaService annotated class requires a constructor taking a single parameter of type AppServiceHub. With the AppServiceHub parameter a CordaService is able to access to privileged operations. In particular such a CordaService can initiate and track flows marked with net.corda.core.flows.StartableByService.

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.AttachmentConstraint

Constrain which contract-code-containing attachment can be used with a ContractState.

net.corda.core.node.services.AttachmentId
net.corda.core.node.services.vault.AttachmentQueryCriteria
net.corda.core.contracts.AttachmentResolutionException

The node asked a remote peer for the attachment identified by hash because it is a dependency of a transaction being resolved, but the remote peer would not provide it.

net.corda.testing.dsl.AttachmentResolutionException
net.corda.core.node.services.vault.AttachmentSort
net.corda.core.node.services.AttachmentStorage

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

net.corda.core.node.services.vault.AttachmentsQueryCriteriaParser
net.corda.core.context.AuthServiceId

Authentication / Authorisation Service ID.

net.corda.core.contracts.AutomaticHashConstraint

This AttachmentConstraint is a convenience class that will be automatically resolved to a HashAttachmentConstraint. The resolution occurs in TransactionBuilder.toWireTransaction and uses the TransactionState.contract value to find a corresponding loaded Cordapp that contains such a contract, and then uses that Cordapp as the Attachment.

net.corda.core.node.services.vault.BaseQueryCriteriaParser
net.corda.core.node.services.vault.BaseSort
net.corda.core.transactions.BaseTransaction

An abstract class defining fields shared by all transaction types in the system.

net.corda.finance.contracts.asset.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.finance.contracts.BilateralNettableState

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

net.corda.core.node.services.vault.BinaryComparisonOperator
net.corda.core.node.services.vault.BinaryLogicalOperator
java.sql.Blob (extensions in package net.corda.core.serialization)
net.corda.core.node.services.vault.Builder
net.corda.finance.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.

net.corda.finance.plugin.BusinessCalendarWrapper
kotlin.ByteArray (extensions in package net.corda.core.crypto)
kotlin.ByteArray (extensions in package net.corda.core.serialization)
kotlin.ByteArray (extensions in package net.corda.core.utilities)
net.corda.core.utilities.ByteSequence

An abstraction of a byte array, with offset and size that does no copying of bytes unless asked to.

net.corda.finance.plugin.CalendarDeserializer
net.corda.finance.plugin.CalendarSerializer
net.corda.finance.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.finance.flows.CashConfigDataFlow

Flow to obtain cash cordapp app configuration.

net.corda.finance.flows.CashConfiguration
net.corda.finance.flows.CashException
net.corda.finance.flows.CashExitFlow

Initiates a flow that produces an cash exit transaction.

net.corda.finance.flows.CashIssueAndPaymentFlow

Initiates a flow that self-issues cash (which should then be sent to recipient(s) using a payment transaction).

net.corda.finance.flows.CashIssueFlow

Initiates a flow that self-issues cash (which should then be sent to recipient(s) using a payment transaction).

net.corda.finance.flows.CashPaymentFlow

Initiates a flow that sends cash to a recipient.

net.corda.finance.schemas.CashSchema

An object used to fully qualify the CashSchema family name (i.e. independent of version).

net.corda.finance.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.finance.contracts.asset.cash.selection.CashSelectionH2Impl
net.corda.finance.contracts.asset.cash.selection.CashSelectionMySQLImpl
net.corda.finance.contracts.asset.cash.selection.CashSelectionPostgreSQLImpl
net.corda.finance.utils.CityDatabase

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

net.corda.core.serialization.ClassWhitelist
net.corda.testing.node.ClusterSpec

Abstract class specifying information about the consensus algorithm used for a cluster of nodes.

net.corda.core.flows.CollectSignatureFlow

Get and check the required signature.

net.corda.core.flows.CollectSignaturesFlow

The CollectSignaturesFlow is used to automate the collection of counterparty signatures for a given transaction.

kotlin.collections.Collection (extensions in package net.corda.core.contracts)
kotlin.collections.Collection (extensions in package net.corda.core.utilities)
net.corda.core.node.services.vault.CollectionOperator
net.corda.core.node.services.vault.Column
net.corda.core.node.services.vault.ColumnPredicate
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.CommandAndState

Return structure for OwnableState.withNewOwner

net.corda.core.contracts.CommandData

Marker interface for classes that represent commands

net.corda.core.contracts.CommandWithParties

A Command where the signing parties have been looked up if they have a well known/recognised institutional key.

net.corda.finance.contracts.CommercialPaper
net.corda.finance.schemas.CommercialPaperSchema

An object used to fully qualify the CommercialPaperSchema family name (i.e. independent of version).

net.corda.finance.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.finance.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.core.schemas.CommonSchema

JPA representation of the common schema entities

net.corda.core.schemas.CommonSchemaV1

First version of the Vault ORM schema

net.corda.core.transactions.ComponentGroup

A ComponentGroup is used to store the full list of transaction components of the same type in serialised form. Practically, a group per component type of a transaction is required; thus, there will be a group for input states, a group for all attachments (if there are any) etc.

net.corda.core.contracts.ComponentGroupEnum

An enum, for which each property corresponds to a transaction component group. The position in the enum class declaration (ordinal) is used for component-leaf ordering when computing the Merkle tree.

net.corda.core.transactions.ComponentVisibilityException

Thrown when checking for visibility of all-components in a group in FilteredTransaction.checkAllComponentsVisible.

net.corda.core.crypto.CompositeKey

A tree data structure that enables the representation of composite public keys, which are used to represent the signing requirements for multi-signature scenarios such as RAFT notary services. A composite key is a list of leaf keys and their contributing weight, and each leaf can be a conventional single key or a composite key. Keys contribute their weight to the total if they are matched by the signature.

net.corda.core.crypto.CompositeKeyFactory

Factory for generating composite keys from ASN.1 format key specifications. This is used by CordaSecurityProvider.

net.corda.core.crypto.CompositeSignature

Dedicated class for storing a set of signatures that comprise CompositeKey.

net.corda.core.crypto.CompositeSignaturesWithKeys

Custom class for holding signature data. This exists for later extension work to provide a standardised cross-platform serialization format.

net.corda.finance.flows.ConfigHolder
net.corda.core.serialization.ConstructorForDeserialization

Annotation indicating a constructor to be used to reconstruct instances of a class during deserialization.

net.corda.core.contracts.Contract

Implemented by a program that implements business logic on the shared ledger. All participants run this code for every net.corda.core.transactions.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 time-window attached to the transaction itself i.e. it is NOT necessarily the current time.

net.corda.core.contracts.ContractAttachment

Wrap an attachment in this if it is to be used as an executable contract attachment

net.corda.core.contracts.ContractClassName
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.core.transactions.ContractUpgradeFilteredTransaction

A filtered version of the ContractUpgradeWireTransaction. In comparison with a regular FilteredTransaction, there is no flexibility on what parts of the transaction to reveal – the inputs and notary field are always visible and the rest of the transaction is always hidden. Its only purpose is to hide transaction data when using a non-validating notary.

net.corda.core.flows.ContractUpgradeFlow

A flow to be used for authorising and upgrading state objects of an old contract to a new contract.

net.corda.core.transactions.ContractUpgradeLedgerTransaction

A contract upgrade transaction with fully resolved inputs and signatures. Contract upgrade transactions are separate to regular transactions because their validation logic is specialised; the original contract by definition cannot be aware of the upgraded contract (it was written after the original contract was developed), so its validation logic cannot succeed. Instead alternative verification logic is used which verifies that the outputs correspond to the inputs after upgrading.

net.corda.core.node.services.ContractUpgradeService

The ContractUpgradeService is responsible for securely upgrading contract state objects according to a specified and mutually agreed (amongst participants) contract version. See also ContractUpgradeFlow to understand the workflow associated with contract upgrades.

net.corda.core.transactions.ContractUpgradeWireTransaction

A special transaction for upgrading the contract of a state.

net.corda.core.CordaException
net.corda.core.concurrent.CordaFuture

Same as Future with additional methods to provide some of the features of java.util.concurrent.CompletableFuture while minimising the API surface area. In Kotlin, to avoid compile errors, whenever CordaFuture is used in a parameter or extension method receiver type, its type parameter should be specified with out variance.

net.corda.core.CordaInternal

These methods are not part of Corda's API compatibility guarantee and applications should not use them.

net.corda.core.CordaOID

OIDs used for the Corda platform. Entries MUST NOT be removed from this file; if an OID is incorrectly assigned it should be marked deprecated.

net.corda.core.crypto.CordaObjectIdentifier
net.corda.client.rpc.CordaRPCClient

An RPC client connects to the specified server and allows you to make calls to the server that perform various useful tasks. Please see the Client RPC section of docs.corda.net to learn more about how this API works. A brief description is provided here.

net.corda.client.rpc.CordaRPCClientConfiguration

Can be used to configure the RPC client connection.

net.corda.client.rpc.CordaRPCConnection

This class is essentially just a wrapper for an RPCConnection and can be treated identically.

net.corda.core.messaging.CordaRPCOps

RPC operations that the node exposes to clients.

net.corda.core.CordaRuntimeException
net.corda.core.crypto.CordaSecurityProvider
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.serialization.CordaSerializationTransformEnumDefault

This annotation is used to mark an enumerated type as having had a new constant appended to it. For each additional constant added a new annotation should be appended to the class. If more than one is required the wrapper annotation CordaSerializationTransformEnumDefaults should be used to encapsulate them

net.corda.core.serialization.CordaSerializationTransformEnumDefaults

This annotation is used to mark an enumerated type as having had multiple members added, It acts as a container annotation for instances of CordaSerializationTransformEnumDefault, each of which details individual additions.

net.corda.core.serialization.CordaSerializationTransformRename

This annotation is used to mark a class has having had a property element. It is used by the AMQP deserializer to allow instances with different versions of the class on their Class Path to successfully deserialize the object.

net.corda.core.serialization.CordaSerializationTransformRenames

This annotation is used to mark a class as having had multiple elements renamed as a container annotation for instances of CordaSerializationTransformRename, each of which details an individual rename.

net.corda.core.node.services.CordaService

Annotate any class that needs to be a long-lived service within the node, such as an oracle, with this annotation. Such a class needs to have a constructor with a single parameter of type AppServiceHub. This constructor will be invoked during node start to initialise the service. The service hub provided can be used to get information about the node that may be necessary for the service. Corda services are created as singletons within the node and are available to flows via ServiceHub.cordaService.

net.corda.core.CordaThrowable
net.corda.core.identity.CordaX500Name

X.500 distinguished name data type customised to how Corda uses names. This restricts the attributes to those Corda supports, and requires that organisation, locality and country attributes are specified. See also RFC 4519 for the underlying attribute type definitions

net.corda.core.cordapp.Cordapp

Represents a cordapp by registering the JAR that contains it and all important classes for Corda. Instances of this class are generated automatically at startup of a node and can get retrieved from CordappProvider.getAppContext from the CordappContext it returns.

net.corda.core.cordapp.CordappContext

An app context provides information about where an app was loaded from, access to its classloader, and (in the included Cordapp object) lists of annotated classes discovered via scanning the JAR.

net.corda.core.cordapp.CordappProvider

Provides access to what the node knows about loaded applications.

net.corda.core.transactions.CoreTransaction

A transaction with the minimal amount of information required to compute the unique transaction id, and resolve a FullTransaction. This type of transaction, wrapped in SignedTransaction, gets transferred across the wire and recorded to storage.

net.corda.core.node.services.vault.CriteriaExpression
net.corda.core.crypto.Crypto

This object controls and provides the available and supported signature schemes for Corda. Any implemented SignatureScheme should be strictly defined here. However, only the schemes returned by {@link #listSupportedSignatureSchemes()} are supported. Note that Corda currently supports the following signature schemes by their code names:

net.corda.finance.contracts.math.CubicSplineInterpolator

Interpolates values between the given data points using a SplineFunction.

java.util.Currency (extensions in package net.corda.finance)
net.corda.core.messaging.DataFeed

The Data feed contains a snapshot of the requested data and an Observable of future updates.

net.corda.core.flows.DataVendingFlow
net.corda.finance.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.finance.contracts.DateRollDirection

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

net.corda.finance.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.finance.contracts.DayCountBasisYear

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

net.corda.finance.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.DeprecatedConstructorForDeserialization

This annotation is a marker to indicate which secondary constructors should be considered, and in which order, for evolving objects during their deserialization.

net.corda.core.crypto.DigitalSignature

A wrapper around a digital signature.

net.corda.core.DoNotImplement

This annotation is for interfaces and abstract classes that provide Corda functionality to user applications. Future versions of Corda may add new methods to such interfaces and classes, but will not remove or modify existing methods.

kotlin.Double (extensions in package net.corda.finance)
net.corda.testing.dsl.DoubleSpentInputs
net.corda.testing.driver.DriverDSL

Underlying interface for the driver DSL. Do not instantiate directly, instead use the driver function.

net.corda.testing.driver.DriverParameters

Builder for configuring a driver.

net.corda.testing.core.DummyCommandData

Trivial implementation of TypeOnlyCommandData for test purposes

net.corda.testing.contracts.DummyContract

Dummy contract for testing purposes. Doesn't do anything useful.

net.corda.testing.contracts.DummyContractV2

Dummy contract state for testing of the upgrade process.

net.corda.testing.contracts.DummyContractV3

Dummy contract state for testing of the upgrade process.

net.corda.testing.contracts.DummyState

Dummy state for use in testing. Not part of any contract, not even the DummyContract.

net.corda.testing.dsl.DuplicateOutputLabel
net.corda.testing.dsl.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.

net.corda.core.node.services.vault.EqualityComparisonOperator
net.corda.testing.core.ExpectCompose

Part of the Expectation DSL

net.corda.finance.contracts.Expression

Represents a textual expression of e.g. a formula

net.corda.finance.contracts.ExpressionDeserializer
net.corda.finance.contracts.ExpressionSerializer
net.corda.core.node.services.vault.FieldInfo

Contains information about a field from an entity class. Used as part of query criteria construction through Builder, produced by function getField. The constructor should not be invoked manually.

net.corda.core.transactions.FilteredComponentGroup

A FilteredComponentGroup is used to store the filtered list of transaction components of the same type in serialised form. This is similar to ComponentGroup, but it also includes the corresponding nonce per component.

net.corda.core.transactions.FilteredTransaction

Class representing merkleized filtered transaction.

net.corda.core.transactions.FilteredTransactionVerificationException

Thrown when FilteredTransaction.verify fails.

net.corda.core.flows.FinalityFlow

Verifies the given transaction, then sends it to the named notary. If the notary agrees that the transaction is acceptable then it is from that point onwards committed to the ledger, and will be written through to the vault. Additionally it will be distributed to the parties reflected in the participants list of the states.

net.corda.finance.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.finance.contracts.FixOf

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

net.corda.finance.contracts.FixableDealState

Interface adding fixing specific methods.

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 FlowSession.receive or FlowSession.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.core.messaging.FlowHandleImpl
net.corda.core.flows.FlowInfo

Version and name of the CorDapp hosting the other side of the flow.

net.corda.core.messaging.FlowInfo

An alias for StateMachineInfo which uses more modern terminology.

net.corda.core.flows.FlowInitiator

Please note that FlowInitiator has been superceded by net.corda.core.context.InvocationContext, which offers more detail for the same event.

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 handle interface representing a FlowLogic instance which would be possible to safely pass out of the contract sandbox. Use FlowLogicRefFactory to construct a concrete security checked instance.

net.corda.core.flows.FlowLogicRefFactory

The public factory interface for creating validated FlowLogicRef instances as part of the scheduling framework.

net.corda.core.messaging.FlowProgressHandle

FlowProgressHandle is a serialisable handle for the started flow, parameterised by the type of the flow's return value.

net.corda.core.messaging.FlowProgressHandleImpl
net.corda.core.flows.FlowSession

A FlowSession is a handle on a communication sequence between two paired flows, possibly running on separate nodes. It is used to send and receive messages between the flows as well as to query information about the counter-flow.

net.corda.core.flows.FlowStackSnapshot

Main data object representing snapshot of the flow stack, extracted from the Quasar stack.

net.corda.finance.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.core.transactions.FullTransaction

A transaction with fully resolved components, such as input states.

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.concurrent)
java.util.concurrent.Future (extensions in package net.corda.core.utilities)
net.corda.core.node.services.vault.GenericQueryCriteria
net.corda.core.contracts.HashAttachmentConstraint

An AttachmentConstraint that verifies by hash. The state protected by this constraint can only be used in a transaction created with that version of the jar. And a receiving node will only accept it if a cordapp with that hash has (is) been deployed on the node.

net.corda.testing.http.HttpApi
net.corda.testing.http.HttpUtils

A small set of utilities for making HttpCalls, aimed at demos and tests.

net.corda.core.node.services.vault.IQueryCriteriaParser
net.corda.core.utilities.Id

Represents a unique, timestamped id.

net.corda.core.node.services.IdentityService

An identity service maintains a directory of parties by their associated distinguished name/public keys and thus supports lookup of a party given its key, or name. The service also manages the certificates linking confidential identities back to the well known identity.

net.corda.core.flows.IllegalFlowLogicException

Thrown if the structure of a class implementing a flow is not correct. There can be several causes for this such as not inheriting from FlowLogic, not having a valid constructor and so on.

net.corda.testing.node.InMemoryMessagingNetwork

An in-memory network allows you to manufacture InternalMockMessagingServices for a set of participants. Each InternalMockMessagingService 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).

net.corda.testing.driver.InProcess

Interface which represents an in process node and exposes available services.

net.corda.core.flows.InitiatedBy

This annotation is required by any FlowLogic that is designed to be initiated by a counterparty flow. The class must have at least a constructor which takes in a single net.corda.core.identity.Party parameter which represents the initiating counterparty. The FlowLogic that does the initiating is specified by the value property and itself must be annotated with InitiatingFlow.

net.corda.core.flows.InitiatingFlow

This annotation is required by any FlowLogic which has been designated to initiate communication with a counterparty and request they start their side of the flow communication.

net.corda.core.contracts.InsufficientBalanceException
kotlin.Int (extensions in package net.corda.core.utilities)
kotlin.Int (extensions in package net.corda.finance)
net.corda.finance.contracts.math.Interpolator
net.corda.finance.contracts.math.InterpolatorFactory
net.corda.core.context.InvocationContext

Models the information needed to trace an invocation in Corda. Includes initiating actor, origin, trace information, and optional external trace information to correlate clients' IDs.

net.corda.core.context.InvocationOrigin

Represents the source of an action such as a flow start, an RPC, a shell command etc.

net.corda.core.contracts.Issued

The Issued data class holds the details of an on ledger digital asset. In particular it gives the public credentials of the entity that created these digital tokens and the particular product represented.

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.finance.utils)
kotlin.collections.Iterable (extensions in package net.corda.testing.core)
net.corda.client.jackson.JacksonSupport

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.

net.corda.testing.driver.JmxPolicy

A class containing configuration information for Jolokia JMX, to be used when creating a node via the driver

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.testing.dsl.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.

net.corda.testing.dsl.LedgerDSLInterpreter

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

net.corda.core.transactions.LedgerTransaction

A LedgerTransaction is derived from a WireTransaction. It is the result of doing the following operations:

net.corda.core.contracts.LegalProseReference

The annotated Contract implements the legal prose identified by the given URI.

net.corda.core.node.services.vault.LikenessOperator
net.corda.finance.contracts.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".

org.slf4j.Logger (extensions in package net.corda.core.utilities)
kotlin.Long (extensions in package net.corda.core.utilities)
kotlin.Long (extensions in package net.corda.finance)
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.core.crypto.MerkleTree

Creation and verification of a Merkle tree for a WireTransaction.

net.corda.core.crypto.MerkleTreeException
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.serialization.MissingAttachmentsException

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

net.corda.core.transactions.MissingContractAttachments

A contract attachment was missing when trying to automatically attach all known contract attachments

net.corda.testing.services.MockAttachmentStorage

A mock implementation of AttachmentStorage for use within tests

net.corda.testing.node.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 or an in memory H2 database instance.

net.corda.testing.node.MockNetworkNotarySpec

The spec for a notary which will used by the MockNetwork to automatically start a notary node. This notary will become part of the network parameters used by all the nodes.

net.corda.testing.node.MockNetworkParameters

Immutable builder for configuring a MockNetwork. Kotlin users can also use named parameters to the constructor of MockNetwork, which is more convenient.

net.corda.testing.node.MockNodeParameters

Immutable builder for configuring a StartedMockNode or an UnstartedMockNode via MockNetwork.createNode and MockNetwork.createUnstartedNode. Kotlin users can also use the named parameters overloads of those methods which are more convenient.

net.corda.testing.node.MockServices

An implementation of ServiceHub that is designed for in-memory unit tests of contract validation logic. It has enough functionality to do tests of code that queries the vault, inserts to the vault, and constructs/checks transactions. However it isn't enough to test flows and other aspects of an app that require a network. For that you should investigate MockNetwork.

net.corda.core.contracts.MoveCommand

A common move command for contract states which can change owner.

net.corda.finance.contracts.asset.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.finance.contracts.MultilateralNettableState

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

net.corda.core.contracts.NamedByHash

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

net.corda.finance.contracts.NetCommand

A common netting command for contracts whose states can be netted.

net.corda.finance.contracts.asset.NetState

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

net.corda.finance.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.finance.contracts.NettableState
net.corda.core.utilities.NetworkHostAndPort

Tuple of host and port. Use NetworkHostAndPort.parse on untrusted data.

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.core.node.services.NetworkMapCacheBase

Subset of NetworkMapCache that doesn't depend on an IdentityService.

net.corda.core.node.NetworkParameters

Network parameters are a set of values that every node participating in the zone needs to agree on and use to correctly interoperate with each other.

net.corda.testing.driver.NodeHandle

A base interface which represents a node as part of the driver dsl, extended by InProcess and OutOfProcess

net.corda.core.node.NodeInfo

Information about a network node that acts on behalf of some party. NodeInfos can be found via the network map cache, accessible from a net.corda.core.node.services.NetworkMapCache. They are also available via RPC using the net.corda.core.messaging.CordaRPCOps.networkMapSnapshot method.

net.corda.testing.driver.NodeParameters

Helper builder for configuring a Node from Java.

net.corda.core.utilities.NonEmptySet

An immutable ordered non-empty set.

net.corda.core.flows.NotarisationPayload

Container for the transaction and notarisation request signature. This is the payload that gets sent by a client to a notary service for committing the input states of the transaction.

net.corda.core.flows.NotarisationRequest

A notarisation request specifies a list of states to consume and the id of the consuming transaction. Its primary purpose is for notarisation traceability – a signature over the notarisation request, NotarisationRequestSignature, allows a notary to prove that a certain party requested the consumption of a particular state.

net.corda.core.flows.NotarisationRequestSignature

A wrapper around a digital signature used for notarisation requests.

net.corda.core.flows.NotarisationResponse

Payload returned by the notary service flow to the client.

net.corda.core.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.core.transactions.NotaryChangeLedgerTransaction

A notary change transaction with fully resolved inputs and signatures. In contrast with a regular transaction, signatures are checked against the signers specified by input states' participants fields, so full resolution is needed for signature verification.

net.corda.core.transactions.NotaryChangeWireTransaction

A special transaction for changing the notary of a state. It only needs specifying the state(s) as input(s), old and new notaries. Output states can be computed by applying the notary modification to corresponding inputs on the fly.

net.corda.core.flows.NotaryError

Specifies the cause for notarisation request failure.

net.corda.core.flows.NotaryException

Exception thrown by the notary service if any issues are encountered while trying to commit a transaction. The underlying error specifies the cause of failure.

net.corda.core.flows.NotaryFlow
net.corda.testing.driver.NotaryHandle

Object ecapsulating a notary started automatically by the driver.

net.corda.core.node.NotaryInfo

Data class storing information about notaries available in the network.

net.corda.core.flows.NotaryInternalException

Exception internal to the notary service. Does not get exposed to CorDapps and flows calling NotaryFlow.Client.

net.corda.core.node.services.NotaryService
net.corda.testing.node.NotarySpec

A notary spec for describing a notary which will be started automatically by the driver and which will be part of the network parameters used by all the nodes.

net.corda.core.crypto.NullKeys
net.corda.core.node.services.vault.NullOperator
net.corda.core.serialization.ObjectWithCompatibleContext
net.corda.finance.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.client.rpc)
rx.Observable (extensions in package net.corda.core)
rx.Observable (extensions in package net.corda.testing.core)
net.corda.finance.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.utilities.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.core.utilities.OpaqueBytesSubSequence

Class is public for serialization purposes

net.corda.core.node.services.vault.Operator
net.corda.testing.driver.OutOfProcess

Interface which represents an out of process node and exposes its process handle.

net.corda.testing.dsl.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.

net.corda.core.contracts.OwnableState

A contract state that can have a single owner.

net.corda.core.node.services.vault.PageSpecification

PageSpecification allows specification of a page number (starting from DEFAULT_PAGE_NUM) and page size (defaulting to DEFAULT_PAGE_SIZE with a maximum page size of MAX_PAGE_SIZE) Note: we default the page number to DEFAULT_PAGE_SIZE to enable queries without requiring a page specification but enabling detection of large results sets that fall out of the DEFAULT_PAGE_SIZE requirement. MAX_PAGE_SIZE should be used with extreme caution as results may exceed your JVM memory footprint.

net.corda.core.messaging.ParametersUpdateInfo

Data class containing information about the scheduled network parameters update. The info is emitted every time node receives network map with ParametersUpdate which wasn't seen before. For more information see: CordaRPCOps.networkParametersFeed and CordaRPCOps.acceptNewNetworkParameters.

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.core.identity.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 can be represented by a composite construct – a CompositeKey, which combines multiple cryptographic public key primitives into a tree structure.

net.corda.finance.contracts.asset.PartyAndAmount

A simple holder for a (possibly anonymous) AbstractParty and a quantity of tokens

net.corda.core.identity.PartyAndCertificate

A full party plus the X.509 certificate and path linking the party back to a trust root. Equality of PartyAndCertificate instances is based on the party only, as certificate and path are data associated with the party, not part of the identifier themselves.

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.node.services.PartyInfo

Holds information about a Party, which may refer to either a specific node or a service.

net.corda.finance.contracts.PaymentRule

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

net.corda.client.rpc.PermissionException

Thrown to indicate that the calling user does not have permission for something they have requested (for example calling a method).

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.finance.contracts.math.Polynomial

Represents a polynomial function of arbitrary degree.

net.corda.testing.driver.PortAllocation

An abstract helper class which is used within the driver to allocate unused ports for testing. Use either the Incremental or RandomFree concrete implementations.

net.corda.core.contracts.PrivacySalt

A privacy salt is required to compute nonces per transaction component in order to ensure that an adversary cannot use brute force techniques and reveal the content of a Merkle-leaf hashed value. Because this salt serves the role of the seed to compute nonces, its size and entropy should be equal to the underlying hash function used for Merkle tree generation, currently SecureHash.SHA256, which has an output of 32 bytes. There are two constructors, one that generates a new 32-bytes random salt, and another that takes a ByteArray input. The latter is required in cases where the salt value needs to be pre-generated (agreed between transacting parties), but it is highlighted that one should always ensure it has sufficient entropy.

java.security.PrivateKey (extensions in package net.corda.core.crypto)
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.core.utilities.PropertyDelegate

Simple interface encapsulating the implicit Kotlin contract for immutable property delegates.

java.security.PublicKey (extensions in package net.corda.core.crypto)
java.security.PublicKey (extensions in package net.corda.core.utilities)
net.corda.core.node.services.vault.QueryCriteria

Indexing assumptions: QueryCriteria assumes underlying schema tables are correctly indexed for performance.

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.client.rpc.RPCConnection

Holds a proxy object implementing I that forwards requests to the RPC server. The server version can be queried via this interface.

net.corda.client.rpc.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.client.rpc.RPCSinceVersion

Records the protocol version in which this RPC was added.

net.corda.core.flows.ReceiveStateAndRefFlow

The ReceiveStateAndRefFlow should be called in response to the SendStateAndRefFlow.

net.corda.core.flows.ReceiveTransactionFlow

The ReceiveTransactionFlow should be called in response to the SendTransactionFlow.

net.corda.core.contracts.Requirements

Defines a simple domain specific language for the specification of financial contracts. Currently covers:

net.corda.core.flows.SchedulableFlow

Any FlowLogic which is schedulable and is designed to be invoked by a net.corda.core.contracts.SchedulableState must have this annotation. If it's missing FlowLogicRefFactory.create will throw an exception when it comes time to schedule the next activity in net.corda.core.contracts.SchedulableState.nextScheduledActivity.

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.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.finance.utils.ScreenCoordinate
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.core.flows.SendStateAndRefFlow

The SendStateAndRefFlow should be used to send a list of input StateAndRef to another peer that wishes to verify the input's integrity by resolving and checking the dependencies as well. The other side should invoke ReceiveStateAndRefFlow at the right point in the conversation to receive the input state and ref and perform the resolution back-and-forth required to check the dependencies.

net.corda.core.flows.SendTransactionFlow

The SendTransactionFlow should be used to send a transaction to another peer that wishes to verify that transaction's integrity by resolving and checking the dependencies as well. The other side should invoke ReceiveTransactionFlow at the right point in the conversation to receive the sent transaction and perform the resolution back-and-forth required to check the dependencies and download any missing attachments.

net.corda.core.serialization.SerializationContext

Parameters to serialization and deserialization.

net.corda.core.serialization.SerializationCustomSerializer

Allows CorDapps to provide custom serializers for third party libraries where those libraries cannot be recompiled with the -parameters flag rendering their classes natively serializable by Corda. In this case a proxy serializer can be written that extends this type whose purpose is to move between those an unserializable types and an intermediate representation.

net.corda.core.serialization.SerializationDefaults

Global singletons to be used as defaults that are injected elsewhere (generally, in the node or in RPC client).

net.corda.testing.core.SerializationEnvironmentRule

A test serialization rule implementation for use in tests

net.corda.core.serialization.SerializationFactory

An abstraction for serializing and deserializing objects, with support for versioning of the wire format via a header / prefix in the bytes.

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.SerializationWhitelist

Provide a subclass of this via the java.util.ServiceLoader mechanism to be able to whitelist types for serialisation that you cannot otherwise annotate. The name of the class must appear in a text file on the classpath under the path META-INF/services/net.corda.core.serialization.SerializationWhitelist

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.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.node.ServiceHub

A service hub is the starting point for most operations you can do inside the node. You are provided with one when a class annotated with CordaService is constructed, and you have access to one inside flows. Most RPCs simply forward to the services found here after some access checking.

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.core.flows.SignTransactionFlow

The SignTransactionFlow should be called in response to the CollectSignaturesFlow. It automates the signing of a transaction providing the transaction:

net.corda.core.crypto.SignableData

A SignableData object is the packet actually signed. It works as a wrapper over transaction id and signature metadata. Note that when multi-transaction signing (signing a block of transactions) is used, the root of the Merkle tree (having transaction IDs as leaves) is actually signed and thus txId refers to this root and not a specific transaction.

net.corda.core.crypto.SignatureMetadata

SignatureMeta is required to add extra meta-data to a transaction's signature. It currently supports platformVersion only, but it can be extended to support a universal digital signature model enabling partial signatures and attaching extra information, such as a user's timestamp or other application-specific fields.

net.corda.core.crypto.SignatureScheme

This class is used to define a digital signature scheme.

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 (including composite keys) 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 Merkle root 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.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.node.services.vault.Sort

Sort allows specification of a set of entity attribute names and their associated directionality and null handling, to be applied upon processing a query specification.

net.corda.core.node.services.vault.SortAttribute
net.corda.core.contracts.SourceAndAmount

Simple data class to associate the origin, owner, or holder of a particular Amount object.

net.corda.finance.contracts.math.SplineFunction

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

net.corda.core.flows.StackFrameDataToken

Token class, used to indicate stack presence of the corda internal data. Since this data is of no use for a CordApp developer, it is skipped from serialisation and its presence is only marked by this token.

net.corda.core.flows.StartableByRPC

Any FlowLogic which is to be started by the RPC interface (net.corda.core.messaging.CordaRPCOps.startFlowDynamic and net.corda.core.messaging.CordaRPCOps.startTrackedFlowDynamic) must have this annotation. If it's missing the flow will not be allowed to start and an exception will be thrown.

net.corda.core.flows.StartableByService

Any FlowLogic which is to be started by the AppServiceHub interface from within a CordaService must have this annotation. If it's missing the flow will not be allowed to start and an exception will be thrown.

net.corda.testing.node.StartedMockNode

A class that represents a started mock node for testing.

net.corda.core.contracts.StateAndContract

A convenience class for passing around a state and it's contract

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.core.flows.StateConsumptionDetails

Contains information about the consuming transaction for a particular state.

net.corda.core.messaging.StateMachineInfo

Represents information about a flow (the name "state machine" is legacy, Kotlin users can use the FlowInfo type alias). You can access progress tracking, information about why the flow was started and so on.

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.core.messaging.StateMachineTransactionMapping
net.corda.core.messaging.StateMachineUpdate
net.corda.core.schemas.StatePersistable

Marker interface to denote a persistable Corda state entity that will always have a transaction id and index

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.core.flows.StateReplacementException
net.corda.core.node.services.StatesNotAvailableException
net.corda.core.node.StatesToRecord

Controls whether the transaction is sent to the vault at all, and if so whether states have to be relevant or not in order to be recorded. Used in ServiceHub.recordTransactions

kotlin.String (extensions in package net.corda.core.utilities)
net.corda.client.jackson.StringToMethodCallParser

This class parses strings in a format designed for human usability into ParsedMethodCall objects representing a ready-to-invoke call on the given target object. The strings accepted by this class are a minor variant of Yaml and can be easily typed at a command line. Intended use cases include things like the Corda shell, text-based RPC dispatch, simple scripting and so on.

net.corda.finance.contracts.Tenor

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

net.corda.testing.node.TestClock

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

net.corda.testing.core.TestIdentity

A class that encapsulates a test identity containing a CordaX500Name and a KeyPair, alongside a range of utility methods for use during testing.

net.corda.testing.dsl.TestLedgerDSLInterpreter
net.corda.testing.dsl.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.

net.corda.core.contracts.TimeWindow

An interval on the time-line; not a single instantaneous point.

net.corda.core.node.services.TimeWindowChecker

Checks if the current instant provided by the input clock falls within the provided time-window.

net.corda.core.contracts.TokenizableAssetInfo

This interface is used by Amount to determine the conversion ratio from indicative/displayed asset amounts in BigDecimal to fungible tokens represented by Amount objects.

net.corda.core.context.Trace

Contextual tracing information, including invocation and session id.

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.testing.dsl.TransactionDSL

Underlying class for the transaction DSL. Do not instantiate directly, instead use the transaction function.

net.corda.testing.dsl.TransactionDSLInterpreter

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

net.corda.core.flows.TransactionParts

The minimum amount of information needed to notarise a transaction. Note that this does not include any sensitive transaction details.

net.corda.core.contracts.TransactionResolutionException

The node asked a remote peer for the transaction identified by hash because it is a dependency of a transaction being resolved, but the remote peer would not provide it.

net.corda.core.crypto.TransactionSignature

A wrapper over the signature output accompanied by signer's public key and signature metadata. This is similar to DigitalSignature.WithKey, but targeted to DLT transaction (or block of transactions) signatures.

net.corda.core.contracts.TransactionState

A wrapper for ContractState containing additional platform-level state information and contract information. This is the definitive state that is stored on the ledger and used in transaction outputs.

net.corda.core.node.services.TransactionStorage

Thread-safe storage of transactions.

net.corda.core.contracts.TransactionVerificationException

Indicates that some aspect of the transaction named by txId violates the platform rules. The exact type of failure is expressed using a subclass. TransactionVerificationException is a FlowException and thus when thrown inside a flow, the details of the failure will be serialised, propagated to the peer and rethrown.

net.corda.core.transactions.TransactionWithSignatures

An interface for transactions containing signatures, with logic for signature verification.

net.corda.core.transactions.TraversableTransaction

Implemented by WireTransaction and FilteredTransaction. 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.core.node.services.TrustedAuthorityNotaryService

A base notary service implementation that provides functionality for cases where a signature by a single member of the cluster is sufficient for transaction notarisation. For example, a single-node or a Raft notary.

net.corda.core.utilities.Try

Representation of an operation that has either succeeded with a result (represented by Success) or failed with an exception (represented by Failure).

net.corda.finance.flows.TwoPartyDealFlow

Classes for manipulating a two party deal or agreement.

net.corda.finance.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.contracts.TypeOnlyCommandData

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

net.corda.core.flows.UnexpectedFlowEndException

Thrown when a flow session ends unexpectedly due to a type mismatch (the other side sent an object of a type that we were not expecting), or the other side had an internal error, or the other side terminated when we were waiting for a response.

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.node.services.UnknownAnonymousPartyException
net.corda.testing.node.UnstartedMockNode

A class that represents an unstarted mock node for testing.

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.UpgradedContract

Interface which can upgrade state objects issued by a contract to a new state object issued by a different contract. The upgraded contract should specify the legacy contract class name, and provide an upgrade function that will convert legacy contract states into states defined by this contract.

net.corda.core.contracts.UpgradedContractWithLegacyConstraint

This interface allows specifying a custom legacy contract constraint for upgraded contracts. The default for UpgradedContract is WhitelistedByZoneAttachmentConstraint.

net.corda.testing.node.User

Object encapsulating a node rpc user and their associated permissions for use when testing using the driver

net.corda.core.utilities.UuidGenerator
net.corda.core.utilities.VariablePropertyDelegate

Simple interface encapsulating the implicit Kotlin contract for mutable property delegates.

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.VaultQueryException
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.testing.driver.VerifierType
net.corda.testing.dsl.Verifies

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

net.corda.core.serialization.VersionHeader
net.corda.testing.driver.WebserverHandle

Class which represents a handle to a webserver process and its NetworkHostAndPort for testing purposes.

net.corda.core.contracts.WhitelistedByZoneAttachmentConstraint

An AttachmentConstraint that verifies that the hash of the attachment is in the network parameters whitelist. See: net.corda.core.node.NetworkParameters.whitelistedContractImplementations It allows for centralized control over the cordapps that can be used.

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 identity of the transaction is the Merkle tree root of its components (see MerkleTree).

net.corda.finance.utils.WorldCoordinate

A latitude/longitude pair.

net.corda.finance.utils.WorldMapLocation

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. The countryCode field is a two letter ISO country code.