### All Types

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.
node.api.APIServer | Top level interface to external interaction with the distributed ledger.
node.internal.APIServerImpl |
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.
node.services.api.AbstractNodeService | Abstract superclass for services that a node can host, which provides helper functions.
protocols.AbstractRequestMessage | Abstract superclass for request messages sent to services, which includes common fields such as replyTo and replyToTopic.
node.services.api.AcceptsFileUpload | A service that implements AcceptsFileUpload can have new binary data provided to it via an HTTP upload.
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.
node.utilities.AddOrRemove | Enum for when adding/removing something, for example adding or removing an entry in a directory.
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.
core.messaging.AllPossibleRecipients | A special base class for the set of all possible recipients, without having to identify who they all are.
core.contracts.Amount | Amount represents a positive quantity of currency, measured in pennies, which are the smallest representable units.
node.services.messaging.ArtemisMessagingService | This class implements the MessagingService API using Apache Artemis, the successor to their ActiveMQ product. Artemis is a message queue broker and here, we embed the entire server inside our own process. Nodes communicate with each other using (by default) an Artemis specific protocol, but it supports other protocols like AQMP/1.0 as well.
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:
node.servlets.AttachmentDownloadServlet | Allows the node administrator to either download full attachment zips, or individual files within those zips.
core.node.services.AttachmentStorage | An attachment store records potentially large binary objects, identified by their hash. Note that attachments are immutable and can never be erased once inserted
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.
core.contracts.AuthenticatedObject | Wraps an object that was signed by a public key, which may be a well known/recognised institutional key.
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.
core.utilities.BriefLogFormatter | A Java logging formatter that writes more compact output than the default.
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 core.crypto) |
kotlin.ByteArray (extensions in package core.serialization) |
contracts.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.
node.services.api.Checkpoint |
node.services.api.CheckpointStorage | Thread-safe storage of fiber checkpoints.
core.node.CityDatabase | A simple lookup table of city names to their coordinates. Lookups are case insensitive.
core.contracts.Command | Command data/content plus pubkey pair: the signature is stored at the end of the serialized bytes
core.contracts.CommandData | Marker interface for classes that represent commands
contracts.CommercialPaper |
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
node.internal.ConfigurationException |

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.

node.api.ContractClassRef |
node.api.ContractDefRef | Encapsulates the contract type. e.g. Cash or CommercialPaper etc.
node.api.ContractLedgerRef |
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.
contracts.CrowdFund | This is a basic crowd funding contract. It allows a party to create a funding opportunity, then for others to pledge during the funding period , and then for the party to either accept the funding (if the target has been reached) return the funds to the pledge-makers (if the target has not been reached).
core.math.CubicSplineInterpolator | Interpolates values between the given data points using a SplineFunction.
node.servlets.DataUploadServlet | Accepts binary streams, finds the right AcceptsFileUpload implementor and hands the stream off to it.
node.services.persistence.DataVendingService | This class sets up network message handlers for requests from peers for data keyed by hash. It is a piece of simple glue that sits between the network layer and the database layer.
core.contracts.DateOffset | Date offset that the fixing is done prior to the accrual start date. Currently not used in the calculation.
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
core.contracts.DateRollDirection | This is utilised in the DateRollConvention class to determine which way we should initially step when finding a business day
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.
core.contracts.DayCountBasisYear | This forms the year part of the "Day Count Basis" used for interest calculation.
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.
demos.DemoClock | A Clock that can have the date advanced for use in demos
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.
kotlin.Double (extensions in package core) |
contracts.DummyContract |
core.crypto.DummyPublicKey |
core.node.services.DummyTimestampingAuthority |
node.services.keys.E2ETestKeyManagementService | A simple in-memory KMS that doesnt bother saving keys to disk. A real implementation would:
core.utilities.Emoji | A simple wrapper class that contains icons and support for printing them only when were connected to a terminal.
contracts.Event | Event superclass - everything happens on a date.
demos.protocols.ExitServerProtocol |
core.contracts.Expression | Represents a textual expression of e.g. a formula
core.contracts.ExpressionDeserializer |
core.contracts.ExpressionSerializer |
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.
protocols.FetchDataProtocol | An abstract protocol for fetching typed data from a remote peer.
protocols.FetchTransactionsProtocol | Given a set of tx hashes (IDs), either loads them from local disk or asks the remote peer to provide them.
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.
core.contracts.FixOf | A FixOf identifies the question side of a fix: what day, tenor and type of fix ("LIBOR", "EURIBOR" etc)
contracts.FixableDealState | Interface adding fixing specific methods
contracts.FixedRate | A very basic subclass to represent a fixed rate.
contracts.FixedRatePaymentEvent | Basic class for the Fixed Rate Payments on the fixed leg - see RatePaymentEvent Assumes that the rate is valid.
contracts.FloatingRate | The parent class of the Floating rate classes
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?
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).
node.internal.testing.IRSSimulation | A simulation in which banks execute interest rate swaps with each other, including the fixing events.
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.
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.
node.services.identity.InMemoryIdentityService | Simple identity service which caches parties and provides functionality for efficient lookup.

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

node.services.network.InMemoryNetworkMapCache | Extremely simple in-memory cache of the network map.
node.services.network.InMemoryNetworkMapService |
contracts.InsufficientBalanceException |
kotlin.Int (extensions in package core) |
kotlin.Int (extensions in package contracts) |

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.

api.InterestRateSwapAPI | This provides a simplified API, currently for demonstration use only.
core.math.Interpolator |
core.math.InterpolatorFactory |
kotlin.collections.Iterable (extensions in package core) |
kotlin.collections.Iterable (extensions in package contracts) |
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.
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 core.crypto) |
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.
core.math.LinearInterpolator | Interpolates values between the given data points using straight lines
core.contracts.LinearState | A state that evolves by superseding itself, all of which share the common "thread"
kotlin.collections.List (extensions in package core) |
java.time.LocalDate (extensions in package core) |
kotlin.Long (extensions in package core) |
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".
core.messaging.MessageHandlerRegistration |
core.messaging.MessageRecipientGroup | A base class for a set of recipients specifically identified by the sender.
core.messaging.MessageRecipients | The interface for a group of message recipients (which may contain only one recipient)
core.messaging.MessagingService | A MessagingService sits at the boundary between a message routing / networking layer and the core platform code.

core.messaging.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.

core.serialization.MissingAttachmentsException | Thrown during deserialisation to indicate that an attachment needed to construct the WireTransaction is not found
core.testservices.MockIdentityService | Scaffolding: a dummy identity service that just expects to have identities loaded off disk or found elsewhere. This class allows the provided list of identities to be mutated after construction, so it takes the list lock when doing lookups and recalculates the mapping each time. The ability to change the list is used by the MockNetwork code.
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.
node.services.network.MockNetworkMapCache | Network map cache with no backing map service.
core.node.subsystems.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.
core.contracts.NamedByHash | Implemented by anything that can be named by a secure hash value (e.g. transactions, attachments).
core.node.services.NetworkCacheError |

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.

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.

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.
node.services.persistence.NodeAttachmentService | Stores attachments in the specified local directory, which must exist. Doesnt allow new attachments to be uploaded.
node.services.config.NodeConfiguration |
node.services.config.NodeConfigurationFromConfig |
core.node.NodeInfo | Info about a network node that acts on behalf of some form of contract party.
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 ...).
node.services.network.NodeMapError |
node.services.network.NodeRegistration | A node registration state in the network map.
core.node.services.NodeTimestamperService | This class implements the server side of the timestamping protocol, using the local clock. A future version might add features like checking against other NTP servers to make sure the clock hasnt drifted by too much.
node.services.wallet.NodeWalletService | 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.
core.crypto.NullPublicKey |
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
core.contracts.OwnableState |
core.crypto.Party | A Party is well known (name, pubkey) pair. In a real system this would probably be an X.509 certificate.
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.
java.nio.file.Path (extensions in package core) |
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.
core.contracts.PaymentRule | Whether the payment should be made before the due date, or after it.
node.services.persistence.PerFileCheckpointStorage | File-based checkpoint storage, storing checkpoints per file.
contracts.PercentageRatioUnit | A class to reprecent a percentage in an unambiguous way.
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.
core.math.Polynomial | Represents a polynomial function of arbitrary degree
java.security.PrivateKey (extensions in package core.crypto) |
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 <emph>steps</emph> that represent an operation. A step is represented by an object (typically a singleton).
node.api.ProtocolClassRef |
node.api.ProtocolInstanceRef |
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.
node.api.ProtocolRef | Encapsulates the protocol to be instantiated. e.g. TwoPartyTradeProtocol.Buyer.
node.api.ProtocolRequiringAttention | Thinking that Instant is OK for short lived protocol deadlines.
core.protocols.ProtocolStateMachine | 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 core.crypto) |
contracts.Rate | Parent of the Rate family. Used to denote fixed rates, floating rates, reference rates etc

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.

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.
contracts.RatioUnit | A utility class to prevent the various mixups between percentages, decimals, bips etc.
core.utilities.RecordingMap | A RecordingMap wraps a regular Map<K, V> and records the sequence of gets and puts to it. This is useful in white box unit tests to ensure that code is accessing a data store as much as you expect.
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.
node.services.api.RegulatorService | Placeholder interface for regulator services.
core.contracts.Requirements |
protocols.ResolveTransactionsProtocol | This protocol fetches each transaction identified by the given hashes from either disk or network, along with all their dependencies, and verifies them together using a single TransactionGroup. If no exception is thrown, then all the transactions have been successfully verified and inserted into the local database.
node.servlets.ResponseFilter | This adds headers needed for cross site scripting on API clients
core.crypto.SecureHash |
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.
core.serialization.SerializedBytesSerializer | A serialiser that avoids writing the wrapper class to the byte stream, thus ensuring SerializedBytes is a pure type safety hack.
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.
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.
core.crypto.SignedData | A serialized piece of data and its signature. Enforces signature validity in order to deserialize the data contained within.
core.contracts.SignedTransaction | Container for a WireTransaction and attached signatures.
node.internal.testing.Simulation | Base class for network simulations that are based on the unit test / mock environment.
core.messaging.SingleMessageRecipient | A base class for the case of point-to-point messages
core.math.SplineFunction | A <emph>spline</emph> is function piecewise-defined by polynomial functions. Points at which polynomial pieces connect are known as <emph>knots</emph>.
node.services.statemachine.StackSnapshot |
core.contracts.StateAndRef | A StateAndRef is simply a (state, ref) pair. For instance, a wallet (which holds available assets) contains these.
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.
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.
node.api.StatesQuery | Extremely rudimentary query language which should most likely be replaced with a product
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.
node.services.persistence.StorageServiceImpl |
kotlin.String (extensions in package core) |
kotlin.String (extensions in package contracts) |
java.time.temporal.Temporal (extensions in package core) |
core.contracts.Tenor | Placeholder class for the Tenor datatype - which is a standardised duration of time until maturity

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.

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)

core.node.services.TimestamperService

Simple interface (for testing) to an abstract timestamping service. Note that this is not "timestamping" in the blockchain sense of a total ordering of transactions, but rather, a signature from a well known/trusted timestamping service over a transaction that indicates the timestamp in it is accurate. Such a signature may not always be necessary: if there are multiple parties involved in a transaction then they can cross-check the timestamp themselves.

core.node.services.TimestampingError |
protocols.TimestampingProtocol | The TimestampingProtocol class is the client code that talks to a NodeTimestamperService on some remote node. It is a ProtocolLogic, meaning it can either be a sub-protocol of some other protocol, or be driven independently.
core.messaging.TopicStringValidator | A singleton thats useful for validating topic strings
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).
demos.TraderDemoProtocolBuyer |
demos.TraderDemoProtocolSeller |
node.api.TransactionBuildStep | Encapsulate a generateXXX method call on a contract.
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 or modifying the existing set. Then once the states and commands are right, this class can be used as a holding bucket to gather signatures from multiple parties.
core.contracts.TransactionConflictException |
core.contracts.TransactionForVerification | A transaction in fully resolved and sig-checked form, ready for passing as input to a verification function.
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.
core.contracts.TransactionGroup | A TransactionGroup defines a directed acyclic graph of transactions that can be resolved with each other and then verified. Successful verification does not imply the non-existence of other conflicting transactions: simply that this subgraph does not contain conflicts and is accepted by the involved contracts.
core.contracts.TransactionResolutionException |
core.contracts.TransactionVerificationException | Thrown if a verification fails due to a contract rejection.
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.
protocols.TwoPartyDealProtocol | Classes for manipulating a two party deal or agreement.
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:
core.contracts.TypeOnlyCommandData | Commands that inherit from this are intended to have no data items: its only their presence that matters.
contracts.UnknownType |
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:
demos.protocols.UpdateBusinessDayProtocol | This is a very temporary, demo-oriented way of initiating processing of temporal events and is not intended as the way things will necessarily be done longer term

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.

node.services.wallet.WalletImpl

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.

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

node.services.network.WireNodeRegistration | A node registration and its signature as a pair.
core.contracts.WireTransaction | Transaction ready for serialisation, without any signatures attached.
core.serialization.WireTransactionSerializer | A serialisation engine that knows how to deserialise code inside a sandbox
core.node.WorldCoordinate | A latitude/longitude pair.