Module Contents

)

val smm:

object ANSIProgressRenderer

Module Contents

var progressTracker:

abstract fun buildTransaction(type:

interface APIServer

Module Contents

steps

List

)

abstract fun commitTransaction(tx:

signatures

List

)

abstract fun fetchProtocolsRequiringAttention(query:

)

Map

abstract fun fetchStates(states: List<

)

Map

abstract fun fetchTransactions(txs: List<

)

Map

abstract fun generateTransactionSignature(tx:

)

abstract fun invokeProtocolSync(type:

abstract fun provideProtocolResponse(protocol:

args

Map

String

Any

)

Any

choice

abstract fun queryStates(query:

args

Map

String

Any

)

Unit

)

List

abstract fun serverTime():

abstract fun status(): <ERROR CLASS>

class APIServerImpl :

Module Contents

APIServerImpl(node:

fun buildTransaction(type:

)

steps

List

)

fun commitTransaction(tx:

signatures

List

)

fun fetchProtocolsRequiringAttention(query:

)

Map

fun fetchStates(states: List<

)

Map

fun fetchTransactions(txs: List<

)

Map

fun generateTransactionSignature(tx:

)

fun invokeProtocolSync(type:

args

Map

String

Any

)

Any

fun provideProtocolResponse(protocol:

choice

args

Map

String

Any

)

Unit

fun queryStates(query:

)

List

fun serverTime():

fun status(): <ERROR CLASS>

abstract class AbstractConserveAmount<S :

Any

Module Contents

AbstractConserveAmount()

amountIssued

assetStates

List

deriveState

(

)

generateMoveCommand

(

)

generateExitCommand

(

)

)

amount

assetsStates

List

onlyFromParties

Set

deriveState

(

)

generateMoveCommand

(

)

)

List

inputs

List

outputs

List

commands

List

groupingKey

abstract class AbstractIssue<in S :

)

Set

Any

Module Contents

AbstractIssue(sum: List<S>.() ->

sumOrZero

List

(

)

)

val sum: List<S>.() ->

val sumOrZero: List<S>.(

)

inputs

List

outputs

List

commands

List

groupingKey

abstract class AbstractJDBCHashMap<K : Any, V : Any, out T :

)

Set

AbstractJDBCHashMap(table: T, loadOnInit: Boolean = false)

MutableMap

AbstractMap

Module Contents

protected abstract fun addKeyToInsert(insert: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit

protected abstract fun addValueToInsert(insert: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit

open fun containsValue(value: V): Boolean

open val entries: MutableSet<MutableEntry<K, V>>

open fun get(key: K): V?

protected abstract fun keyFromRow(row: <ERROR CLASS>): K

val loadOnInit: Boolean

open fun put(key: K, value: V): V?

open fun remove(key: K): V?

protected abstract fun valueFromRow(row: <ERROR CLASS>): V

val table: T

open val values: MutableCollection<V>

abstract class AbstractJDBCHashSet<K : Any, out T :

AbstractJDBCHashSet(table: T, loadOnInit: Boolean = false)

MutableSet

AbstractSet

Module Contents

open fun add(element: K): Boolean

protected abstract fun addElementToInsert(insert: <ERROR CLASS>, entry: K, finalizables: MutableList<() -> Unit>): Unit

open fun contains(element: K): Boolean

protected abstract fun elementFromRow(row: <ERROR CLASS>): K

protected val innerMap:

Unit

open fun iterator(): MutableIterator<K>

open fun remove(element: K): Boolean

abstract class AbstractNetworkMapService :

protected val table: T

AbstractNetworkMapService(services:

AbstractNodeService

Module Contents

protected val _mapVersion:

)

AtomicInteger

fun getUnacknowledgedCount(subscriber:

mapVersion

Int

)

Int

val maxSizeRegistrationRequestBytes: Int

val maxUnacknowledgedUpdates: Int

open val nodes: List<

fun notifySubscribers(wireReg:

fun processAcknowledge(req:

mapVersion

Int

)

Unit

UpdateAcknowledge

)

Unit

fun processFetchAllRequest(req:

FetchMapRequest

)

FetchMapResponse

fun processQueryRequest(req:

QueryIdentityRequest

)

QueryIdentityResponse

fun processRegistrationChangeRequest(req:

RegistrationRequest

)

RegistrationResponse

fun processSubscriptionRequest(req:

SubscribeRequest

)

SubscribeResponse

protected abstract val registeredNodes: MutableMap<

protected fun setup(): Unit

protected abstract val subscribers:

MutableMap

fun unregisterNetworkHandlers(): Unit

abstract class AbstractNode :

AbstractNode(configuration:

Module Contents

networkMapService

advertisedServices

Set

platformClock

class DatabaseConfigurationException :

)

DatabaseConfigurationException(msg: String)

Module Contents

val PRIVATE_KEY_FILE_NAME: String

val PUBLIC_IDENTITY_FILE_NAME: String

protected val _servicesThatAcceptUploads:

val advertisedServices: Set<

lateinit var api:

lateinit var checkpointStorage:

open val configuration:

protected open fun constructStorageService(attachments:

transactionStorage

stateMachineRecordedTransactionMappingStorage

protected fun createNodeDir(): Unit

)

StorageServiceImpl

val customServices:

lateinit var database: <ERROR CLASS>

Any

protected var dbCloser:

inline fun <reified T : Any> findService(): <ERROR CLASS>

protected open fun generateKeyPair():

lateinit var identity:

var inNodeNetworkMapService:

var inNodeNotaryService:

val info:

protected open fun initialiseCheckpointService(dir:

)

protected open fun initialiseDatabasePersistence(insideTransaction: () -> Unit): Unit

protected open fun initialiseStorageService(dir:

)

var isPreviousCheckpointsPresent: Boolean

lateinit var keyManagement:

protected abstract val log: <ERROR CLASS>

protected fun makeAttachmentStorage(dir:

)

protected open fun makeIdentityService():

protected open fun makeKeyManagementService():

protected abstract fun makeMessagingService():

protected open fun makeNetworkMapService(): Unit

protected open fun makeNotaryService(type:

)

protected open fun makeSchemaService():

protected abstract fun makeUniquenessProvider():

protected open fun makeVaultService():

lateinit var net:

lateinit var netMapCache:

val networkMapRegistrationFuture: <ERROR CLASS><Unit>

var networkMapSeq: Long

val networkMapService:

protected open fun noNetworkMapConfigured(): <ERROR CLASS><Unit>

protected fun obtainLegalIdentity():

protected fun obtainLegalIdentityKey():

protected val partyKeys: <ERROR CLASS>

val platformClock:

protected val pluginRegistries: List<

lateinit var protocolLogicFactory:

protected val runOnStop:

lateinit var scheduler:

lateinit var schemas:

protected abstract val serverThread:

val servicesThatAcceptUploads: List<

protected abstract fun startMessagingService(cordaRPCOps:

)

Unit

var started: Boolean

open fun stop(): Unit

lateinit var storage:

var uniquenessProvider:

lateinit var vault:

abstract class AbstractNodeService :

AbstractNodeService(services:

Module Contents

)

reified

Any

addMessageHandler

(

topic

String

crossinline

handler

(

)

crossinline

exceptionConsumer

(

)

Unit

)

reified

Any

addMessageHandler

(

topic

String

crossinline

handler

(

)

val net:

abstract class AbstractStateReplacementProtocol<T>

Module Contents

AbstractStateReplacementProtocol()

abstract class Acceptor<T> :

Unit

Module Contents

progressTracker

)

protected abstract fun verifyProposal(maybeProposal:

)

abstract class Instigator<out S :

Module Contents

protected abstract fun assembleProposal(stateRef:

modification

progressTracker

)

modification

stx

)

protected abstract fun assembleTx(): <ERROR CLASS><

List

interface Proposal<out T>

Module Contents

abstract val modification: T

abstract val stateRef:

Module Contents

)

)

interface AcceptsFileUpload

Module Contents

abstract val acceptableFileExtensions: List<String>

abstract val dataTypePrefix: String

abstract fun upload(data:

enum class AccrualAdjustment

)

String

Module Contents

Adjusted

Unadjusted

object Ack :

interface AffinityExecutor :

enum class AddOrRemove

Module Contents

ADD

REMOVE

Module Contents

class Gate :

Gate(alwaysQueue: Boolean = false)

Module Contents

fun execute(command:

)

Unit

val taskQueueSize: Int

fun waitAndRun(): Unit

val SAME_THREAD:

class ServiceAffinityExecutor :

ServiceAffinityExecutor(threadName: String, numThreads: Int)

ThreadPoolExecutor

Module Contents

protected fun afterExecute(r:

Throwable

)

Unit

open fun checkOnThread(): Unit

open fun executeASAP(runnable: () -> Unit): Unit

open fun <T> fetchFrom(fetcher: () -> T): T

open fun flush(): Unit

abstract val isOnThread: Boolean

class AggregatedList<A, E : Any, K : Any> : TransformationList<A, E>

Module Contents

AggregatedList(list: ObservableList<out E>, toKey: (E) -> K, assemble: (K, ObservableList<E>) -> A)

val assemble: (K, ObservableList<E>) -> A

fun get(index: Int): A?

protected fun sourceChanged(c: Change<out E>): Unit

val toKey: (E) -> K

class AllComposition<S :

Any

AllComposition(firstClause:

Module Contents

vararg

remainingClauses

)

)

List

inputs

List

outputs

List

commands

List

interface AllPossibleRecipients :

groupingKey

)

Set

data class Amount<T> : Comparable<

Module Contents

Amount(amount:

Amount(quantity: Long, token: T)

currency

)

operator fun div(other: Long):

)

Int

operator fun div(other: Int):

operator fun minus(other:

)

operator fun plus(other:

)

operator fun times(other: Long):

val quantity: Long

operator fun times(other: Int):

fun exchange(currency: ObservableValue<

val token: T

object AmountBindings

Module Contents

exchangeRate

ObservableValue

)

ObservableValue

(

fun <T> sum(amounts: ObservableList<

)

Long

fun sumAmountExchange(amounts: ObservableList<

token

)

currency

ObservableValue

exchangeRate

ObservableValue

)

ObservableValue

AmountGenerator(tokenGenerator: <ERROR CLASS><T>)

class AmountGenerator<T>

Module Contents

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

val tokenGenerator: <ERROR CLASS><T>

class AnyComposition<in S :

Any

AnyComposition(vararg rawClauses:

Module Contents

)

val clauses: List<

)

List

inputs

List

outputs

List

commands

List

AppContext(attachments: List<

groupingKey

)

Set

data class AppContext

Module Contents

)

val classLoader:

abstract class ArtemisMessagingComponent :

ArtemisMessagingComponent(config:

Module Contents

protected interface ArtemisAddress

)

Module Contents

abstract val hostAndPort: <ERROR CLASS>

abstract val queueName: <ERROR CLASS>

const val CLIENTS_PREFIX: String

protected enum class ConnectionDirection

Module Contents

INBOUND

OUTBOUND

protected val NETWORK_MAP_ADDRESS: <ERROR CLASS>

protected data class NetworkMapAddress :

NetworkMapAddress(hostAndPort: <ERROR CLASS>)

Module Contents

data class NodeAddress :

Module Contents

NodeAddress(identity:

hostAndPort

)

const val PEERS_PREFIX: String

const val RPC_REQUESTS_QUEUE: String

fun checkStorePasswords(): Unit

fun configureWithDevSSLCertificate(): Unit

protected fun parseKeyFromQueueName(name: String):

protected fun tcpTransport(direction:

ConnectionDirection

host

String

port

Int

)

fun toHostAndPort(target:

protected fun toQueueName(target:

)

class ArtemisMessagingServer :

)

ArtemisMessagingServer(config:

Module Contents

myHostPort

networkMapCache

fun bridgeToNetworkMapService(networkMapService:

)

)

Unit

val myHostPort: <ERROR CLASS>

class AssociatedList<K, out A, B> :

AssociatedList(sourceList: ObservableList<out A>, toKey: (A) -> K, assemble: (K, A) -> B)

Unit

Module Contents

val sourceList: ObservableList<out A>

interface Attachment :

open fun extractFile(path: String, outputTo:

Module Contents

OutputStream

)

Unit

abstract fun open():

class AttachmentDownloadServlet

open fun openAsJAR():

JarInputStream

Module Contents

AttachmentDownloadServlet()

fun doGet(req: <ERROR CLASS>, resp: <ERROR CLASS>): Unit

interface AttachmentStorage

Module Contents

abstract fun importAttachment(jar:

)

abstract fun openAttachment(id:

)

class AttachmentsClassLoader :

SecureClassLoader

Module Contents

AttachmentsClassLoader(attachments: List<

parent

class OverlappingAttachments :

)

OverlappingAttachments(path: String)

Module Contents

val path: String

protected fun findClass(name: String):

protected fun findResource(name: String):

fun getResourceAsStream(name: String):

data class AuthenticatedObject<out T : Any>

Module Contents

AuthenticatedObject(signers: List<

signingParties

List

value

)

val signingParties: List<

val value: T

object AutoOfferProtocol

Module Contents

Module Contents

Requester(dealToBeOffered:

Module Contents

)

object DEALING :

Module Contents

Module Contents

)

Module Contents

abstract class BaseTransaction :

BaseTransaction(inputs: List<*>, outputs: List<

Module Contents

notary

mustSign

List

type

timestamp

protected fun checkInvariants(): Unit

)

data class BilateralNetState :

open val inputs: List<*>

BilateralNetState(partyKeys: Set<

Module Contents

template

)

interface BilateralNettableState<N :

abstract val bilateralNetState: Any

Module Contents

abstract fun net(other: N): N

class BroadcastTransactionProtocol :

BroadcastTransactionProtocol(notarisedTransaction:

Unit

Module Contents

events

Set

participants

Set

data class NotifyTxRequest

)

Module Contents

NotifyTxRequest(tx:

events

Set

)

val events: Set<

val notarisedTransaction:

open class BusinessCalendar

Module Contents

val TEST_CALENDAR_DATA: <ERROR CLASS>

class UnknownCalendar :

UnknownCalendar(name: String)

Module Contents

open fun applyRollConvention(testDate:

dateRollConvention

)

val calendars: <ERROR CLASS>

fun createGenericSchedule(startDate:

period

calendar

dateRollConvention

noOfAdditionalPeriods

Int

endDate

periodOffset

Int

)

List

fun getInstance(vararg calname: String):

fun getOffsetDate(startDate:

period

steps

Int

)

val holidayDates: List<

open fun isWorkingDay(date:

fun moveBusinessDays(date:

)

Boolean

direction

Int

)

fun parseDateFromString(it: String):

Module Contents

Module Contents

Module Contents

Module Contents

)

List

Module Contents

out

Module Contents

Module Contents

)

Module Contents

val exitKeys: <ERROR CLASS>

Module Contents

)

Module Contents

amount

owner

)

owner

encumbrance

Int

)

val encumbrance: Int?

)

newOwner

)

)

amount

owner

)

)

List

)

tokenDef

pennies

Long

owner

notary

)

Unit

amount

owner

notary

)

Unit

class CashBalanceAsMetricsObserver

)

Unit

Module Contents

CashBalanceAsMetricsObserver(serviceHubInternal:

)

val serviceHubInternal:

object CashSchema

object CashSchemaV1 :

class PersistentCashState :

Module Contents

PersistentCashState(encumbrance: Int?, owner: String, pennies: Long, currency: String, issuerParty: String, issuerRef: ByteArray)

Module Contents

CertificateSigner(config:

var encumbrance: Int?

var issuerParty: String

var issuerRef: ByteArray

var owner: String

var pennies: Long

class CertificateSigner

Module Contents

certService

fun buildKeyStore(): Unit

)

val certService:

val pollInterval:

interface CertificateSigningService

Module Contents

abstract fun retrieveCertificates(requestId: String): Array<

abstract fun submitRequest(request: <ERROR CLASS>): String

class Checkpoint

Module Contents

Checkpoint(serializedFiber:

)

interface CheckpointStorage

Module Contents

abstract fun addCheckpoint(checkpoint:

abstract fun forEach(block: (

)

Unit

abstract fun removeCheckpoint(checkpoint:

)

Boolean

)

Unit

class ChosenList<E> : ObservableListBase<E>

)

Unit

Module Contents

ChosenList(chosenListObservable: ObservableValue<out ObservableList<out E>>)

fun get(index: Int): E

operator fun get(name: String):

object CityDatabase

Module Contents

abstract class Clause<in S :

Any

Module Contents

Clause()

)

List

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

sealed class CliParams

Module Contents

class DateChange :

DateChange(apiAddress: <ERROR CLASS>, dateString: String)

Module Contents

val dateString: String

Module Contents

dir

networkAddress

apiAddress

mapAddress

String

tradeWithIdentities

List

uploadRates

Boolean

defaultLegalName

String

autoSetup

Boolean

h2Port

Int

)

val autoSetup: Boolean

val dir:

val networkAddress: <ERROR CLASS>

val h2Port: Int

val mapAddress: String

val tradeWithIdentities: List<

val uploadRates: Boolean

Module Contents

dir

defaultLegalName

String

)

Trade(apiAddress: <ERROR CLASS>, tradeId: String)

Module Contents

val tradeId: String

class UploadRates :

UploadRates(apiAddress: <ERROR CLASS>)

Module Contents

val defaultBaseDirectory: String

fun legalName(node:

fun parse(options: <ERROR CLASS>):

)

String

val apiAddressArg: <ERROR CLASS>

object CliParamsSpec

Module Contents

val fakeTradeWithIdentityFile: <ERROR CLASS>

val h2PortArg: <ERROR CLASS>

val help: <ERROR CLASS>

val networkAddressArg: <ERROR CLASS>

val networkMapNetAddr: <ERROR CLASS>

val nonOptions: <ERROR CLASS>

val roleArg: <ERROR CLASS>

data class ClientRPCRequestMessage

Module Contents

ClientRPCRequestMessage(args:

const val METHOD_NAME: String

Array

Any

replyToAddress

String

observationsToAddress

String

methodName

String

)

const val OBSERVATIONS_TO: String

const val REPLY_TO: String

val args:

val observationsToAddress: String?

Array

Any

val methodName: String

val replyToAddress: String

sealed class ClientToServiceCommand

Module Contents

class ExitCash :

Module Contents

issueRef

)

Module Contents

issueRef

recipient

notary

)

Module Contents

recipient

)

Module Contents

key

)

signers

List

)

class CommandDataGenerator

interface CommandData

Module Contents

CommandDataGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class CommandGenerator

Module Contents

CommandGenerator()

class CommercialPaper :

Module Contents

Module Contents

Module Contents

)

List

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

Module Contents

Module Contents

)

Module Contents

Module Contents

owner

faceValue

maturityDate

)

)

val token:

)

)

)

)

)

Module Contents

maturityDate

)

faceValue

maturityDate

notary

)

paper

newOwner

)

Unit

paper

vault

List

)

Unit

class CommercialPaperLegacy :

)

Unit

Module Contents

CommercialPaperLegacy()

Module Contents

Module Contents

Module Contents

Module Contents

Module Contents

owner

faceValue

maturityDate

)

CommercialPaperLegacy

)

)

)

)

)

fun withoutOwner():

faceValue

maturityDate

notary

)

paper

newOwner

)

Unit

paper

vault

)

Unit

object CommercialPaperSchema

)

Unit

object CommercialPaperSchemaV1 :

class PersistentCommericalPaperState :

Module Contents

PersistentCommericalPaperState(issuanceParty: String, issuanceRef: ByteArray, owner: String, maturity:

Module Contents

faceValue

Long

currency

String

faceValueIssuerParty

String

faceValueIssuerRef

ByteArray

)

var faceValueIssuerParty: String

var faceValue: Long

var faceValueIssuerRef: ByteArray

var issuanceParty: String

var issuanceRef: ByteArray

Module Contents

Commodity(commodityCode: String, displayName: String, defaultFractionDigits: Int = 0)

val commodityCode: String

val defaultFractionDigits: Int

val displayName: String

fun getInstance(commodityCode: String):

class CommodityContract :

Module Contents

Module Contents

Module Contents

Module Contents

)

List

Module Contents

out

Module Contents

Module Contents

)

Module Contents

val exitKeys: MutableSet<

Module Contents

)

Module Contents

amount

owner

)

owner

)

newOwner

)

)

amount

owner

)

)

List

)

tokenDef

pennies

Long

owner

notary

)

Unit

amount

owner

notary

)

Unit

abstract class CompositeClause<in S :

)

Unit

Any

Module Contents

abstract val clauses: List<

)

List

abstract fun matchedClauses(commands: List<

)

List

class ConcatenatedList<A> : TransformationList<A, ObservableList<A>>

Module Contents

ConcatenatedList(sourceList: ObservableList<ObservableList<A>>)

protected fun sourceChanged(change: Change<out ObservableList<A>>): Unit

class Config

Module Contents

Config(services:

val defaultObjectMapper: <ERROR CLASS>

)

)

Module Contents

fun loadConfig(baseDirectoryPath:

configFileOverride

allowMissingConfig

Boolean

configOverrides

Map

String

Any

)

class ConfigurationException :

ConfigurationException(message: String)

Module Contents

interface Contract

Module Contents

abstract val legalContractReference:

data class ContractClassRef :

)

Unit

ContractClassRef(className: String)

Module Contents

data class ContractLedgerRef :

interface ContractDefRef

Module Contents

ContractLedgerRef(hash:

)

interface ContractState

Module Contents

abstract val contract:

open val encumbrance: Int?

abstract val participants: List<

class ContractStateGenerator

Module Contents

ContractStateGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

val cashStates: ObservableList<

class ContractStateModel

Module Contents

ContractStateModel()

val cashStatesDiff: <ERROR CLASS><

val contractStatesDiff: <ERROR CLASS><

abstract class CordaPluginRegistry

Module Contents

CordaPluginRegistry()

open val requiredProtocols: Map<String, Set<String>>

open val servicePlugins: List<

open val staticServeDirs: Map<String, String>

open val webApis: List<

class CordaRPCClient :

Closeable

CordaRPCClient(host: <ERROR CLASS>, certificatesPath:

Module Contents

)

fun close(): Unit

val host: <ERROR CLASS>

var myID: Int

fun proxy(timeout:

minVersion

Int

)

abstract fun executeCommand(command:

interface CordaRPCOps :

RPCOps

Module Contents

)

@RPCReturnsObservables abstract fun stateMachineRecordedTransactionMapping(): <ERROR CLASS><List<

@RPCReturnsObservables abstract fun stateMachinesAndUpdates(): <ERROR CLASS><List<

@RPCReturnsObservables abstract fun vaultAndUpdates(): <ERROR CLASS><List<

@RPCReturnsObservables abstract fun verifiedTransactions(): <ERROR CLASS><List<

class CubicSplineInterpolator :

CubicSplineInterpolator(xs: DoubleArray, ys: DoubleArray)

Module Contents

CubicSplineInterpolator

class CurrencyGenerator

Module Contents

CurrencyGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class DBCheckpointStorage :

Module Contents

DBCheckpointStorage()

)

Unit

)

Boolean

)

Unit

fun doPost(req: <ERROR CLASS>, resp: <ERROR CLASS>): Unit

)

Unit

class DataUploadServlet

Module Contents

DataUploadServlet()

Module Contents

Module Contents

Module Contents

class NotifyTransactionHandler :

)

NotifyTransactionHandler(otherParty:

Unit

Module Contents

)

class TransactionRejectedError :

TransactionRejectedError(msg: String)

Module Contents

enum class DateRollConvention

Module Contents

Actual

Module Contents

Following

Module Contents

ModifiedFollowing

Module Contents

ModifiedPrevious

Module Contents

Module Contents

abstract fun direction():

abstract val isModified: Boolean

enum class DateRollDirection

Module Contents

BACKWARD

FORWARD

val value: Long

enum class DayCountBasisDay

Module Contents

enum class DayCountBasisYear

Module Contents

interface DealState :

abstract fun generateAgreement(notary:

Module Contents

)

abstract val parties: List<

abstract val ref: String

class DemoClock :

MutableClock

Module Contents

DemoClock(delegateClock:

)

)

fun updateDate(date:

)

Boolean

fun withZone(zone:

ZoneId

)

interface DeserializeAsKotlinObjectDef

data class Diff<out T :

Module Contents

Diff(added: Collection<

removed

Collection

)

val added: Collection<

val removed: Collection<

open class DigitalSignature :

DigitalSignature(bits: ByteArray)

Module Contents

class LegallyIdentifiable :

LegallyIdentifiable(signer:

Module Contents

bits

ByteArray

)

Module Contents

bits

ByteArray

)

val by:

fun verifyWithECDSA(content: ByteArray): Unit

fun verifyWithECDSA(content:

DriverDSLInternalInterface

)

Unit

class DriverDSL :

Module Contents

DriverDSL(portAllocation:

debugPortAllocation

baseDirectory

String

isDebug

Boolean

)

Module Contents

val registeredProcesses:

LinkedList

val baseDirectory: String

val debugPortAllocation:

fun <A> pickA(array: Array<A>): A

val isDebug: Boolean

val name: Array<String>

val networkMapCache:

InMemoryNetworkMapCache

val portAllocation:

fun registerProcess(process:

)

Unit

fun shutdown(): Unit

fun startClient(providedName: String, serverAddress: <ERROR CLASS>):

fun startLocalServer():

fun startNode(providedName: String?, advertisedServices: Set<

)

fun waitForAllNodesToFinish(): Unit

interface DriverDSLExposedInterface

Module Contents

abstract fun startClient(providedName: String, serverAddress: <ERROR CLASS>):

abstract fun startLocalServer():

abstract fun startNode(providedName: String? = null, advertisedServices: Set<

)

abstract fun waitForAllNodesToFinish(): Unit

interface DriverDSLInternalInterface :

abstract fun shutdown(): Unit

Module Contents

abstract fun start(): Unit

class DummyContract :

Module Contents

Module Contents

Module Contents

Module Contents

data class MultiOwnerState :

MultiOwnerState(magicNumber: Int = 0, owners: List<

Module Contents

)

data class SingleOwnerState :

SingleOwnerState(magicNumber: Int = 0, owner:

Module Contents

)

)

interface State :

abstract val magicNumber: Int

Module Contents

fun generateInitial(owner:

magicNumber

Int

notary

)

newOwner

)

fun move(priors: List<

newOwner

)

)

Unit

class DummyPublicKey :

Comparable

DummyPublicKey(s: String)

Module Contents

)

Int

fun getEncoded(): <ERROR CLASS>

val s: String

data class DummyState :

DummyState(magicNumber: Int = 0)

Module Contents

val contract:

DummyContract

val magicNumber: Int

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class DurationGenerator

Module Contents

DurationGenerator()

class E2ETestKeyManagementService :

E2ETestKeyManagementService(initialKeys: Set<

Module Contents

)

object Ed25519PrivateKeySerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: <ERROR CLASS>): Unit

)

object Ed25519PublicKeySerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: <ERROR CLASS>): Unit

)

object Emoji

Module Contents

const val CODE_BAG_OF_CASH: String

const val CODE_DIAMOND: String

const val CODE_GREEN_TICK: String

const val CODE_LEFT_ARROW: String

const val CODE_NEWSPAPER: String

const val CODE_PAPERCLIP: String

const val CODE_RIGHT_ARROW: String

val bagOfCash: String

val diamond: String

val hasEmojiTerminal: <ERROR CLASS>

val leftArrow: String

val newspaper: String

val paperclip: String

fun renderIfSupported(obj: Any): String

val rightArrow: String

data class ErrorOr<out A>

Module Contents

ErrorOr(value: A)

)

inline fun <T> catch(body: () -> T):

Nothing

fun <B, C> combine(other:

function

(

)

fun map(function: (A) -> B): <ERROR CLASS>

val error: Throwable?

fun getOrThrow(): A

fun <T> match(onValue: (A) -> T, onError: (Throwable) -> T): T

fun of(t: Throwable):

Nothing

Module Contents

)

EventGenerator(parties: List<

class EventGenerator

Module Contents

notary

val amountGenerator: <ERROR CLASS>

)

val amountIssuedGenerator: <ERROR CLASS>

val cashStateGenerator: <ERROR CLASS>

val clientToServiceCommandGenerator: <ERROR CLASS>

val consumedGenerator:

Set

val currencyGenerator: <ERROR CLASS>

val exitCashGenerator: <ERROR CLASS>

val issueCashGenerator: <ERROR CLASS>

val issueRefGenerator:

val moveCashGenerator: <ERROR CLASS>

val producedGenerator:

Set

val publicKeyGenerator: <ERROR CLASS>

interface ExchangeRate

Module Contents

abstract fun rate(from:

val exchangeRate: ObservableValue<

)

Double

class ExchangeRateModel

Module Contents

ExchangeRateModel()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class ExitGenerator

Module Contents

ExitGenerator()

object ExitServerProtocol

Module Contents

ExitMessage(exitCode: Int)

Boolean

Module Contents

Broadcast(exitCode: Int)

fun call(): Boolean

val exitCode: Int

data class ExitMessage

Module Contents

Module Contents

object ExpressionDeserializer

Module Contents

)

data class Expression

Module Contents

Expression(expr: String)

val expr: String

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ExpressionSerializer

Module Contents

fun serialize(expr:

class FetchAttachmentsProtocol :

generator

provider

)

Unit

FetchAttachmentsProtocol(requests: Set<

ByteArray

Module Contents

otherSide

protected fun convert(wire: ByteArray):

)

)

protected fun maybeWriteToDisk(downloaded: List<

abstract class FetchDataProtocol<T :

)

Unit

Any

FetchDataProtocol(requests: Set<

Module Contents

otherSide

)

open class BadAnswer :

class DownloadedVsRequestedDataMismatch :

Module Contents

BadAnswer()

BadAnswer

Module Contents

DownloadedVsRequestedDataMismatch(requested:

got

)

Module Contents

HashNotFound(requested:

)

Module Contents

Request(hashes: List<

)

val hashes: List<

data class Result<out T :

Result(fromDisk: List<T>, downloaded: List<T>)

Module Contents

val downloaded: List<T>

val fromDisk: List<T>

open fun call():

protected open fun convert(wire: W): T

protected abstract fun load(txid:

protected open fun maybeWriteToDisk(downloaded: List<T>): Unit

)

protected val otherSide:

protected val requests: Set<

class FetchTransactionsProtocol :

FetchTransactionsProtocol(requests: Set<

Module Contents

otherSide

)

)

FiberBox(content: T, lock:

class FiberBox<out T>

Module Contents

Lock

)

fun <R> read(body: T.() -> R): R

fun <R> readWithDeadline(clock:

deadline

fun <R> write(body: T.() -> R): R

body

(

)

Any

Module Contents

filterStates

(

List

)

List

)

val filterStates: (List<

fun getExecutionPath(commands: List<

)

List

)

List

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

class FinalityProtocol :

FinalityProtocol(transaction:

Unit

Module Contents

events

Set

participants

Set

progressTracker

)

object BROADCASTING :

class FirstComposition<S :

Any

FirstComposition(firstClause:

Module Contents

vararg

remainingClauses

)

)

List

inputs

List

outputs

List

commands

List

FixOf(name: String, forDay:

groupingKey

)

Set

Module Contents

value

)

Module Contents

ofTenor

)

interface FixableDealState :

abstract fun generateFix(ptx:

Module Contents

oldState

fix

abstract fun nextFixingOf():

)

Unit

abstract val oracleType:

Module Contents

)

fun isPositive(): Boolean

class FixedRatePaymentEvent :

FixedRatePaymentEvent(date:

Module Contents

accrualStartDate

accrualEndDate

dayCountBasisDay

dayCountBasisYear

notional

rate

)

val flow:

object FixingSessionInitiation

Module Contents

Module Contents

Module Contents

class FlattenedList<A> : TransformationList<A, ObservableValue<out A>>

)

Module Contents

FlattenedList(sourceList: ObservableList<out ObservableValue<out A>>)

class WrappedObservableValue<A>

Module Contents

WrappedObservableValue(observableValue: ObservableValue<A>)

val observableValue: ObservableValue<A>

val indexMap:

WrappedObservableValue

out

Int

ChangeListener

protected fun sourceChanged(c: Change<out ObservableValue<out A>>): Unit

val sourceList: ObservableList<out ObservableValue<out A>>

open class FloatingRate :

class FloatingRatePaymentEvent :

Module Contents

FloatingRate()

FloatingRatePaymentEvent(date:

Module Contents

accrualStartDate

accrualEndDate

dayCountBasisDay

dayCountBasisYear

fixingDate

notional

rate

)

accrualStartDate

accrualEndDate

dayCountBasisDay

dayCountBasisYear

fixingDate

notional

rate

)

fun withNewRate(newRate:

)

Module Contents

Module Contents

Long

)

Module Contents

Long

)

Module Contents

Long

)

Module Contents

Long

)

Module Contents

Long

)

Module Contents

Long

)

Module Contents

Long

)

val annualCompoundCount: Int

abstract fun offset(d:

Long

)

class FullNodeConfiguration :

FullNodeConfiguration(config: <ERROR CLASS>)

Module Contents

val artemisAddress: <ERROR CLASS>

val dataSourceProperties:

val extraAdvertisedServiceIds: String

val devMode: Boolean

val emailAddress: String

val exportJMXto: String

val keyStorePassword: String

val messagingServerAddress: <ERROR CLASS>?

val myLegalName: String

val nearestCity: String

val networkMapAddress: <ERROR CLASS>?

val trustStorePassword: String

val useHTTPS: Boolean

val webAddress: <ERROR CLASS>

interface FungibleAsset<T> :

Module Contents

Module Contents

Module Contents

abstract val deposit:

abstract val exitKeys: Collection<

abstract val issuanceDef:

abstract fun move(newAmount:

newOwner

)

data class GatheredTransactionData

Module Contents

GatheredTransactionData(transaction:

stateMachines

ObservableList

out

val stateMachines: ObservableList<out

)

class GatheredTransactionDataModel

Module Contents

GatheredTransactionDataModel()

val collectedTransactions: <ERROR CLASS>

val gatheredTransactionDataList: ObservableList<out

GatheredTransactionData

val partiallyResolvedTransactions: <ERROR CLASS>

val progressEvents: <ERROR CLASS>

val smTxMappingList: <ERROR CLASS>

val stateMachineDataList: ObservableList<

val stateMachineDataMap: ObservableMap<

val stateMachineStatus: ObservableMap<

out

ObservableValue

val transactionMap: <ERROR CLASS>

class Generator<out A>

Module Contents

Generator(generate: (

)

)

)

fun <A> choice(generators: List<

Nothing

)

fun <B, R> combine(other1:

Nothing

function

(

)

fun <B, C, R> combine(other1:

other2

function

(

)

fun <B, C, D, R> combine(other1:

other2

other3

function

(

)

fun <B, C, D, E, R> combine(other1:

other2

other3

other4

function

(

)

)

fun <A> frequency(vararg generators: <ERROR CLASS><Double,

)

)

fun <A> impure(valueClosure: () -> A):

fun map(function: (A) -> B):

fun product(other:

(

)

fun <A> pure(value: A):

fun <A> sequence(generators: List<

)

fun <A> success(generate: (

List

)

abstract class GroupClauseVerifier<S :

Any

Unit

Module Contents

GroupClauseVerifier(clause:

)

)

List

abstract fun groupStates(tx:

)

List

inputs

List

outputs

List

commands

List

class HTTPCertificateSigningService :

groupingKey

Unit

)

Set

HTTPCertificateSigningService(server:

Module Contents

val clientVersion: String

)

fun retrieveCertificates(requestId: String): Array<

val server:

fun submitRequest(request: <ERROR CLASS>): String

class HibernateObserver

Module Contents

HibernateObserver(services:

class NodeDatabaseConnectionProvider

)

Module Contents

NodeDatabaseConnectionProvider()

fun closeConnection(conn:

)

Unit

fun getConnection():

fun isUnwrappableAs(unwrapType:

fun supportsAggressiveRelease(): Boolean

)

Boolean

fun <T> unwrap(unwrapType:

)

val schemaService:

val sessionFactories:

ConcurrentHashMap

class IRSDemoPluginRegistry :

enum class IRSDemoNode

Module Contents

Module Contents

IRSDemoPluginRegistry()

val staticServeDirs: Map<String, String>

val webApis: List<

enum class IRSDemoRole

Module Contents

class IRSSimulation :

IRSSimulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, latencyInjector: <ERROR CLASS>?)

Module Contents

fun iterate(): <ERROR CLASS>?

val om: <ERROR CLASS>

protected fun startMainSimulation(): <ERROR CLASS><Unit>

interface IdentityService

Module Contents

abstract fun partyFromKey(key:

)

abstract fun partyFromName(name: String):

abstract fun registerIdentity(party:

class IllegalProtocolLogicException :

)

Unit

IllegalArgumentException

Module Contents

IllegalProtocolLogicException(type:

class ImmutableClassSerializer<T : Any>

msg

String

)

Module Contents

ImmutableClassSerializer(klass: KClass<T>)

val constructor: <ERROR CLASS>

val klass: KClass<T>

val props: <ERROR CLASS>

val propsByName: <ERROR CLASS>

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: T): Unit

)

class InMemoryIdentityService :

InMemoryIdentityService()

Module Contents

fun partyFromKey(key:

)

fun partyFromName(name: String):

fun registerIdentity(party:

open class InMemoryNetworkMapCache :

)

Unit

InMemoryNetworkMapCache()

Module Contents

open fun addMapService(net:

networkMapAddress

Boolean

ifChangedSinceVer

Int

)

Unit

open fun addNode(node:

open val changed: <ERROR CLASS><

)

Unit

open fun deregisterForUpdates(net:

service

open fun get(): <ERROR CLASS>

)

Unit

open fun get(serviceType:

open fun getNodeByLegalName(name: String): <ERROR CLASS>

)

open fun getNodeByPublicKey(publicKey:

open fun getRecommended(type:

)

contract

vararg

party

)

open val mapServiceRegistered: <ERROR CLASS><Unit>

open val networkMapNodes: List<

open val notaryNodes: List<

open val partyNodes: List<

fun processUpdatePush(req:

protected var registeredNodes: MutableMap<

)

Unit

open val regulators: List<

open fun removeNode(node:

open fun runWithoutMapService(): Unit

)

Unit

class InMemoryNetworkMapService :

InMemoryNetworkMapService(services:

Module Contents

)

protected val subscribers: <ERROR CLASS>

class InMemoryStateMachineRecordedTransactionMappingStorage :

InMemoryStateMachineRecordedTransactionMappingStorage()

Module Contents

fun addMapping(stateMachineRunId:

transactionId

)

Unit

class InMemoryUniquenessProvider :

InMemoryUniquenessProvider()

Module Contents

txId

callerIdentity

open class InMemoryVaultService :

)

Unit

InMemoryVaultService(services:

Module Contents

protected class InnerState

)

Module Contents

InnerState()

val _updatesPublisher: <ERROR CLASS>

var vault:

open val currentVault:

open val linearHeads: Map<

protected open val log: <ERROR CLASS>

protected val mutex:

open fun notifyAll(txns: Iterable<

InnerState

)

protected val services:

open fun track(): <ERROR CLASS><

open val updates: <ERROR CLASS><

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class InstantGenerator

Module Contents

InstantGenerator()

class InsufficientBalanceException :

InsufficientBalanceException(amountMissing:

Module Contents

)

val amountMissing:

class InterestRateSwap :

Module Contents

InterestRateSwap()

data class Calculation

Module Contents

Calculation(expression:

floatingLegPaymentSchedule

Map

fixedLegPaymentSchedule

Map

val fixedLegPaymentSchedule: Map<

)

fun applyFixing(date:

newRate

)

val floatingLegPaymentSchedule: Map<

fun getFixing(date:

)

fun nextFixingDate():

abstract class AbstractIRSClause :

interface Clauses

Module Contents

Module Contents

fun checkLegAmounts(legs: List<

fun checkLegDates(legs: List<

)

Unit

fun checkRates(legs: List<

)

Unit

fun checkSchedules(legs: List<

)

Boolean

fun getFloatingLegPaymentsDifferences(payments1: Map<

)

Boolean

payments2

Map

)

List

class Agree :

AbstractIRSClause

Module Contents

Agree()

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

)

List

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Unit

Module Contents

Timestamped()

inputs

List

outputs

List

commands

List

groupingKey

Unit

)

Set

Module Contents

Module Contents

Module Contents

Module Contents

Module Contents

)

Module Contents

eligibleCurrency

eligibleCreditSupport

String

independentAmounts

threshold

minimumTransferAmount

rounding

valuationDateDescription

String

notificationTime

String

resolutionTime

String

interestRate

ReferenceRate

addressForTransfers

String

exposure

localBusinessDay

dailyInterestAmount

val addressForTransfers: String

tradeID

String

hashLegalDocs

String

)

val baseCurrency:

val dailyInterestAmount:

val eligibleCreditSupport: String

val eligibleCurrency:

val exposure:

val hashLegalDocs: String

val independentAmounts:

val localBusinessDay:

val minimumTransferAmount:

val notificationTime: String

val resolutionTime: String

val valuationDateDescription: String

abstract class CommonLeg

Module Contents

paymentFrequency

effectiveDate

effectiveDateAdjustment

terminationDate

terminationDateAdjustment

dayCountBasisDay

dayCountBasisYear

dayInMonth

Int

paymentRule

paymentDelay

Int

paymentCalendar

interestPeriodAdjustment

)

val effectiveDateAdjustment:

val interestPeriodAdjustment:

val paymentDelay: Int

val paymentFrequency:

val terminationDateAdjustment:

class FixedLeg :

Module Contents

FixedLeg(fixedRatePayer:

notional

paymentFrequency

effectiveDate

effectiveDateAdjustment

terminationDate

terminationDateAdjustment

dayCountBasisDay

dayCountBasisYear

dayInMonth

Int

paymentRule

paymentDelay

Int

paymentCalendar

interestPeriodAdjustment

fixedRate

rollConvention

)

fun copy(fixedRatePayer:

notional

paymentFrequency

effectiveDate

effectiveDateAdjustment

terminationDate

terminationDateAdjustment

dayCountBasisDay

dayCountBasisYear

dayInMonth

Int

paymentRule

paymentDelay

Int

paymentCalendar

interestPeriodAdjustment

fixedRate

)

FixedLeg

var rollConvention:

class FloatingLeg :

FloatingLeg(floatingRatePayer:

Module Contents

notional

paymentFrequency

effectiveDate

effectiveDateAdjustment

terminationDate

terminationDateAdjustment

dayCountBasisDay

dayCountBasisYear

dayInMonth

Int

paymentRule

paymentDelay

Int

paymentCalendar

interestPeriodAdjustment

rollConvention

fixingRollConvention

resetDayInMonth

Int

fixingPeriodOffset

Int

resetRule

fixingsPerPayment

fixingCalendar

index

String

indexSource

String

indexTenor

fun copy(floatingRatePayer:

)

notional

paymentFrequency

effectiveDate

effectiveDateAdjustment

terminationDate

terminationDateAdjustment

dayCountBasisDay

dayCountBasisYear

dayInMonth

Int

paymentRule

paymentDelay

Int

paymentCalendar

interestPeriodAdjustment

rollConvention

fixingRollConvention

resetDayInMonth

Int

fixingPeriod

Int

resetRule

fixingsPerPayment

fixingCalendar

index

String

indexSource

String

indexTenor

)

FloatingLeg

var fixingCalendar:

var fixingPeriodOffset: Int

var fixingRollConvention:

var fixingsPerPayment:

var floatingRatePayer:

var index: String

var indexSource: String

var indexTenor:

var resetDayInMonth: Int

fun evaluateCalculation(businessDate:

Module Contents

floatingLeg

calculation

common

linearId

)

expression

fun generateAgreement(notary:

)

Any

)

oldState

fix

)

Unit

fun isRelevant(ourKeys: Set<

fun nextScheduledActivity(thisStateRef:

)

Boolean

protocolLogicRefFactory

)

val parties: List<

fun prettyPrint(): <ERROR CLASS>

val ref: String

fun generateAgreement(floatingLeg:

fixedLeg

calculation

common

notary

)

irs

fixing

)

Unit

val legalContractReference: <ERROR CLASS>

class InterestRateSwapAPI

)

Unit

Module Contents

InterestRateSwapAPI(services:

fun exitServer(): <ERROR CLASS>

)

fun fetchDeal(ref: String): <ERROR CLASS>

fun fetchDeals(): Array<

fun storeDeal(newDeal:

fun storeDemoDate(newDemoDate:

)

abstract fun interpolate(x: Double): Double

)

interface Interpolator

Module Contents

interface InterpolatorFactory

Module Contents

abstract fun create(xs: DoubleArray, ys: DoubleArray):

interface IssuanceDefinition

interface IssueCommand :

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

Module Contents

abstract val nonce: Long

class IssueGenerator

Module Contents

IssueGenerator()

data class Issued<out P>

Module Contents

Issued(issuer:

product

)

val issuer:

val product: P

IssuedGenerator(productGenerator: <ERROR CLASS><T>)

class IssuedGenerator<T>

Module Contents

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

val productGenerator: <ERROR CLASS><T>

class JDBCHashMap<K : Any, V : Any> :

JDBCHashMap(tableName: String, loadOnInit: Boolean = false)

BlobMapTable

Module Contents

class BlobMapTable :

BlobMapTable(tableName: String)

Module Contents

protected fun addKeyToInsert(insert: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit

val value: <ERROR CLASS>

protected fun addValueToInsert(insert: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit

protected fun keyFromRow(row: <ERROR CLASS>): K

protected fun valueFromRow(row: <ERROR CLASS>): V

class JDBCHashSet<K : Any> :

AbstractJDBCHashSet

BlobSetTable

Module Contents

JDBCHashSet(tableName: String, loadOnInit: Boolean = false)

class BlobSetTable :

BlobSetTable(tableName: String)

Module Contents

protected fun addElementToInsert(insert: <ERROR CLASS>, entry: K, finalizables: MutableList<() -> Unit>): Unit

protected fun elementFromRow(row: <ERROR CLASS>): K

open class JDBCHashedTable

Module Contents

JDBCHashedTable(tableName: String)

val keyHash: <ERROR CLASS>

val seqNo: <ERROR CLASS>

object JsonSupport

Module Contents

object CalendarDeserializer

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object LocalDateDeserializer

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object LocalDateKeyDeserializer

Module Contents

fun deserializeKey(text: String, p1: <ERROR CLASS>): Any?

object PartyDeserializer

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object PartySerializer

Module Contents

object PublicKeyDeserializer

generator

provider

)

Unit

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): <ERROR CLASS>

object PublicKeySerializer

Module Contents

fun serialize(obj: <ERROR CLASS>, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit

object PublicKeyTreeDeserializer

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object PublicKeyTreeSerializer

Module Contents

class SecureHashDeserializer<T :

generator

provider

)

Unit

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): T

Module Contents

SecureHashDeserializer()

object SecureHashSerializer

Module Contents

class ServiceHubObjectMapper

generator

provider

)

Unit

Module Contents

ServiceHubObjectMapper(identities:

)

val identities:

object ToStringSerializer

Module Contents

fun serialize(obj: Any, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit

fun createDefaultMapper(identities:

interface KeyManagementService

)

Module Contents

abstract fun freshKey():

abstract val keys: Map<

open fun toKeyPair(publicKey:

)

open fun toPrivate(publicKey:

)

object KotlinObjectSerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

)

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj:

data class LastAcknowledgeInfo

)

Unit

Module Contents

LastAcknowledgeInfo(mapVersion: Int)

class LedgerTransaction :

LedgerTransaction(inputs: List<

Module Contents

outputs

List

commands

List

attachments

List

notary

signers

List

timestamp

type

)

outRef

(

index

Int

)

fun toTransactionForContract():

class LeftOuterJoinedMap<K : Any, A, B, C> :

fun verify(): Unit

LeftOuterJoinedMap(leftTable: ObservableMap<K, out A>, rightTable: ObservableMap<K, out B>, assemble: (K, A, ObservableValue<B?>) -> C)

SimpleObjectProperty

Module Contents

val leftTable: ObservableMap<K, out A>

val rightTable: ObservableMap<K, out B>

class LinearInterpolator :

LinearInterpolator(xs: DoubleArray, ys: DoubleArray)

Module Contents

LinearInterpolator

interface LinearState :

Module Contents

class ClauseVerifier<S :

Unit

Module Contents

ClauseVerifier()

inputs

List

outputs

List

commands

List

abstract fun isRelevant(ourKeys: Set<

groupingKey

Unit

)

Set

)

Boolean

abstract val linearId:

object LocalDateColumnType

Module Contents

fun nonNullValueToString(value: Any): String

fun reset(vararg names: String): Unit

object LogHelper

Module Contents

fun reset(vararg classes: KClass<*>): <ERROR CLASS>

fun setLevel(vararg loggerNames: String): Unit

fun setLevel(vararg classes: KClass<*>): <ERROR CLASS>

class MapValuesList<K, A, C> : ObservableList<C>

Module Contents

fun <K, A, C> create(sourceMap: ObservableMap<K, A>, assemble: (Entry<K, A>) -> C):

MapValuesList

val sourceMap: ObservableMap<K, A>

class MappedList<A, B> : TransformationList<B, A>

Module Contents

MappedList(list: ObservableList<A>, function: (A) -> B)

val function: (A) -> B

fun get(index: Int): B

protected fun sourceChanged(change: Change<out A>): Unit

abstract class MappedSchema

Module Contents

MappedSchema(schemaFamily:

version

Int

mappedTypes

Iterable

val mappedTypes: Iterable<

)

data class MarshalledObservation

Module Contents

MarshalledObservation(forHandle: Int, what: <ERROR CLASS><out <ERROR CLASS>>)

val forHandle: Int

val what: <ERROR CLASS><out <ERROR CLASS>>

interface Message

Module Contents

abstract val data: ByteArray

abstract val debugTimestamp:

abstract fun serialise(): ByteArray

abstract val topicSession:

abstract val uniqueMessageId:

interface MessageHandlerRegistration

interface MessageRecipientGroup :

interface MessageRecipients

interface MessagingService

Module Contents

abstract fun addMessageHandler(topic: String = "", sessionID: Long = DEFAULT_SESSION_ID, executor:

callback

(

)

Unit

)

abstract fun addMessageHandler(topicSession:

executor

callback

(

)

Unit

)

abstract fun createMessage(topicSession:

data

ByteArray

uuid

)

abstract val myAddress:

abstract fun removeMessageHandler(registration:

abstract fun send(message:

)

Unit

target

interface MessagingServiceBuilder<out T :

)

Unit

abstract fun start(): <ERROR CLASS><out T>

Module Contents

interface MessagingServiceInternal :

abstract fun stop(): Unit

Module Contents

class MissingAttachmentsException :

MissingAttachmentsException(ids: List<

Module Contents

)

Module Contents

fun <M : Any> get(klass: KClass<M>, origin: KClass<*>): M

inline fun <reified M : Any> get(origin: KClass<*>): M

fun <M : Any> initModel(klass: KClass<M>): <ERROR CLASS>

class MonitoringService :

MonitoringService(metrics: <ERROR CLASS>)

Module Contents

val metrics: <ERROR CLASS>

interface MoveCommand :

abstract val contractHash:

Module Contents

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class MoveGenerator

Module Contents

MoveGenerator()

data class MultilateralNetState :

MultilateralNetState(template:

Module Contents

)

val template:

interface MultilateralNettableState<out T : Any>

Module Contents

abstract val multilateralNetState: T

abstract class MutableClock :

val mutations: <ERROR CLASS><Long>

Module Contents

MutableClock()

val mutationCount: Long

protected fun notifyMutationObservers(): Unit

interface NamedByHash

Module Contents

open class NetClause<C :

Unit

Module Contents

NetClause()

out

inputs

List

outputs

List

commands

List

fun verifyNetCommand(inputs: List<

groupingKey

Unit

)

Set

interface NettableState<N :

outputs

List

command

netState

)

Unit

interface NetCommand :

Module Contents

Module Contents

abstract val template:

Module Contents

Any

MultilateralNettableState

sealed class NetworkCacheError :

class DeregistrationFailed :

Module Contents

NetworkCacheError

Module Contents

DeregistrationFailed()

interface NetworkMapCache

Module Contents

Module Contents

prevNodeInfo

type

)

enum class MapChangeType

Module Contents

Added

Modified

Removed

abstract fun addMapService(net:

networkMapAddress

abstract fun addNode(node:

Boolean

ifChangedSinceVer

Int

)

Unit

abstract val changed: <ERROR CLASS><

)

Unit

abstract fun deregisterForUpdates(net:

service

abstract fun get(): Collection<

)

Unit

abstract fun get(serviceType:

)

Collection

abstract fun getNodeByLegalName(name: String):

abstract fun getNodeByPublicKey(publicKey:

)

abstract fun getRecommended(type:

contract

vararg

party

)

abstract val mapServiceRegistered: <ERROR CLASS><Unit>

abstract val networkMapNodes: List<

abstract val notaryNodes: List<

abstract val partyNodes: List<

abstract val regulators: List<

abstract fun removeNode(node:

abstract fun runWithoutMapService(): Unit

)

Unit

interface NetworkMapService

Module Contents

val DEFAULT_EXPIRATION_PERIOD:

Period

val FETCH_PROTOCOL_TOPIC: String

class FetchMapRequest :

FetchMapRequest(: Boolean, ifChangedSinceVersion: Int?, replyTo:

Module Contents

val ifChangedSinceVersion: Int?

sessionID

Long

)

data class FetchMapResponse

Module Contents

FetchMapResponse(nodes: Collection<

version

Int

)

val nodes: Collection<

val PUSH_ACK_PROTOCOL_TOPIC: String

val PUSH_PROTOCOL_TOPIC: String

val QUERY_PROTOCOL_TOPIC: String

class QueryIdentityRequest :

QueryIdentityRequest(identity:

Module Contents

replyTo

sessionID

Long

)

data class QueryIdentityResponse

Module Contents

QueryIdentityResponse(node:

)

val REGISTER_PROTOCOL_TOPIC: String

class RegistrationRequest :

RegistrationRequest(wireReg:

Module Contents

replyTo

sessionID

Long

)

val wireReg:

data class RegistrationResponse

Module Contents

RegistrationResponse(success: Boolean)

val success: Boolean

val SUBSCRIPTION_PROTOCOL_TOPIC: String

class SubscribeRequest :

SubscribeRequest(: Boolean, replyTo:

Module Contents

sessionID

Long

)

data class SubscribeResponse

Module Contents

SubscribeResponse(confirmed: Boolean)

val confirmed: Boolean

data class Update

Module Contents

Update(wireReg:

data class UpdateAcknowledge

mapVersion

Int

replyTo

)

Module Contents

UpdateAcknowledge(mapVersion: Int, replyTo:

)

abstract val nodes: List<

class NoReferencesSerializer<T>

Module Contents

NoReferencesSerializer(baseSerializer: <ERROR CLASS><T>)

val baseSerializer: <ERROR CLASS><T>

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: T): Unit

)

open class NoZeroSizedOutputs<in S :

Any

Module Contents

inputs

List

outputs

List

commands

List

groupingKey

)

Set

class Node :

Module Contents

Node(configuration:

networkMapAddress

advertisedServices

Set

clock

)

val DEFAULT_PORT: Int

val configuration:

protected fun initialiseDatabasePersistence(insideTransaction: () -> Unit): Unit

protected fun makeMessagingService():

protected fun makeUniquenessProvider():

PersistentUniquenessProvider

var messageBroker:

protected val serverThread:

fun run(): Unit

ServiceAffinityExecutor

protected fun startMessagingService(cordaRPCOps:

)

Unit

lateinit var webServer: <ERROR CLASS>

class NodeAttachmentService :

NodeAttachmentService(storePath:

Module Contents

class OnDiskHashMismatch :

metrics

)

Module Contents

OnDiskHashMismatch(file:

actual

)

var automaticallyExtractAttachments: Boolean

var checkAttachmentsOnLoad: Boolean

fun importAttachment(jar:

)

fun openAttachment(id:

)

)

Module Contents

NodeClock(delegateClock:

)

interface NodeConfiguration :

)

)

Module Contents

abstract val basedir:

open val certificatesPath:

open val dataSourceProperties:

abstract val devMode: Boolean

abstract val emailAddress: String

abstract val exportJMXto: String

abstract val myLegalName: String

abstract val nearestCity: String

data class NodeInfo

Module Contents

NodeInfo(address:

legalIdentity

advertisedServices

List

ServiceEntry

physicalLocation

)

val address:

var advertisedServices: List<

val physicalLocation:

fun serviceIdentities(type:

)

List

object NodeInterestRates

Module Contents

class FixContainer

Module Contents

FixContainer(fixes: Set<

factory

)

operator fun get(fixOf:

)

class InterpolatingRateMap

Module Contents

InterpolatingRateMap(date:

inputRates

Map

calendar

factory

)

)

Module Contents

signingKey

clock

)

fun query(queries: List<

deadline

)

List

)

Module Contents

Module Contents

)

fun parseFile(s: String):

)

String

Module Contents

)

FixContainer

fun parseFix(s: String):

fun parseFixOf(key: String):

sealed class NodeMapError :

Module Contents

class InvalidSignature :

class InvalidSubscriber :

Module Contents

InvalidSignature()

class UnknownChangeType :

Module Contents

InvalidSubscriber()

class NodeMessagingClient :

Module Contents

UnknownChangeType()

NodeMessagingClient(config:

Module Contents

serverHostPort

myIdentity

executor

persistentInbox

Boolean

persistenceTx

(

)

Unit

)

Unit

)

data class Handler :

Module Contents

Handler(executor:

topicSession

callback

(

)

Unit

)

val callback: (

val SESSION_ID_PROPERTY: String

)

Unit

val TOPIC_PROPERTY: String

fun addMessageHandler(topic: String, sessionID: Long, executor:

callback

(

)

Unit

)

fun addMessageHandler(topicSession:

executor

callback

(

)

Unit

)

fun createMessage(topicSession:

data

ByteArray

uuid

)

fun makeNetworkMapAddress(hostAndPort: <ERROR CLASS>):

val myAddress:

val myIdentity:

val persistenceTx: (() -> Unit) -> Unit

val persistentInbox: Boolean

fun removeMessageHandler(registration:

val serverHostPort: <ERROR CLASS>

)

Unit

target

)

Unit

fun start(rpcOps:

)

Unit

val clientToService: <ERROR CLASS><

class NodeMonitorModel

Module Contents

NodeMonitorModel()

val progressTracking: <ERROR CLASS><

fun register(vaultMonitorNodeInfo:

certificatesPath

val stateMachineTransactionMapping: <ERROR CLASS><

)

Unit

val stateMachineUpdates: <ERROR CLASS><

val transactions: <ERROR CLASS><

val vaultUpdates: <ERROR CLASS><

class NodeRegistration

Module Contents

NodeRegistration(node:

serial

Long

type

expires

)

data class NodeRegistrationInfo

fun toWire(privateKey:

)

Module Contents

NodeRegistrationInfo(reg:

mapVersion

Int

)

val reg:

interface NodeSSLConfiguration

Module Contents

abstract val certificatesPath:

abstract val keyStorePassword: String

open val keyStorePath:

abstract val trustStorePassword: String

open val trustStorePath:

class NodeSchedulerService :

NodeSchedulerService(services:

Module Contents

protocolLogicRefFactory

schedulerTimerExecutor

fun scheduleStateActivity(action:

)

fun unscheduleStateActivity(ref:

)

Unit

class NodeSchemaService :

)

Unit

fun generateMappedObject(state:

Module Contents

NodeSchemaService()

schema

)

val schemaOptions: Map<

fun selectSchemas(state:

)

Iterable

class NodeVaultService :

NodeVaultService(services:

Module Contents

)

val currentVault:

val linearHeads: Map<

fun notifyAll(txns: Iterable<

)

fun track(): <ERROR CLASS><

class NonEmptySet<T> : MutableSet<T>

Module Contents

NonEmptySet(initial: T)

inner class Iterator<out T, T> : MutableIterator<T>

Module Contents

Iterator(iterator: MutableIterator<T>)

fun hasNext(): Boolean

val iterator: MutableIterator<T>

fun next(): T

fun remove(): Unit

fun add(element: T): Boolean

fun addAll(elements: Collection<T>): Boolean

fun clear(): Nothing

fun contains(element: T): Boolean

fun containsAll(elements: Collection<T>): Boolean

fun iterator(): MutableIterator<T>

fun isEmpty(): Boolean

fun remove(element: T): Boolean

fun removeAll(elements: Collection<T>): Boolean

fun retainAll(elements: Collection<T>): Boolean

object NonEmptySetSerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

Any

)

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj:

Any

Any

)

Unit

Module Contents

Module Contents

Module Contents

object NotaryChangeProtocol :

)

AbstractStateReplacementProtocol

Module Contents

Module Contents

progressTracker

)

protected fun verifyProposal(maybeProposal:

)

Module Contents

newNotary

progressTracker

protected fun assembleProposal(stateRef:

)

modification

stx

)

protected fun assembleTx(): <ERROR CLASS><

List

data class Proposal :

Module Contents

modification

stx

)

sealed class NotaryError

Module Contents

Module Contents

conflict

)

val tx:

class SignaturesMissing :

SignaturesMissing(missingSigners: Set<

Module Contents

)

val missingSigners: Set<

class TimestampInvalid :

class TransactionInvalid :

Module Contents

TimestampInvalid()

Module Contents

TransactionInvalid()

class NotaryException :

Module Contents

NotaryException(error:

)

lateinit var notaryParty:

object NotaryProtocol

Module Contents

Module Contents

progressTracker

)

open fun beforeCommit(stx:

Module Contents

Module Contents

)

Module Contents

)

Unit

Module Contents

timestampChecker

uniquenessProvider

)

reqIdentity

)

Unit

abstract class NotaryService :

Module Contents

callerIdentity

)

Module Contents

NotaryService(services:

abstract fun createProtocol(otherParty:

)

)

object NullPublicKey :

Comparable

Module Contents

)

Int

fun getEncoded(): ByteArray

object NullSignature :

Module Contents

Module Contents

Module Contents

Module Contents

)

List

Module Contents

out

Module Contents

Unit

inputs

List

outputs

List

commands

List

groupingKey

Unit

)

Set

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

class VerifyLifecycle<S :

Any

Module Contents

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

Module Contents

)

Module Contents

data class SetLifecycle :

Module Contents

)

Module Contents

)

val exitKeys: Collection<

Module Contents

SetLifecycle(lifecycle:

)

Module Contents

)

Module Contents

Module Contents

obligor

template

quantity

Long

beneficiary

)

val bilateralNetState:

newOwner

)

val multilateralNetState:

)

Terms(acceptableContracts:

)

data class Terms

Module Contents

acceptableIssuedProducts

dueBefore

timeTolerance

)

val acceptableContracts:

val acceptableIssuedProducts:

fun generateCloseOutNetting(tx:

signer

vararg

states

)

Unit

amountIssued

assetStates

List

)

obligor

issuanceDef

pennies

Long

beneficiary

notary

fun generatePaymentNetting(tx:

)

Unit

issued

notary

vararg

states

fun generateSetLifecycle(tx:

)

Unit

statesAndRefs

List

lifecycle

notary

)

Unit

fun generateSettle(tx:

statesAndRefs

Iterable

assetStatesAndRefs

Iterable

moveCommand

notary

)

Unit

abstract class OnLedgerAsset<T : Any, C :

)

Unit

Module Contents

abstract val conserveClause:

abstract fun deriveState(txState:

amount

owner

)

abstract fun extractCommands(commands: Collection<

)

Collection

amountIssued

assetStates

List

)

abstract fun generateExitCommand(amount:

)

abstract fun generateIssueCommand():

abstract fun generateMoveCommand():

amount

assetsStates

List

onlyFromParties

Set

)

List

OpaqueBytes(bits: ByteArray)

open class OpaqueBytes

Module Contents

val bits: ByteArray

fun of(vararg b: Byte):

class OptionalConfig<out T>

Module Contents

OptionalConfig(conf: <ERROR CLASS>, lambda: () -> T)

val conf: <ERROR CLASS>

operator fun getValue(receiver: Any, metadata: KProperty<*>): T

val lambda: () -> T

interface OwnableState :

Module Contents

abstract val owner:

abstract fun withNewOwner(newOwner:

)

Module Contents

object ParamsSpec

Module Contents

data class PartiallyResolvedTransaction

Module Contents

PartiallyResolvedTransaction(transaction:

inputs

List

ObservableValue

sealed class InputResolution

)

Module Contents

class Resolved :

fun fromSignedTransaction(transaction:

Module Contents

Resolved(stateAndRef:

)

Module Contents

)

transactions

ObservableMap

)

val inputs: List<ObservableValue<

Module Contents

Party(name: String, owningKey:

)

)

fun ref(vararg bytes: Byte):

data class PartyAndReference

Module Contents

PartyAndReference(party:

reference

)

class PartyAndReferenceGenerator

Module Contents

PartyAndReferenceGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

PartyColumns(name: <ERROR CLASS><String>, owningKey: <ERROR CLASS><

data class PartyColumns

Module Contents

val name: <ERROR CLASS><String>

)

val owningKey: <ERROR CLASS><

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class PartyGenerator

Module Contents

PartyGenerator()

abstract class PaymentEvent :

Module Contents

PaymentEvent(date:

abstract fun calculate():

)

class PerFileCheckpointStorage :

enum class PaymentRule

Module Contents

InAdvance

InArrears

PerFileCheckpointStorage(storeDir:

Module Contents

)

)

Unit

)

Boolean

)

Unit

)

Unit

val storeDir:

class PerFileTransactionStorage :

PerFileTransactionStorage(storeDir:

Module Contents

fun addTransaction(transaction:

)

)

Unit

fun getTransaction(id:

)

val transactions: Iterable<

open class PercentageRatioUnit :

PercentageRatioUnit(percentageAsString: String)

Module Contents

class PersistentKeyManagementService :

PersistentKeyManagementService(initialKeys: Set<

Module Contents

)

class PersistentNetworkMapService :

PersistentNetworkMapService(services:

Module Contents

)

protected val subscribers:

JDBCHashMap

open class PersistentState

Module Contents

PersistentState(stateRef:

)

var stateRef:

data class PersistentStateRef :

Serializable

Module Contents

PersistentStateRef(stateRef:

PersistentStateRef(txId: String?, index: Int?)

)

PersistentStateRef()

var index: Int?

var txId: String?

class PersistentUniquenessProvider :

PersistentUniquenessProvider()

Module Contents

txId

callerIdentity

data class PhysicalLocation

)

Unit

Module Contents

PhysicalLocation(coordinate:

description

String

)

val coordinate:

Polynomial(coefficients: DoubleArray)

val description: String

class Polynomial

Module Contents

fun getValue(x: Double): <ERROR CLASS>

sealed class PortAllocation

Module Contents

class Incremental :

Incremental(portCounter: Int)

Module Contents

Module Contents

fun nextHostAndPort(): <ERROR CLASS>

abstract fun nextPort(): Int

class PrivateKeyGenerator

Module Contents

PrivateKeyGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

ProgressTracker(vararg steps:

class ProgressTracker

Module Contents

)

Module Contents

Module Contents

newStep

)

Module Contents

ofStep

)

Module Contents

parent

)

Module Contents

inner class RelabelableStep :

RelabelableStep(currentLabel: String)

Module Contents

open val changes: <ERROR CLASS>

var currentLabel: String

open val changes: <ERROR CLASS><

class Step

Module Contents

Step(label: String)

open fun childProgressTracker():

object UNSTARTED :

Module Contents

val allSteps: List<<ERROR CLASS><Int,

var currentStep:

val currentStepRecursive:

fun getChildProgressTracker(step:

)

fun setChildProgressTracker(step:

childProgressTracker

data class ProgressTrackingEvent

)

Unit

Module Contents

ProgressTrackingEvent(stateMachineId:

fun createStreamFromStateMachineInfo(stateMachine:

message

String

)

)

val message: String

val stateMachineId:

data class ProtocolClassRef :

ProtocolClassRef(className: String)

Module Contents

interface ProtocolIORequest

Module Contents

abstract val session:

ProtocolSession

abstract val stackTraceInCaseOfProblems:

data class ProtocolInstanceRef

Module Contents

ProtocolInstanceRef(protocolInstance:

protocolClass

protocolStepId

String

)

val protocolClass:

val protocolInstance:

val protocolStepId: String

abstract class ProtocolLogic<out T>

Module Contents

ProtocolLogic()

abstract fun call(): T

)

lateinit var psm:

inline fun <reified T : Any> receive(otherParty:

)

inline fun <reified T : Any> sendAndReceive(otherParty:

receiveType

)

payload

Any

)

Unit

payload

Any

)

fun <R> subProtocol(subLogic:

payload

Any

receiveType

)

fun track(): <ERROR CLASS><String, <ERROR CLASS><String>>?

shareParentSessions

Boolean

)

data class ProtocolLogicRef

Module Contents

val appContext:

AppContext

class ProtocolLogicRefFactory :

ProtocolLogicRefFactory()

Module Contents

ProtocolLogicRefFactory(protocolWhitelist: Map<String, Set<String>>)

fun create(type:

out

vararg

args

Any

)

fun createKotlin(protocolLogicClassName: String, args: Map<String, Any?>, attachments: List<

)

fun createKotlin(type:

out

args

Map

String

Any

)

fun toProtocolLogic(ref:

)

data class ProtocolRequiringAttention

interface ProtocolRef

Module Contents

ProtocolRequiringAttention(ref:

prompt

String

choiceIdsToMessages

Map

String

dueBy

val choiceIdsToMessages: Map<

)

String

class ProtocolSessionException :

ProtocolSessionException(message: String)

Module Contents

interface ProtocolStateMachine<R>

Module Contents

abstract val logger: <ERROR CLASS>

abstract fun <T : Any> receive(otherParty:

receiveType

sessionProtocol

)

abstract val resultFuture: <ERROR CLASS><R>

abstract fun send(otherParty:

payload

Any

sessionProtocol

abstract fun <T : Any> sendAndReceive(otherParty:

)

Unit

payload

Any

receiveType

sessionProtocol

)

abstract val serviceHub:

class ProtocolStateMachineImpl<R> :

ProtocolStateMachineImpl(id:

Module Contents

logic

fun currentStateMachine():

scheduler

FiberScheduler

)

val logic:

val resultFuture: <ERROR CLASS><R>

receiveType

sessionProtocol

)

fun run(): R

fun send(otherParty:

payload

Any

sessionProtocol

)

Unit

payload

Any

receiveType

sessionProtocol

)

lateinit var serviceHub:

data class ProtocolStatus

Module Contents

ProtocolStatus(status: String)

val status: String

object PublicKeyColumnType

Module Contents

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class PublicKeyGenerator

Module Contents

PublicKeyGenerator()

sealed class PublicKeyTree

Module Contents

class Builder

Module Contents

Builder()

fun addKey(publicKey:

weight

Int

)

fun addKeys(vararg publicKeys:

)

fun addLeaves(publicKeys: List<

)

fun addLeaves(vararg publicKeys:

)

fun build(threshold: Int? = null):

Module Contents

)

Node(threshold: Int, children: List<

)

Module Contents

weights

List

Int

)

val children: List<

fun containsAny(keys: Iterable<

)

Boolean

val threshold: Int

val weights: List<Int>

abstract fun getKeys(): Set<

)

abstract fun isFulfilledBy(keys: Iterable<

)

Boolean

fun isFulfilledBy(key:

fun parseFromBase58(encoded: String): <ERROR CLASS>

)

fun toBase58String(): String

interface QueryableState :

abstract fun generateMappedObject(schema:

Module Contents

)

abstract fun supportedSchemas(): Iterable<

abstract class RPCDispatcher

Module Contents

RPCDispatcher(target: Any)

fun dispatch(msg:

ClientRPCRequestMessage

)

Unit

abstract fun send(bits:

fun start(rpcConsumer: <ERROR CLASS>, rpcNotificationConsumer: <ERROR CLASS>?, onExecutor:

toAddress

String

)

Unit

open class RPCException :

)

Unit

val target: Any

RuntimeException

Module Contents

RPCException(msg: String)

RPCException(msg: String, cause: Throwable?)

class DeadlineExceeded :

RPCException

Module Contents

DeadlineExceeded(rpcName: String)

interface RPCOps

Module Contents

abstract val protocolVersion: Int

@Target([AnnotationTarget.FUNCTION]) annotation class RPCReturnsObservables

Module Contents

RPCReturnsObservables()

@Target([AnnotationTarget.FUNCTION]) annotation class RPCSinceVersion

Module Contents

RPCSinceVersion(version: Int)

Module Contents

)

val ratioUnit:

abstract class RatePaymentEvent :

PaymentEvent

Module Contents

RatePaymentEvent(date:

accrualStartDate

accrualEndDate

dayCountBasisDay

dayCountBasisYear

notional

rate

)

val accrualEndDate:

val accrualStartDate:

open fun asCSV(): String

open fun calculate():

abstract val flow:

open class RatesFixProtocol :

Unit

Module Contents

oracle

fixOf

expectedRate

rateTolerance

progressTracker

)

class FixOutOfRange :

Module Contents

FixOutOfRange(byAmount:

)

val byAmount:

class FixQueryProtocol :

Module Contents

FixQueryProtocol(fixOf:

oracle

)

class FixSignProtocol :

Module Contents

oracle

)

Module Contents

QUERYING(name: String)

QueryRequest(queries: List<

data class QueryRequest

Module Contents

deadline

)

protected open fun beforeSigning(fix:

Module Contents

)

)

Unit

fun tracker(fixName: String):

Module Contents

)

open class ReadOnlyBackedObservableMapBase<K, A, B> : ObservableMap<K, A>

Module Contents

ReadOnlyBackedObservableMapBase()

open fun addListener(listener: InvalidationListener): Unit

open fun addListener(listener: MapChangeListener<in K, in A>?): Unit

protected val backingMap:

open fun containsValue(value: A): <ERROR CLASS>

open val entries: MutableSet<MutableEntry<K, A>>

protected fun fireChange(change: Change<out K, out A>): Unit

open fun get(key: K): <ERROR CLASS>

open fun put(key: K, value: A): A

open fun putAll(from: Map<out K, A>): Unit

open fun remove(key: K): A

open fun removeListener(listener: InvalidationListener?): Unit

open fun removeListener(listener: MapChangeListener<in K, in A>?): Unit

open val values: MutableCollection<A>

interface ReadOnlyTransactionStorage

Module Contents

abstract fun getTransaction(id:

)

data class ReceiveOnly<T :

Module Contents

receiveType

)

interface ReceiveRequest<T :

abstract val receiveType:

Module Contents

ReferenceRate(oracle: String, tenor:

class ReferenceRate :

FloatingRate

Module Contents

name

String

)

object ReferencesAwareJavaSerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: Any): Unit

Any

)

Any

interface RegulatorService

Module Contents

class ReplayedList<A> : TransformationList<A, A>

Module Contents

ReplayedList(sourceList: ObservableList<A>)

val replayedList:

protected fun sourceChanged(c: Change<out A>): Unit

class Requirements

Module Contents

Requirements()

infix fun String.by(expr: Boolean): Unit

class ResolveTransactionsProtocol :

List

ResolveTransactionsProtocol(stx:

Module Contents

otherSide

ResolveTransactionsProtocol(wtx:

)

otherSide

ResolveTransactionsProtocol(txHashes: Set<

)

otherSide

class ExcessivelyLargeTransactionGraph :

)

ExcessivelyLargeTransactionGraph()

Module Contents

fun call(): List<

var transactionCountLimit: Int

class ResponseFilter

Module Contents

ResponseFilter()

fun filter(requestContext: <ERROR CLASS>, responseContext: <ERROR CLASS>): Unit

abstract class RetryableException :

RetryableException(message: String)

Module Contents

enum class Role

Module Contents

RECIPIENT

SENDER

val legalName: String

Module Contents

interface SchedulableState :

abstract fun nextScheduledActivity(thisStateRef:

Module Contents

protocolLogicRefFactory

)

abstract val scheduledAt:

interface Scheduled

Module Contents

data class ScheduledActivity :

ScheduledActivity(logicRef:

Module Contents

scheduledAt

)

class ScheduledActivityObserver

Module Contents

ScheduledActivityObserver(services:

)

data class ScheduledStateRef :

interface SchedulerService

Module Contents

ScheduledStateRef(ref:

scheduledAt

)

Module Contents

abstract fun scheduleStateActivity(action:

abstract fun unscheduleStateActivity(ref:

)

Unit

SchemaOptions(databaseSchema: String?, tablePrefix: String?)

)

Unit

interface SchemaService

Module Contents

data class SchemaOptions

Module Contents

val databaseSchema: String?

val tablePrefix: String?

abstract fun generateMappedObject(state:

schema

)

abstract val schemaOptions: Map<

abstract fun selectSchemas(state:

)

Iterable

sealed class SecureHash :

Module Contents

class SHA256 :

fun parse(str: String): <ERROR CLASS>

Module Contents

SHA256(bits: ByteArray)

fun prefixChars(prefixLen: Int = 6): <ERROR CLASS>

fun randomSHA256():

fun sha256(bits: ByteArray):

fun sha256(str: String): <ERROR CLASS>

fun sha256Twice(bits: ByteArray):

object SecureHashColumnType

Module Contents

class SecureHashGenerator

Module Contents

SecureHashGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

data class SendAndReceive<T :

SendRequest

ReceiveRequest

Module Contents

SendAndReceive(session:

message

receiveType

)

data class SendOnly :

Module Contents

message

)

interface SendRequest :

Module Contents

abstract val message:

interface SerializationToken

Module Contents

abstract fun fromToken(context:

interface SerializeAsToken

)

Any

Module Contents

abstract fun toToken(context:

)

class SerializeAsTokenContext

Module Contents

SerializeAsTokenContext(toBeTokenized: Any, kryo: <ERROR CLASS> = createKryo())

class SerializeAsTokenSerializer<T :

SerializeAsTokenSerializer()

Module Contents

fun clearContext(kryo: <ERROR CLASS>): Unit

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

fun setContext(kryo: <ERROR CLASS>, context:

)

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: T): Unit

)

Unit

class SerializedBytes<T : Any> :

SerializedBytes(bits: ByteArray)

Module Contents

fun writeToFile(path:

)

object SerializedBytesSerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

Any

)

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj:

Any

Any

)

Unit

class ServerRPCOps :

Module Contents

ServerRPCOps(services:

smm

class InputStateRefResolveFailed :

database

)

InputStateRefResolveFailed(stateRefs: List<

Module Contents

)

fun executeCommand(command:

)

fun stateMachineRecordedTransactionMapping(): <ERROR CLASS><List<

val protocolVersion: Int

fun stateMachinesAndUpdates(): <ERROR CLASS><List<

fun vaultAndUpdates(): <ERROR CLASS><List<

fun verifiedTransactions(): <ERROR CLASS><List<

abstract val identityService:

data class ServiceEntry

Module Contents

identity

)

Module Contents

abstract fun <T : Any> invokeProtocolAsync(logicType:

out

abstract val keyManagementService:

vararg

args

Any

)

open val legalIdentityKey:

open fun loadState(stateRef:

)

open val notaryIdentityKey:

abstract fun recordTransactions(txs: Iterable<

abstract val schedulerService:

)

Unit

abstract val storageService:

abstract val vaultService:

abstract class ServiceHubInternal :

abstract fun getProtocolFactory(markerClass:

Module Contents

ServiceHubInternal()

)

(

)

open fun <T : Any> invokeProtocolAsync(logicType:

out

abstract val monitoringService:

vararg

args

Any

)

MonitoringService

abstract val protocolLogicRefFactory:

abstract fun registerProtocolInitiator(markerClass: KClass<*>, protocolFactory: (

)

abstract val schemaService:

)

Unit

abstract fun <T> startProtocol(logic:

)

data class ServiceInfo

Module Contents

ServiceInfo(type:

fun parse(encoded: String):

name

String

)

val name: String?

interface ServiceRequestMessage

Module Contents

abstract val replyTo:

abstract val sessionID: Long

sealed class ServiceType

Module Contents

val corda:

open operator fun equals(other: Any?): Boolean

fun getServiceType(namespace: String, typeId: String):

fun getSubType(subTypeId: String):

fun isSubTypeOf(superType:

val id: String

fun isNotary(): Boolean

)

Boolean

fun parse(id: String):

val regulator:

open class SignedData<T : Any>

Module Contents

sig

)

protected open fun verifyData(data: T): Unit

data class SignedTransaction :

SignedTransaction(txBits:

Module Contents

sigs

List

class SignaturesMissingException :

)

SignaturesMissingException(missing: Set<

SignatureException

Module Contents

descriptions

List

String

val descriptions: List<String>

)

fun checkSignaturesAreValid(): Unit

operator fun plus(sig:

)

operator fun plus(sigList: Collection<

)

fun verifySignatures(vararg allowedToBeMissing:

)

)

fun withAdditionalSignature(sig:

)

fun withAdditionalSignatures(sigList: Iterable<

)

class SignedTransactionGenerator

Module Contents

SignedTransactionGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class SimpleNotaryService :

SimpleNotaryService(services:

Module Contents

timestampChecker

uniquenessProvider

)

)

abstract class Simulation

Module Contents

Simulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, latencyInjector: <ERROR CLASS>?)

inner class BankFactory

Module Contents

network

networkMapAddr

advertisedServices

Set

Int

keyPair

)

fun createAll(): List<

object NetworkMapNodeFactory

Module Contents

network

networkMapAddr

advertisedServices

Set

Int

keyPair

)

object NotaryNodeFactory

Module Contents

network

networkMapAddr

advertisedServices

Set

Int

keyPair

object RatesOracleFactory

)

Module Contents

network

networkMapAddr

advertisedServices

Set

Int

keyPair

)

object RegulatorFactory

Module Contents

network

networkMapAddr

advertisedServices

Set

Int

keyPair

)

open class SimulatedNode

Module Contents

SimulatedNode(config:

mockNet

networkMapAddress

advertisedServices

Set

Int

keyPair

)

val allProtocolSteps: <ERROR CLASS><<ERROR CLASS><

val bankLocations: <ERROR CLASS>

val banks: List<

val clocks: <ERROR CLASS>

var currentDateAndTime:

val dateChanges: <ERROR CLASS><

val doneSteps: <ERROR CLASS><Collection<

val extraNodeLabels: MutableMap<

open fun iterate(): <ERROR CLASS>?

String

val network: <ERROR CLASS>

val networkInitialisationFinished: <ERROR CLASS><out <ERROR CLASS>>

val networkMap:

val networkSendManuallyPumped: Boolean

val regulators: List<

val serviceProviders: List<

protected fun showConsensusFor(nodes: List<

protected fun showProgressFor(nodes: List<

)

Unit

fun start(): <ERROR CLASS><Unit>

)

Unit

protected open fun startMainSimulation(): <ERROR CLASS><Unit>

fun startTradingCircle(tradeBetween: (Int, Int) -> <ERROR CLASS><out <ERROR CLASS>>): Unit

interface SingleMessageRecipient :

data class SingletonSerializationToken :

SingletonSerializationToken(toBeTokenized:

Module Contents

)

fun fromToken(context:

fun registerWithContext(token:

)

Any

SingletonSerializationToken

toBeTokenized

context

)

abstract class SingletonSerializeAsToken :

SingletonSerializeAsToken()

Module Contents

open fun toToken(context:

)

SplineFunction(segmentMap:

class SplineFunction

Module Contents

TreeMap

Double

Polynomial

)

fun getValue(x: Double): Double

class StackSnapshot : Throwable

Module Contents

StackSnapshot()

data class StateAndRef<out T :

Module Contents

ref

)

data class StateMachineData

Module Contents

StateMachineData(id:

protocolStatus

ObservableValue

stateMachineStatus

ObservableValue

)

val protocolStatus: ObservableValue<

val stateMachineStatus: ObservableValue<

data class StateMachineInfo

Module Contents

StateMachineInfo(id:

fun fromProtocolStateMachineImpl(psm:

protocolLogicClassName

String

progressTrackerStepAndUpdates

String

String

)

)

val progressTrackerStepAndUpdates: <ERROR CLASS><String, <ERROR CLASS><String>>?

class StateMachineManager

Module Contents

StateMachineManager(serviceHub:

tokenizableServices

List

Any

checkpointStorage

executor

interface ExistingSessionMessage :

database

)

Module Contents

addOrRemove

)

abstract val recipientSessionId: Long

Module Contents

inner class FiberScheduler

Module Contents

FiberScheduler()

data class ProtocolSession

Module Contents

ProtocolSession(protocol:

otherParty

ourSessionId

Long

otherPartySessionId

Long

waitingForResponse

Boolean

)

val otherParty:

var otherPartySessionId: Long?

val ourSessionId: Long

val protocol:

val psm:

val receivedMessages:

ConcurrentLinkedQueue

var waitingForResponse: Boolean

data class SessionConfirm :

SessionConfirm(initiatorSessionId: Long, initiatedSessionId: Long)

Module Contents

val initiatedSessionId: Long

data class SessionData :

SessionData(recipientSessionId: Long, payload: Any)

Module Contents

val payload: Any

data class SessionEnd :

SessionEnd(recipientSessionId: Long)

Module Contents

data class SessionInit :

SessionInit(initiatorSessionId: Long, initiatorParty:

Module Contents

protocolName

String

)

val initiatorParty:

interface SessionInitResponse :

val protocolName: String

data class SessionReject :

interface SessionMessage

SessionReject(initiatorSessionId: Long, errorMessage: String)

Module Contents

val errorMessage: String

fun <T> add(logic:

)

val allStateMachines: List<

val checkpointStorage:

findStateMachines

(

protocolClass

)

List

interface StateMachineRecordedTransactionMappingStorage

Module Contents

abstract fun addMapping(stateMachineRunId:

transactionId

)

Unit

data class StateMachineRunId

Module Contents

fun createRandom():

val uuid:

sealed class StateMachineStatus

Module Contents

Added(stateMachineName: String)

Module Contents

class Removed :

Removed(stateMachineName: String)

Module Contents

val stateMachineName: String

data class StateMachineTransactionMapping

Module Contents

StateMachineTransactionMapping(stateMachineRunId:

transactionId

)

val stateMachineRunId:

val transactionId:

sealed class StateMachineUpdate

Module Contents

Module Contents

Added(stateMachineInfo:

fun fromStateMachineChange(change:

)

val stateMachineInfo:

Module Contents

)

)

Module Contents

index

Int

)

val index: Int

val txhash:

data class StateRefColumns

Module Contents

StateRefColumns(txId: <ERROR CLASS><

val index: <ERROR CLASS><Int>

index

Int

)

val txId: <ERROR CLASS><

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class StateRefGenerator

Module Contents

StateRefGenerator()

class StateReplacementException :

StateReplacementException(error:

Module Contents

)

class StateReplacementRefused

Module Contents

StateReplacementRefused(identity:

state

detail

String

)

abstract val attachments:

interface StatesQuery

Module Contents

Module Contents

Module Contents

data class Selection :

Module Contents

)

)

interface StorageService

Module Contents

abstract val stateMachineRecordedTransactionMapping:

open class StorageServiceImpl :

StorageServiceImpl(attachments:

Module Contents

validatedTransactions

stateMachineRecordedTransactionMapping

)

open val attachments:

open val stateMachineRecordedTransactionMapping:

open val validatedTransactions:

class StrandLocalTransactionManager

Module Contents

StrandLocalTransactionManager(initWithDatabase: <ERROR CLASS>)

fun currentOrNull(): <ERROR CLASS>?

var database: <ERROR CLASS>

fun newTransaction(isolation: Int): <ERROR CLASS>

fun restoreThreadLocalTx(context: <ERROR CLASS><<ERROR CLASS>?, <ERROR CLASS>?>): Unit

fun setThreadLocalTx(tx: <ERROR CLASS>?): <ERROR CLASS><<ERROR CLASS>?, <ERROR CLASS>?>

Module Contents

Module Contents

fun daysToMaturity(startDate:

calendar

)

Int

ThreadBox(content: T, lock:

class ThreadBox<out T>

Module Contents

inline fun <R> alreadyLocked(body: T.() -> R): R

)

fun checkNotLocked(): <ERROR CLASS>

val content: T

val lock:

inline fun <R> locked(body: T.() -> R): R

data class TimeWindow

Module Contents

duration

)

Module Contents

tolerance

)

before

)

class TimestampChecker

Module Contents

TimestampChecker(clock:

tolerance

)

fun isValid(timestampCommand:

)

Boolean

val tolerance:

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class TimestampGenerator

Module Contents

TimestampGenerator()

TopicSession(topic: String, sessionID: Long = DEFAULT_SESSION_ID)

data class TopicSession

Module Contents

val Blank:

fun isBlank(): Boolean

object TopicStringValidator

val topic: String

Module Contents

fun check(tag: String): <ERROR CLASS>

sealed class TrackedDelegate<M : Any>

Module Contents

class EventSinkDelegate<M : Any, T> :

EventSinkDelegate(klass: KClass<M>, eventSinkProperty: (M) -> <ERROR CLASS><T>)

Module Contents

val eventSinkProperty: (M) -> <ERROR CLASS><T>

operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>

class EventStreamDelegate<M : Any, T> :

EventStreamDelegate(klass: KClass<M>, eventStreamProperty: (M) -> <ERROR CLASS><T>)

Module Contents

val eventStreamProperty: (M) -> <ERROR CLASS><T>

operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>

class ObjectPropertyDelegate<M : Any, T> :

ObjectPropertyDelegate(klass: KClass<M>, objectPropertyProperty: (M) -> ObjectProperty<T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): ObjectProperty<T>

val objectPropertyProperty: (M) -> ObjectProperty<T>

class ObservableDelegate<M : Any, T> :

ObservableDelegate(klass: KClass<M>, observableProperty: (M) -> <ERROR CLASS><T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>

val observableProperty: (M) -> <ERROR CLASS><T>

class ObservableListDelegate<M : Any, T> :

ObservableListDelegate(klass: KClass<M>, observableListProperty: (M) -> ObservableList<T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): ObservableList<T>

val observableListProperty: (M) -> ObservableList<T>

class ObservableListReadOnlyDelegate<M : Any, out T> :

ObservableListReadOnlyDelegate(klass: KClass<M>, observableListReadOnlyProperty: (M) -> ObservableList<out T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): ObservableList<out T>

val observableListReadOnlyProperty: (M) -> ObservableList<out T>

class ObservableValueDelegate<M : Any, T> :

ObservableValueDelegate(klass: KClass<M>, observableValueProperty: (M) -> ObservableValue<T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): ObservableValue<T>

val observableValueProperty: (M) -> ObservableValue<T>

class ObserverDelegate<M : Any, T> :

ObserverDelegate(klass: KClass<M>, observerProperty: (M) -> <ERROR CLASS><T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>

val observerProperty: (M) -> <ERROR CLASS><T>

class SubjectDelegate<M : Any, T> :

SubjectDelegate(klass: KClass<M>, subjectProperty: (M) -> <ERROR CLASS><T, T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T, T>

val subjectProperty: (M) -> <ERROR CLASS><T, T>

class WritableValueDelegate<M : Any, T> :

WritableValueDelegate(klass: KClass<M>, writableValueProperty: (M) -> WritableValue<T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): WritableValue<T>

val writableValueProperty: (M) -> WritableValue<T>

val klass: KClass<M>

class TradeSimulation :

TradeSimulation(runAsync: Boolean, latencyInjector: <ERROR CLASS>?)

Module Contents

protected fun startMainSimulation(): <ERROR CLASS><Unit>

sealed class TransactionBuildResult

Module Contents

Module Contents

class ProtocolStarted :

Module Contents

ProtocolStarted(id:

transaction

message

String

)

data class TransactionBuildStep

Module Contents

TransactionBuildStep(generateMethodName: String, args: Map<String, Any?>)

val generateMethodName: String

open class TransactionBuilder

Module Contents

TransactionBuilder(type:

notary

inputs

MutableList

attachments

MutableList

outputs

MutableList

commands

MutableList

signers

MutableSet

timestamp

fun addAttachment(attachmentId:

)

)

Unit

fun addCommand(arg:

)

Unit

vararg

keys

)

keys

List

open fun addInputState(stateAndRef:

)

Unit

)

Unit

)

Int

notary

)

Int

fun addSignatureUnchecked(sig:

)

Int

)

fun attachments(): List<

protected val attachments: MutableList<

fun checkAndAddSignature(sig:

)

Unit

fun checkSignature(sig:

)

Unit

fun commands(): List<

protected val commands: MutableList<

fun copy():

protected val currentSigs: <ERROR CLASS>

fun inputStates(): List<

protected val inputs: MutableList<

var notary:

fun outputStates(): List<

protected val outputs: MutableList<

timeTolerance

)

Unit

fun setTime(newTimestamp:

)

Unit

fun signWith(key:

)

protected val signers: MutableSet<

val time:

protected var timestamp:

fun toSignedTransaction(checkSufficientSignatures: Boolean = true):

fun toWireTransaction():

protected val type:

fun withItems(vararg items: Any):

class TransactionConflictException :

TransactionConflictException(conflictRef:

Module Contents

tx1

tx2

)

sealed class TransactionCreateStatus

Module Contents

Module Contents

class Started :

Started(message: String?)

Module Contents

data class TransactionForContract

Module Contents

TransactionForContract(inputs: List<

outputs

List

attachments

List

data class InOutGroup<out T :

commands

List

origHash

inputNotary

timestamp

)

InOutGroup(inputs: List<T>, outputs: List<T>, groupingKey: K)

out

Any

Module Contents

val groupingKey: K

val inputs: List<T>

val outputs: List<T>

Any

groupStates

(

ofType

selector

(

)

List

Any

groupStates

(

selector

(

)

List

class TransactionGraphSearch :

Any

~~groupStatesInternal~~

(

inGroups

Map

List

outGroups

Map

List

)

List

Callable

List

TransactionGraphSearch(transactions:

Module Contents

startPoints

List

)

class Query

Module Contents

Query(withCommandOfType:

out

followInputsOfType

out

)

val followInputsOfType:

out

val withCommandOfType:

out

val startPoints: List<

val transactions:

class TransactionResolutionException :

TransactionResolutionException(hash:

Module Contents

)

data class TransactionState<out T :

TransactionState(data: T, notary:

Module Contents

)

fun withNotary(newNotary:

)

class TransactionStateGenerator<T :

TransactionStateGenerator(stateGenerator: <ERROR CLASS><T>)

Module Contents

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

val stateGenerator: <ERROR CLASS><T>

interface TransactionStorage :

abstract fun addTransaction(transaction:

Module Contents

sealed class TransactionType

)

Unit

Module Contents

Module Contents

Module Contents

)

)

fun addInputState(stateAndRef:

)

Unit

Module Contents

Module Contents

)

)

Unit

)

)

Unit

abstract fun getRequiredSigners(tx:

)

Set

)

Unit

fun verifySigners(tx:

)

Set

abstract fun verifyTransaction(tx:

sealed class TransactionVerificationException :

)

Unit

class ContractRejection :

Module Contents

Module Contents

ContractRejection(tx:

contract

class InvalidNotaryChange :

cause

Throwable

)

Module Contents

Module Contents

InvalidNotaryChange(tx:

class MoreThanOneNotary :

)

Module Contents

MoreThanOneNotary(tx:

class NotaryChangeInWrongTransactionType :

)

NotaryChangeInWrongTransactionType(tx:

Module Contents

outputNotary

)

class SignersMissing :

Module Contents

SignersMissing(tx:

missing

List

)

val missing: List<

class TransactionMissingEncumbranceException :

TransactionMissingEncumbranceException(tx:

Module Contents

class TransientProperty<out T>

missing

Int

inOut

)

Module Contents

TransientProperty(initializer: () -> T)

operator fun getValue(thisRef: Any?, property: KProperty<*>): T

object TwoPartyDealProtocol

Module Contents

Module Contents

progressTracker

)

protected open fun assembleSharedTX(handshake:

)

List

protected open fun validateHandshake(handshake:

)

Module Contents

dealBeingOffered

)

val dealBeingOffered:

class DealMismatchException :

DealMismatchException(expectedDeal:

Module Contents

actualDeal

)

class DealRefMismatchException :

DealRefMismatchException(expectedDeal:

Module Contents

actualDeal

)

protected fun assembleSharedTX(handshake:

Module Contents

progressTracker

)

)

List

protected fun validateHandshake(handshake:

)

class FixingRoleDecider :

data class Handshake<out T>

Unit

Module Contents

FixingRoleDecider(ref:

progressTracker

)

Module Contents

data class FixingSession

Module Contents

oracleType

)

Module Contents

payload

progressTracker

)

Module Contents

Handshake(payload: T, publicKey:

)

Module Contents

Instigator(otherParty:

payload

myKeyPair

progressTracker

)

interface MarkerForBogusRegulatorProtocol

abstract class Primary :

Module Contents

Primary(progressTracker:

)

object COPYING_TO_REGULATOR :

)

fun getPartialTransaction():

abstract val myKeyPair:

abstract val notaryNode:

abstract val payload: Any

fun verifyPartialTransaction(untrustedPartialTX:

)

)

abstract class Secondary :

Secondary(progressTracker:

Module Contents

)

object VERIFYING :

protected abstract fun assembleSharedTX(handshake:

)

List

protected abstract fun validateHandshake(handshake:

)

class SignaturesFromPrimary

Module Contents

SignaturesFromPrimary(sellerSig:

notarySig

)

object TwoPartyTradeProtocol

Module Contents

class AssetMismatchException :

AssetMismatchException(expectedTypeName: String, typeName: String)

Module Contents

val expectedTypeName: String

Module Contents

notary

acceptablePrice

typeToBuy

out

)

out

Module Contents

notaryNode

assetToSell

price

myKeyPair

progressTracker

)

object NOTARY :

data class SellerTradeInfo

)

Module Contents

SellerTradeInfo(assetForSale:

price

sellerOwnerKey

)

data class SignaturesFromSeller

Module Contents

SignaturesFromSeller(sellerSig:

notarySig

)

class UnacceptablePriceException :

UnacceptablePriceException(givenPrice:

Module Contents

)

interface TxWritableStorageService :

Module Contents

abstract class TypeOnlyCommandData :

Module Contents

TypeOnlyCommandData()

object UUIDStringColumnType

Module Contents

data class UniqueIdentifier : Comparable<

UniqueIdentifier(externalId: String? = null, id:

Module Contents

)

fun fromString(name: String):

)

Int

val externalId: String?

class UniquenessException :

UniquenessException(error:

Module Contents

)

interface UniquenessProvider

Module Contents

data class Conflict

Module Contents

Conflict(stateHistory: Map<

)

val stateHistory: Map<

data class ConsumingTx

Module Contents

ConsumingTx(id:

abstract fun commit(states: List<

inputIndex

Int

requestingParty

)

txId

callerIdentity

)

Unit

open class UnknownType

Module Contents

UnknownType()

class UntrustworthyData<out T>

Module Contents

UntrustworthyData(fromUntrustedWorld: T)

val data: T

inline fun <R> unwrap(validator: (T) -> R): R

inline fun <R> ~~validate~~(validator: (T) -> R): R

object UpdateBusinessDayProtocol

Module Contents

Unit

Module Contents

progressTracker

)

Module Contents

data class UpdateBusinessDayMessage

Module Contents

)

Module Contents

UpdateBusinessDayMessage(date:

)

val date:

class ValidatingNotaryProtocol :

ValidatingNotaryProtocol(otherSide:

Module Contents

timestampChecker

uniquenessProvider

)

fun beforeCommit(stx:

reqIdentity

class ValidatingNotaryService :

)

Unit

ValidatingNotaryService(services:

Module Contents

timestampChecker

uniquenessProvider

)

)

ValidatingNotaryProtocol

class Vault

Module Contents

Vault(states: Iterable<

)

Module Contents

Update(consumed: Set<

produced

Set

)

operator fun plus(rhs:

)

val states: Iterable<

statesOfType

(

)

List

abstract val currentVault:

interface VaultService

Module Contents

abstract val linearHeads: Map<

linearHeadsOfType_

(

stateType

abstract fun notifyAll(txns: Iterable<

)

Map

)

)

open fun statesForRefs(refs: List<

)

Map

abstract fun track(): <ERROR CLASS><

open fun whenConsumed(ref:

)

class WhitelistTrustManager :

WhitelistTrustManager(originalProvider:

Module Contents

)

authType

String

socket

)

Unit

authType

String

engine

)

Unit

authType

String

)

Unit

authType

String

socket

)

Unit

authType

String

engine

)

Unit

val checker: HostnameChecker

authType

String

)

Unit

fun getAcceptedIssuers(): Array<out

object WhitelistTrustManagerProvider :

Provider

Module Contents

fun addWhitelistEntries(serverNames: List<String>): Unit

fun addWhitelistEntry(serverName: String): Unit

val originalTrustProviderAlgorithm: String

fun register(): Unit

val whitelist: Set<String>

class WhitelistTrustManagerSpi :

TrustManagerFactorySpi

Module Contents

WhitelistTrustManagerSpi()

protected fun engineGetTrustManagers(): Array<out

TrustManager

protected fun engineInit(keyStore:

protected fun engineInit(managerFactoryParameters:

)

Unit

ManagerFactoryParameters

)

Unit

class WireNodeRegistration :

TrustManagerFactory

SignedData

WireNodeRegistration(raw:

Module Contents

sig

protected fun verifyData(data:

)

)

Unit

class WireTransaction :

WireTransaction(inputs: List<

Module Contents

attachments

List

outputs

List

commands

List

notary

signers

List

type

timestamp

)

val commands: List<

fun deserialize(bits:

kryo

)

outRef

(

index

Int

)

outRef

(

state

)

)

object WireTransactionSerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

)

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj:

class WiredTransactionGenerator

)

Unit

Module Contents

WiredTransactionGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

data class WorldCoordinate

Module Contents

WorldCoordinate(latitude: Double, longitude: Double)

val latitude: Double

val longitude: Double

fun project(screenWidth: Double, screenHeight: Double, topLatitude: Double, bottomLatitude: Double, leftLongitude: Double, rightLongitude: Double): <ERROR CLASS><Double, Double>

object X509Utilities

Module Contents

data class CACertAndKey

Module Contents

CACertAndKey(certificate:

keyPair

)

val CORDA_CLIENT_CA: String

val CORDA_CLIENT_CA_PRIVATE_KEY: String

val CORDA_INTERMEDIATE_CA: String

val CORDA_INTERMEDIATE_CA_PRIVATE_KEY: String

val CORDA_ROOT_CA: String

val CORDA_ROOT_CA_PRIVATE_KEY: String

val ECDSA_CURVE: String

val KEYSTORE_TYPE: String

val KEY_GENERATION_ALGORITHM: String

val SIGNATURE_ALGORITHM: String

addOrReplaceCertificate

(

alias

String

cert

)

Unit

addOrReplaceKey

(

alias

String

key

Key

password

CharArray

chain

Array

fun createCAKeyStoreAndTrustStore(keyStoreFilePath:

)

Unit

storePassword

String

keyPassword

String

trustStoreFilePath

trustStorePassword

String

)

fun createCertificateSigningRequest(myLegalName: String, nearestCity: String, email: String, keyPair:

fun createIntermediateCert(domain: String, certificateAuthority:

)

)

fun createKeystoreForSSL(keyStoreFilePath:

storePassword

String

keyPassword

String

caKeyStore

caKeyPassword

String

)

fun createSelfSignedCACert(myLegalName: String):

fun createServerCert(subject: <ERROR CLASS>, publicKey:

certificateAuthority

subjectAlternativeNameDomains

List

String

subjectAlternativeNameIps

List

String

)

fun generateECDSAKeyPairForSSL():

fun getDevX509Name(domain: String): <ERROR CLASS>

fun getX509Name(myLegalName: String, nearestCity: String, email: String): <ERROR CLASS>

fun loadCertificateAndKey(keyStore:

keyPassword

String

alias

String

)

fun loadCertificateFromKeyStore(keyStoreFilePath:

storePassword

String

alias

String

)

fun loadCertificateFromPEMFile(filename:

)

fun loadKeyPairFromKeyStore(keyStoreFilePath:

storePassword

String

keyPassword

String

alias

String

)

fun loadKeyStore(keyStoreFilePath:

storePassword

String

)

fun loadKeyStore(input:

storePassword

String

)

fun loadOrCreateKeyPairFromKeyStore(keyStoreFilePath:

storePassword

String

keyPassword

String

alias

String

keyGenerator

(

)

)

fun loadOrCreateKeyStore(keyStoreFilePath:

storePassword

String

)

fun saveCertificateAsPEMFile(x509Certificate:

filename

fun saveKeyStore(keyStore:

)

Unit

keyStoreFilePath

storePassword

String

)

Unit

java.nio.file.Path

Module Contents

div

(

other

String

)

fun <R>

use

(

block

(

)

java.security.KeyPair

Module Contents

component1

(

)

component2

(

)

signWithECDSA

(

bitsToSign

ByteArray

)

signWithECDSA

(

bitsToSign

)

signWithECDSA

(

bitsToSign

party

)

signWithECDSA

(

bitsToSign

ByteArray

party

)

LegallyIdentifiable

java.security.PrivateKey

Module Contents

signWithECDSA

(

bits

ByteArray

)

signWithECDSA

(

bitsToSign

ByteArray

publicKey

)

java.security.PublicKey

Module Contents

toBase58String

(

)

toStringShort

(

)

String

tree

verifyWithECDSA

(

content

ByteArray

signature

)

Unit

java.time.Clock

Module Contents

awaitWithDeadline

(

deadline

future

)

Boolean

java.time.LocalDate

Module Contents

isWorkingDay

(

accordingToCalendar

java.time.temporal.Temporal

)

Boolean

Module Contents

Temporal

until

(

endExclusive

)

Module Contents

issued by

(

deposit

)

issuedBy

(

deposit

)

javafx.beans.value.ObservableValue

Module Contents

fun <A, B> ObservableValue<out A>.bind(function: (A) -> ObservableValue): ObservableValue

fun <A, B> ObservableValue<out A>.bindOut(function: (A) -> ObservableValue<out B>): ObservableValue<out B>

fun <A, B> ObservableValue<out A>.map(function: (A) -> B): ObservableValue

javafx.collections.ObservableList

Module Contents

fun <K, A, B> ObservableList<out A>.associateBy(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, B>

fun <K, A> ObservableList<out A>.associateBy(toKey: (A) -> K): ObservableMap<K, A>

fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList>

fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>>

fun <A> ObservableList<ObservableList<A>>.concatenate(): ObservableList<A>

fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A>

fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A>

fun <A> ObservableList<A>.first(): ObservableValue<A?>

fun <A> ObservableList<out ObservableValue<out A>>.flatten(): ObservableList<A>

fun <A, B> ObservableList<out A>.foldObservable(initial: B, folderFunction: (B, A) -> B): ObservableValue

fun <A> ObservableList<A>.getValueAt(index: Int): ObservableValue<A?>

fun <A> ObservableList<A>.last(): ObservableValue<A?>

fun <A : Any, B : Any, C, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K, assemble: (A, ObservableList) -> C): ObservableList<C>

fun <A : Any, B : Any, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K): ObservableMap<K, <ERROR CLASS><ObservableList<A>, ObservableList>>

fun <A, B> ObservableList<out A>.map(cached: Boolean = true, function: (A) -> B): ObservableList

javafx.collections.ObservableMap

Module Contents

fun <A, K> ObservableMap<K, A>.createMapChange(key: K, removedValue: A?, addedValue: A?): Change<K, A>

fun <K, V> ObservableMap<K, V>.getObservableEntries(): ObservableList<Entry<K, V>>

fun <K, V> ObservableMap<K, V>.getObservableValue(key: K): ObservableValue<V?>

fun <K, V> ObservableMap<K, V>.getObservableValues(): ObservableList<V>

Module Contents

fun ByteArray.sha256():

fun <T : Any> ByteArray.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): T

Module Contents

fun ByteArray.opaque():

fun ByteArray.toHexString(): <ERROR CLASS>

Module Contents

Module Contents

Module Contents

fun <A, R> (A) -> R.lift(arg0: ObservableValue<A>): ObservableValue<R>

kotlin.Function2

Module Contents

fun <A, B, R> (A, B) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue): ObservableValue<R>

kotlin.Function3

Module Contents

fun <A, B, C, R> (A, B, C) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue, arg2: ObservableValue<C>): ObservableValue<R>

kotlin.Function4

Module Contents

fun <A, B, C, D, R> (A, B, C, D) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue, arg2: ObservableValue<C>, arg3: ObservableValue<D>): ObservableValue<R>

Module Contents

val Int.SWISS_FRANCS:

Module Contents

infix fun Int.checkedAdd(b: Int): Int

Module Contents

)

Int

)

Int

)

Int

kotlin.Long

Module Contents

val Long.bd:

infix fun Long.checkedAdd(b: Long): Long

fun String.parseAsHex(): <ERROR CLASS>

Module Contents

fun String.abbreviate(maxWidth: Int): String

Module Contents

Module Contents

Module Contents

val Throwable.rootCause: Throwable

Module Contents

Collection

requireSingleCommand

(

)

Collection

requireSingleCommand

(

klass

)

Collection

select

(

signer

party

)

Collection

select

(

signers

Collection

parties

Collection

)

fun <A> Collection<ObservableValue<out A>>.sequence(): ObservableList<A>

Module Contents

Module Contents

Iterable

filterStatesOfType

(

)

List

sumOrNull

(

)

Nothing

sumOrThrow

(

)

sumOrZero

(

currency

)

Module Contents

byKeys

(

)

getKeys

(

)

toStringsShort

(

)

String

Module Contents

containsType

(

type

)

fun <T, I : Comparable> Iterable<T>.isOrderedAndUnique(extractId: T.() -> I): Boolean

Module Contents

fun <T> Iterable<T>.noneOrSingle(predicate: (T) -> Boolean): T?

fun <T> Iterable<T>.noneOrSingle(): T?

Module Contents

sumCash

(

)

sumCashBy

(

owner

)

sumCashOrNull

(

)

sumCashOrZero

(

currency

)

sumCommodities

(

)

sumCommoditiesOrNull

(

)

sumCommoditiesOrZero

(

currency

)

sumFungibleOrNull

(

)

sumFungibleOrZero

(

token

)

fun <T> List<T>.indexOfOrThrow(item: T): Int

sumObligations

(

)

sumObligationsOrNull

(

)

sumObligationsOrZero

(

issuanceDef

)

kotlin.collections.List

Module Contents

package com.r3corda.client

Module Contents

class CordaRPCClient :

Closeable

CordaRPCClient(host: <ERROR CLASS>, certificatesPath:

Module Contents

)

fun close(): Unit

val host: <ERROR CLASS>

var myID: Int

fun proxy(timeout:

minVersion

Int

)

package com.r3corda.client.fxutils

Module Contents

class AggregatedList<A, E : Any, K : Any> : TransformationList<A, E>

Module Contents

AggregatedList(list: ObservableList<out E>, toKey: (E) -> K, assemble: (K, ObservableList<E>) -> A)

val assemble: (K, ObservableList<E>) -> A

fun get(index: Int): A?

protected fun sourceChanged(c: Change<out E>): Unit

val toKey: (E) -> K

object AmountBindings

Module Contents

fun exchange(currency: ObservableValue<

exchangeRate

ObservableValue

)

ObservableValue

(

fun <T> sum(amounts: ObservableList<

)

Long

fun sumAmountExchange(amounts: ObservableList<

token

)

currency

ObservableValue

exchangeRate

ObservableValue

)

ObservableValue

class AssociatedList<K, out A, B> :

AssociatedList(sourceList: ObservableList<out A>, toKey: (A) -> K, assemble: (K, A) -> B)

Unit

Module Contents

val sourceList: ObservableList<out A>

class ChosenList<E> : ObservableListBase<E>

Module Contents

ChosenList(chosenListObservable: ObservableValue<out ObservableList<out E>>)

fun get(index: Int): E

class ConcatenatedList<A> : TransformationList<A, ObservableList<A>>

Module Contents

ConcatenatedList(sourceList: ObservableList<ObservableList<A>>)

protected fun sourceChanged(change: Change<out ObservableList<A>>): Unit

class FlattenedList<A> : TransformationList<A, ObservableValue<out A>>

Module Contents

FlattenedList(sourceList: ObservableList<out ObservableValue<out A>>)

class WrappedObservableValue<A>

Module Contents

WrappedObservableValue(observableValue: ObservableValue<A>)

val observableValue: ObservableValue<A>

val indexMap:

WrappedObservableValue

out

Int

ChangeListener

protected fun sourceChanged(c: Change<out ObservableValue<out A>>): Unit

val sourceList: ObservableList<out ObservableValue<out A>>

class LeftOuterJoinedMap<K : Any, A, B, C> :

LeftOuterJoinedMap(leftTable: ObservableMap<K, out A>, rightTable: ObservableMap<K, out B>, assemble: (K, A, ObservableValue<B?>) -> C)

SimpleObjectProperty

Module Contents

val leftTable: ObservableMap<K, out A>

val rightTable: ObservableMap<K, out B>

class MapValuesList<K, A, C> : ObservableList<C>

Module Contents

fun <K, A, C> create(sourceMap: ObservableMap<K, A>, assemble: (Entry<K, A>) -> C):

MapValuesList

val sourceMap: ObservableMap<K, A>

class MappedList<A, B> : TransformationList<B, A>

Module Contents

MappedList(list: ObservableList<A>, function: (A) -> B)

val function: (A) -> B

fun get(index: Int): B

protected fun sourceChanged(change: Change<out A>): Unit

open class ReadOnlyBackedObservableMapBase<K, A, B> : ObservableMap<K, A>

Module Contents

ReadOnlyBackedObservableMapBase()

open fun addListener(listener: InvalidationListener): Unit

open fun addListener(listener: MapChangeListener<in K, in A>?): Unit

protected val backingMap:

open fun containsValue(value: A): <ERROR CLASS>

open val entries: MutableSet<MutableEntry<K, A>>

protected fun fireChange(change: Change<out K, out A>): Unit

open fun get(key: K): <ERROR CLASS>

open fun put(key: K, value: A): A

open fun putAll(from: Map<out K, A>): Unit

open fun remove(key: K): A

open fun removeListener(listener: InvalidationListener?): Unit

open fun removeListener(listener: MapChangeListener<in K, in A>?): Unit

open val values: MutableCollection<A>

class ReplayedList<A> : TransformationList<A, A>

Module Contents

ReplayedList(sourceList: ObservableList<A>)

val replayedList:

protected fun sourceChanged(c: Change<out A>): Unit

fun <A, B, C> <ERROR CLASS><A>.foldToObservableList(initialAccumulator: C, folderFun: (A, C, ObservableList) -> C): ObservableList

fun <A, B, K, C> <ERROR CLASS><A>.foldToObservableMap(initialAccumulator: C, folderFun: (A, C, ObservableMap<K, B>) -> C): ObservableMap<K, out B>

fun <A, B> <ERROR CLASS><A>.foldToObservableValue(initial: B, folderFun: (A, B) -> B): ObservableValue

javafx.beans.value.ObservableValue

Module Contents

fun <A, B> ObservableValue<out A>.bind(function: (A) -> ObservableValue): ObservableValue

fun <A, B> ObservableValue<out A>.bindOut(function: (A) -> ObservableValue<out B>): ObservableValue<out B>

fun <A, B> ObservableValue<out A>.map(function: (A) -> B): ObservableValue

javafx.collections.ObservableList

Module Contents

fun <K, A, B> ObservableList<out A>.associateBy(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, B>

fun <K, A> ObservableList<out A>.associateBy(toKey: (A) -> K): ObservableMap<K, A>

fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList>

fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>>

fun <A> ObservableList<ObservableList<A>>.concatenate(): ObservableList<A>

fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A>

fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A>

fun <A> ObservableList<A>.first(): ObservableValue<A?>

fun <A> ObservableList<out ObservableValue<out A>>.flatten(): ObservableList<A>

fun <A, B> ObservableList<out A>.foldObservable(initial: B, folderFunction: (B, A) -> B): ObservableValue

fun <A> ObservableList<A>.getValueAt(index: Int): ObservableValue<A?>

fun <A> ObservableList<A>.last(): ObservableValue<A?>

fun <A, B> ObservableList<out A>.map(cached: Boolean = true, function: (A) -> B): ObservableList

javafx.collections.ObservableMap

Module Contents

fun <A, K> ObservableMap<K, A>.createMapChange(key: K, removedValue: A?, addedValue: A?): Change<K, A>

fun <K, V> ObservableMap<K, V>.getObservableEntries(): ObservableList<Entry<K, V>>

fun <K, V> ObservableMap<K, V>.getObservableValue(key: K): ObservableValue<V?>

fun <K, V> ObservableMap<K, V>.getObservableValues(): ObservableList<V>

kotlin.Function1

Module Contents

fun <A, R> (A) -> R.lift(arg0: ObservableValue<A>): ObservableValue<R>

kotlin.Function2

Module Contents

fun <A, B, R> (A, B) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue): ObservableValue<R>

kotlin.Function3

Module Contents

fun <A, B, C, R> (A, B, C) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue, arg2: ObservableValue<C>): ObservableValue<R>

kotlin.Function4

Module Contents

fun <A, B, C, D, R> (A, B, C, D) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue, arg2: ObservableValue<C>, arg3: ObservableValue<D>): ObservableValue<R>

fun <A> Collection<ObservableValue<out A>>.sequence(): ObservableList<A>

Module Contents

fun <A> A.lift(): ObservableValue<A>

fun <A, K> <ERROR CLASS><A>.recordAsAssociation(toKey: (A) -> K, merge: (K, A, A) -> A = { _key, _oldValue, newValue -> newValue }): ObservableMap<K, out A>

fun <A> <ERROR CLASS><A>.recordInSequence(): ObservableList<A>

package com.r3corda.client.mock

Module Contents

class EventGenerator

Module Contents

EventGenerator(parties: List<

notary

val amountGenerator: <ERROR CLASS>

)

val amountIssuedGenerator: <ERROR CLASS>

val cashStateGenerator: <ERROR CLASS>

val clientToServiceCommandGenerator: <ERROR CLASS>

val consumedGenerator:

Set

val currencyGenerator: <ERROR CLASS>

val exitCashGenerator: <ERROR CLASS>

val issueCashGenerator: <ERROR CLASS>

val issueRefGenerator:

val moveCashGenerator: <ERROR CLASS>

val producedGenerator:

Set

val publicKeyGenerator: <ERROR CLASS>

class Generator<out A>

Module Contents

Generator(generate: (

)

)

)

fun <A> choice(generators: List<

Nothing

)

fun <B, R> combine(other1:

Nothing

function

(

)

fun <B, C, R> combine(other1:

other2

function

(

)

fun <B, C, D, R> combine(other1:

other2

other3

function

(

)

fun <B, C, D, E, R> combine(other1:

other2

other3

other4

function

(

)

)

fun <A> frequency(vararg generators: <ERROR CLASS><Double,

)

)

fun <A> impure(valueClosure: () -> A):

fun map(function: (A) -> B):

fun product(other:

(

)

fun <A> pure(value: A):

fun <A> sequence(generators: List<

)

fun <A> success(generate: (

List

)

fun Generator.Companion.double():

fun Generator.Companion.doubleRange(from: Double, to: Double):

Double

Double

fun <A>

generateOrFail

(

random

fun Generator.Companion.int():

numberOfTries

Int

)

fun Generator.Companion.intRange(from: Int, to: Int):

Int

fun <A> Generator.Companion.oneOf(list: List<A>):

Int

fun <A> Generator.Companion.pickOne(list: List<A>):

fun <A> Generator.Companion.replicate(number: Int, generator:

)

fun <A> Generator.Companion.replicatePoisson(meanSize: Double, generator:

List

)

fun <A> Generator.Companion.sampleBernoulli(maxRatio: Double = 1.0, vararg collection: A): <ERROR CLASS>

List

fun <A> Generator.Companion.sampleBernoulli(collection: Collection<A>, maxRatio: Double = 1.0):

package com.r3corda.client.model

List

Module Contents

class ContractStateModel

Module Contents

ContractStateModel()

val cashStates: ObservableList<

val cashStatesDiff: <ERROR CLASS><

val contractStatesDiff: <ERROR CLASS><

data class Diff<out T :

Module Contents

Diff(added: Collection<

removed

Collection

)

val added: Collection<

val removed: Collection<

interface ExchangeRate

Module Contents

abstract fun rate(from:

val exchangeRate: ObservableValue<

)

Double

class ExchangeRateModel

Module Contents

ExchangeRateModel()

data class GatheredTransactionData

Module Contents

GatheredTransactionData(transaction:

stateMachines

ObservableList

out

val stateMachines: ObservableList<out

)

class GatheredTransactionDataModel

Module Contents

GatheredTransactionDataModel()

val collectedTransactions: <ERROR CLASS>

val gatheredTransactionDataList: ObservableList<out

GatheredTransactionData

val partiallyResolvedTransactions: <ERROR CLASS>

val progressEvents: <ERROR CLASS>

val smTxMappingList: <ERROR CLASS>

val stateMachineDataList: ObservableList<

val stateMachineDataMap: ObservableMap<

val stateMachineStatus: ObservableMap<

out

ObservableValue

val transactionMap: <ERROR CLASS>

object Models

Module Contents

fun <M : Any> get(klass: KClass<M>, origin: KClass<*>): M

inline fun <reified M : Any> get(origin: KClass<*>): M

fun <M : Any> initModel(klass: KClass<M>): <ERROR CLASS>

class NodeMonitorModel

Module Contents

NodeMonitorModel()

val clientToService: <ERROR CLASS><

val progressTracking: <ERROR CLASS><

fun register(vaultMonitorNodeInfo:

certificatesPath

val stateMachineTransactionMapping: <ERROR CLASS><

)

Unit

val stateMachineUpdates: <ERROR CLASS><

val transactions: <ERROR CLASS><

val vaultUpdates: <ERROR CLASS><

data class PartiallyResolvedTransaction

Module Contents

PartiallyResolvedTransaction(transaction:

inputs

List

ObservableValue

sealed class InputResolution

)

Module Contents

class Resolved :

fun fromSignedTransaction(transaction:

Module Contents

Resolved(stateAndRef:

)

Module Contents

)

transactions

ObservableMap

)

val inputs: List<ObservableValue<

data class ProgressTrackingEvent

Module Contents

ProgressTrackingEvent(stateMachineId:

fun createStreamFromStateMachineInfo(stateMachine:

message

String

)

)

val message: String

val stateMachineId:

data class ProtocolStatus

Module Contents

ProtocolStatus(status: String)

val status: String

data class StateMachineData

Module Contents

StateMachineData(id:

protocolStatus

ObservableValue

stateMachineStatus

ObservableValue

)

val protocolStatus: ObservableValue<

val stateMachineStatus: ObservableValue<

sealed class StateMachineStatus

Module Contents

Added(stateMachineName: String)

Module Contents

class Removed :

Removed(stateMachineName: String)

Module Contents

val stateMachineName: String

sealed class TrackedDelegate<M : Any>

Module Contents

class EventSinkDelegate<M : Any, T> :

EventSinkDelegate(klass: KClass<M>, eventSinkProperty: (M) -> <ERROR CLASS><T>)

Module Contents

val eventSinkProperty: (M) -> <ERROR CLASS><T>

operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>

class EventStreamDelegate<M : Any, T> :

EventStreamDelegate(klass: KClass<M>, eventStreamProperty: (M) -> <ERROR CLASS><T>)

Module Contents

val eventStreamProperty: (M) -> <ERROR CLASS><T>

operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>

class ObjectPropertyDelegate<M : Any, T> :

ObjectPropertyDelegate(klass: KClass<M>, objectPropertyProperty: (M) -> ObjectProperty<T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): ObjectProperty<T>

val objectPropertyProperty: (M) -> ObjectProperty<T>

class ObservableDelegate<M : Any, T> :

ObservableDelegate(klass: KClass<M>, observableProperty: (M) -> <ERROR CLASS><T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>

val observableProperty: (M) -> <ERROR CLASS><T>

class ObservableListDelegate<M : Any, T> :

ObservableListDelegate(klass: KClass<M>, observableListProperty: (M) -> ObservableList<T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): ObservableList<T>

val observableListProperty: (M) -> ObservableList<T>

class ObservableListReadOnlyDelegate<M : Any, out T> :

ObservableListReadOnlyDelegate(klass: KClass<M>, observableListReadOnlyProperty: (M) -> ObservableList<out T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): ObservableList<out T>

val observableListReadOnlyProperty: (M) -> ObservableList<out T>

class ObservableValueDelegate<M : Any, T> :

ObservableValueDelegate(klass: KClass<M>, observableValueProperty: (M) -> ObservableValue<T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): ObservableValue<T>

val observableValueProperty: (M) -> ObservableValue<T>

class ObserverDelegate<M : Any, T> :

ObserverDelegate(klass: KClass<M>, observerProperty: (M) -> <ERROR CLASS><T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T>

val observerProperty: (M) -> <ERROR CLASS><T>

class SubjectDelegate<M : Any, T> :

SubjectDelegate(klass: KClass<M>, subjectProperty: (M) -> <ERROR CLASS><T, T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): <ERROR CLASS><T, T>

val subjectProperty: (M) -> <ERROR CLASS><T, T>

class WritableValueDelegate<M : Any, T> :

WritableValueDelegate(klass: KClass<M>, writableValueProperty: (M) -> WritableValue<T>)

Module Contents

operator fun getValue(thisRef: Any, property: KProperty<*>): WritableValue<T>

val writableValueProperty: (M) -> WritableValue<T>

val klass: KClass<M>

sealed class TransactionCreateStatus

Module Contents

Module Contents

class Started :

Started(message: String?)

Module Contents

inline fun <reified M : Any, T> eventSink(noinline sinkProperty: (M) -> <ERROR CLASS><T>): <ERROR CLASS>

inline fun <reified M : Any, T> eventStream(noinline streamProperty: (M) -> <ERROR CLASS><T>): <ERROR CLASS>

exchangeAmount

(

amount

)

exchangeDouble

(

amount

inline fun <reified M : Any, T> objectProperty(noinline objectProperty: (M) -> ObjectProperty<T>):

)

Double

ObjectPropertyDelegate

inline fun <reified M : Any, T> observable(noinline observableProperty: (M) -> <ERROR CLASS><T>): <ERROR CLASS>

inline fun <reified M : Any, T> observableList(noinline observableListProperty: (M) -> ObservableList<T>):

ObservableListDelegate

inline fun <reified M : Any, T> observableListReadOnly(noinline observableListProperty: (M) -> ObservableList<out T>):

ObservableListReadOnlyDelegate

inline fun <reified M : Any, T> observableValue(noinline observableValueProperty: (M) -> ObservableValue<T>):

ObservableValueDelegate

inline fun <reified M : Any, T> observer(noinline observerProperty: (M) -> <ERROR CLASS><T>): <ERROR CLASS>

inline fun <reified M : Any, T> subject(noinline subjectProperty: (M) -> <ERROR CLASS><T, T>): <ERROR CLASS>

inline fun <reified M : Any, T> writableValue(noinline writableValueProperty: (M) -> WritableValue<T>):

WritableValueDelegate

package com.r3corda.contracts

Module Contents

val CP_LEGACY_PROGRAM_ID:

CommercialPaperLegacy

val CP_PROGRAM_ID:

CommercialPaper

class CommercialPaper :

Module Contents

Module Contents

Module Contents

)

List

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

Module Contents

Module Contents

)

Module Contents

Module Contents

owner

faceValue

maturityDate

)

)

val token:

)

)

)

)

)

Module Contents

maturityDate

)

faceValue

maturityDate

notary

)

paper

newOwner

)

Unit

paper

vault

List

)

Unit

class CommercialPaperLegacy :

)

Unit

Module Contents

CommercialPaperLegacy()

Module Contents

Module Contents

Module Contents

Module Contents

Module Contents

owner

faceValue

maturityDate

)

CommercialPaperLegacy

)

)

)

)

)

fun withoutOwner():

faceValue

maturityDate

notary

)

paper

newOwner

)

Unit

paper

vault

)

Unit

)

Unit

Module Contents

)

Module Contents

)

fun isPositive(): Boolean

class FixedRatePaymentEvent :

FixedRatePaymentEvent(date:

Module Contents

accrualStartDate

accrualEndDate

dayCountBasisDay

dayCountBasisYear

notional

rate

)

val flow:

open class FloatingRate :

class FloatingRatePaymentEvent :

Module Contents

FloatingRate()

FloatingRatePaymentEvent(date:

Module Contents

accrualStartDate

accrualEndDate

dayCountBasisDay

dayCountBasisYear

fixingDate

notional

rate

)

accrualStartDate

accrualEndDate

dayCountBasisDay

dayCountBasisYear

fixingDate

notional

rate

)

fun withNewRate(newRate:

)

val IRS_PROGRAM_ID:

InterestRateSwap

class InterestRateSwap :

Module Contents

InterestRateSwap()

data class Calculation

Module Contents

Calculation(expression:

floatingLegPaymentSchedule

Map

fixedLegPaymentSchedule

Map

val fixedLegPaymentSchedule: Map<

)

fun applyFixing(date:

newRate

)

val floatingLegPaymentSchedule: Map<

fun getFixing(date:

)

fun nextFixingDate():

abstract class AbstractIRSClause :

interface Clauses

Module Contents

Module Contents

fun checkLegAmounts(legs: List<

fun checkLegDates(legs: List<

)

Unit

fun checkRates(legs: List<

)

Unit

fun checkSchedules(legs: List<

)

Boolean

fun getFloatingLegPaymentsDifferences(payments1: Map<

)

Boolean

payments2

Map

)

List

class Agree :

AbstractIRSClause

Module Contents

Agree()

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

)

List

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Unit

Module Contents

Timestamped()

inputs

List

outputs

List

commands

List

groupingKey

Unit

)

Set

Module Contents

Module Contents

Module Contents

Module Contents

Module Contents

)

Module Contents

eligibleCurrency

eligibleCreditSupport

String

independentAmounts

threshold

minimumTransferAmount

rounding

valuationDateDescription

String

notificationTime

String

resolutionTime

String

interestRate

ReferenceRate

addressForTransfers

String

exposure

localBusinessDay

dailyInterestAmount

val addressForTransfers: String

tradeID

String

hashLegalDocs

String

)

val baseCurrency:

val dailyInterestAmount:

val eligibleCreditSupport: String

val eligibleCurrency:

val exposure:

val hashLegalDocs: String

val independentAmounts:

val localBusinessDay:

val minimumTransferAmount:

val notificationTime: String

val resolutionTime: String

val valuationDateDescription: String

abstract class CommonLeg

Module Contents

paymentFrequency

effectiveDate

effectiveDateAdjustment

terminationDate

terminationDateAdjustment

dayCountBasisDay

dayCountBasisYear

dayInMonth

Int

paymentRule

paymentDelay

Int

paymentCalendar

interestPeriodAdjustment

)

val effectiveDateAdjustment:

val interestPeriodAdjustment:

val paymentDelay: Int

val paymentFrequency:

val terminationDateAdjustment:

class FixedLeg :

Module Contents

FixedLeg(fixedRatePayer:

notional

paymentFrequency

effectiveDate

effectiveDateAdjustment

terminationDate

terminationDateAdjustment

dayCountBasisDay

dayCountBasisYear

dayInMonth

Int

paymentRule

paymentDelay

Int

paymentCalendar

interestPeriodAdjustment

fixedRate

rollConvention

)

fun copy(fixedRatePayer:

notional

paymentFrequency

effectiveDate

effectiveDateAdjustment

terminationDate

terminationDateAdjustment

dayCountBasisDay

dayCountBasisYear

dayInMonth

Int

paymentRule

paymentDelay

Int

paymentCalendar

interestPeriodAdjustment

fixedRate

)

FixedLeg

var rollConvention:

class FloatingLeg :

FloatingLeg(floatingRatePayer:

Module Contents

notional

paymentFrequency

effectiveDate

effectiveDateAdjustment

terminationDate

terminationDateAdjustment

dayCountBasisDay

dayCountBasisYear

dayInMonth

Int

paymentRule

paymentDelay

Int

paymentCalendar

interestPeriodAdjustment

rollConvention

fixingRollConvention

resetDayInMonth

Int

fixingPeriodOffset

Int

resetRule

fixingsPerPayment

fixingCalendar

index

String

indexSource

String

indexTenor

fun copy(floatingRatePayer:

)

notional

paymentFrequency

effectiveDate

effectiveDateAdjustment

terminationDate

terminationDateAdjustment

dayCountBasisDay

dayCountBasisYear

dayInMonth

Int

paymentRule

paymentDelay

Int

paymentCalendar

interestPeriodAdjustment

rollConvention

fixingRollConvention

resetDayInMonth

Int

fixingPeriod

Int

resetRule

fixingsPerPayment

fixingCalendar

index

String

indexSource

String

indexTenor

)

FloatingLeg

var fixingCalendar:

var fixingPeriodOffset: Int

var fixingRollConvention:

var fixingsPerPayment:

var floatingRatePayer:

var index: String

var indexSource: String

var indexTenor:

var resetDayInMonth: Int

fun evaluateCalculation(businessDate:

Module Contents

floatingLeg

calculation

common

linearId

)

expression

fun generateAgreement(notary:

)

Any

)

oldState

fix

)

Unit

fun isRelevant(ourKeys: Set<

fun nextScheduledActivity(thisStateRef:

)

Boolean

protocolLogicRefFactory

)

val parties: List<

fun prettyPrint(): <ERROR CLASS>

val ref: String

fun generateAgreement(floatingLeg:

fixedLeg

calculation

common

notary

)

irs

fixing

)

Unit

val legalContractReference: <ERROR CLASS>

abstract class PaymentEvent :

)

Unit

Module Contents

PaymentEvent(date:

abstract fun calculate():

)

open class PercentageRatioUnit :

PercentageRatioUnit(percentageAsString: String)

Module Contents

open class Rate

Module Contents

Rate(ratioUnit:

)

val ratioUnit:

abstract class RatePaymentEvent :

PaymentEvent

Module Contents

RatePaymentEvent(date:

accrualStartDate

accrualEndDate

dayCountBasisDay

dayCountBasisYear

notional

rate

)

val accrualEndDate:

val accrualStartDate:

open fun asCSV(): String

open fun calculate():

abstract val flow:

Module Contents

)

ReferenceRate(oracle: String, tenor:

class ReferenceRate :

FloatingRate

Module Contents

name

String

)

open class UnknownType

Module Contents

UnknownType()

exportIRSToCSV

(

)

String

kotlin.Int

Module Contents

)

Int

)

Int

)

Int

Module Contents

owned by

(

owner

)

infix fun <ERROR CLASS>.owned by(newOwner:

)

times

(

other

)

with notary

(

notary

)

package com.r3corda.contracts.asset

Module Contents

CASH

val COMMODITY_PROGRAM_ID:

Module Contents

Module Contents

Module Contents

Module Contents

)

List

Module Contents

out

Module Contents

Module Contents

)

Module Contents

val exitKeys: <ERROR CLASS>

Module Contents

)

Module Contents

amount

owner

)

owner

encumbrance

Int

)

val encumbrance: Int?

)

newOwner

)

)

amount

owner

)

)

List

)

tokenDef

pennies

Long

owner

notary

)

Unit

amount

owner

notary

)

Unit

class CommodityContract :

)

Unit

Module Contents

Module Contents

Module Contents

Module Contents

)

List

Module Contents

out

Module Contents

Module Contents

)

Module Contents

val exitKeys: MutableSet<

Module Contents

)

Module Contents

amount

owner

)

owner

)

newOwner

)

)

amount

owner

)

)

List

)

tokenDef

pennies

Long

owner

notary

)

Unit

amount

owner

notary

)

Unit

val DUMMY_CASH_ISSUER: <ERROR CLASS>

)

Unit

val DUMMY_CASH_ISSUER_KEY: <ERROR CLASS>

val DUMMY_OBLIGATION_ISSUER: <ERROR CLASS>

val DUMMY_OBLIGATION_ISSUER_KEY: <ERROR CLASS>

interface FungibleAsset<T> :

Module Contents

Module Contents

Module Contents

abstract val deposit:

abstract val exitKeys: Collection<

abstract val issuanceDef:

abstract fun move(newAmount:

newOwner

)

class InsufficientBalanceException :

InsufficientBalanceException(amountMissing:

Module Contents

)

val amountMissing:

val OBLIGATION_PROGRAM_ID:

OBLIGATION

OBLIGATION_DEF

Module Contents

Module Contents

Module Contents

Module Contents

)

List

Module Contents

out

Module Contents

Unit

inputs

List

outputs

List

commands

List

groupingKey

Unit

)

Set

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

out

inputs

List

outputs

List

commands

List

groupingKey

)

Set

class VerifyLifecycle<S :

Any

Module Contents

inputs

List

outputs

List

commands

List

groupingKey

)

Set

Module Contents

Module Contents

)

Module Contents

data class SetLifecycle :

Module Contents

)

Module Contents

)

val exitKeys: Collection<

Module Contents

SetLifecycle(lifecycle:

)

Module Contents

)

Module Contents

Module Contents

obligor

template

quantity

Long

beneficiary

)

val bilateralNetState:

newOwner

)

val multilateralNetState:

)

Terms(acceptableContracts:

)

data class Terms

Module Contents

acceptableIssuedProducts

dueBefore

timeTolerance

)

val acceptableContracts:

val acceptableIssuedProducts:

fun generateCloseOutNetting(tx:

signer

vararg

states

)

Unit

amountIssued

assetStates

List

)

obligor

issuanceDef

pennies

Long

beneficiary

notary

fun generatePaymentNetting(tx:

)

Unit

issued

notary

vararg

states

fun generateSetLifecycle(tx:

)

Unit

statesAndRefs

List

lifecycle

notary

)

Unit

fun generateSettle(tx:

statesAndRefs

Iterable

assetStatesAndRefs

Iterable

moveCommand

notary

)

Unit

abstract class OnLedgerAsset<T : Any, C :

)

Unit

Module Contents

abstract val conserveClause:

abstract fun deriveState(txState:

amount

owner

)

abstract fun extractCommands(commands: Collection<

)

Collection

amountIssued

assetStates

List

)

abstract fun generateExitCommand(amount:

)

abstract fun generateIssueCommand():

abstract fun generateMoveCommand():

amount

assetsStates

List

onlyFromParties

Set

)

List

STATE

(

dueBefore

)

between

(

parties

)

cashBalances

Map

fun extractAmountsDue(product:

states

Iterable

)

Map

issued by

(

party

)

issued by

(

deposit

)

issued by

(

party

)

issuedBy

(

party

)

issuedBy

(

deposit

)

issuedBy

(

party

)

Module Contents

sumCash

(

)

sumCashBy

(

owner

)

sumCashOrNull

(

)

sumCashOrZero

(

currency

)

sumCommodities

(

)

sumCommoditiesOrNull

(

)

sumCommoditiesOrZero

(

currency

)

sumFungibleOrNull

(

)

sumFungibleOrZero

(

token

)

fun netAmountsDue(balances: Map<<ERROR CLASS><

sumObligations

(

)

sumObligationsOrNull

(

)

sumObligationsOrZero

(

issuanceDef

)

)

Map

owned by

(

owner

)

owned by

(

owner

)

ownedBy

(

owner

)

ownedBy

(

owner

)

fun sumAmountsDue(balances: Map<<ERROR CLASS><

)

Map

Long

with deposit

(

deposit

)

withDeposit

(

deposit

)

package com.r3corda.contracts.clause

Module Contents

abstract class AbstractConserveAmount<S :

Any

Module Contents

AbstractConserveAmount()

amountIssued

assetStates

List

deriveState

(

)

generateMoveCommand

(

)

generateExitCommand

(

)

)

amount

assetsStates

List

onlyFromParties

Set

deriveState

(

)

generateMoveCommand

(

)

)

List

inputs

List

outputs

List

commands

List

groupingKey

abstract class AbstractIssue<in S :

)

Set

Any

Module Contents

AbstractIssue(sum: List<S>.() ->

sumOrZero

List

(

)

)

val sum: List<S>.() ->

val sumOrZero: List<S>.(

)

inputs

List

outputs

List

commands

List

groupingKey

data class BilateralNetState :

)

Set

BilateralNetState(partyKeys: Set<

Module Contents

template

)

data class MultilateralNetState :

MultilateralNetState(template:

Module Contents

)

val template:

open class NetClause<C :

Unit

Module Contents

NetClause()

out

inputs

List

outputs

List

commands

List

fun verifyNetCommand(inputs: List<

groupingKey

Unit

)

Set

outputs

List

command

netState

)

Unit

interface NetState

Module Contents

abstract val template:

open class NoZeroSizedOutputs<in S :

Any

Module Contents

inputs

List

outputs

List

commands

List

groupingKey

package com.r3corda.contracts.testing

)

Set

Module Contents

class CommandDataGenerator

Module Contents

CommandDataGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class CommandGenerator

Module Contents

CommandGenerator()

class ContractStateGenerator

Module Contents

ContractStateGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class ExitGenerator

Module Contents

ExitGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class IssueGenerator

Module Contents

IssueGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class MoveGenerator

Module Contents

MoveGenerator()

class SignedTransactionGenerator

Module Contents

SignedTransactionGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class WiredTransactionGenerator

Module Contents

WiredTransactionGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

fillWithSomeTestCash

(

howMuch

outputNotary

data class ErrorOr<out A>

atLeastThisManyStates

Int

atMostThisManyStates

Int

rng

ref

ownedBy

)

package com.r3corda.core

Module Contents

Module Contents

ErrorOr(value: A)

)

inline fun <T> catch(body: () -> T):

Nothing

fun <B, C> combine(other:

function

(

)

fun map(function: (A) -> B): <ERROR CLASS>

val error: Throwable?

fun getOrThrow(): A

fun <T> match(onValue: (A) -> T, onError: (Throwable) -> T): T

fun of(t: Throwable):

abstract class RetryableException :

Nothing

val value: A?

RetryableException(message: String)

Module Contents

val RunOnCallerThread: <ERROR CLASS>

class ThreadBox<out T>

Module Contents

ThreadBox(content: T, lock:

inline fun <R> alreadyLocked(body: T.() -> R): R

)

fun checkNotLocked(): <ERROR CLASS>

val content: T

val lock:

inline fun <R> locked(body: T.() -> R): R

class TransientProperty<out T>

Module Contents

TransientProperty(initializer: () -> T)

operator fun getValue(thisRef: Any?, property: KProperty<*>): T

fun <T> <ERROR CLASS><T>.bufferUntilSubscribed(): <ERROR CLASS><T>

inline fun <T> <ERROR CLASS><T>.catch(block: () -> T): Unit

fun extractZipFile(zipPath:

toPath

fun <T> <ERROR CLASS><T>.failure(executor:

)

Unit

infix fun <T> <ERROR CLASS><T>.failure(body: (Throwable) -> Unit): <ERROR CLASS><T>

body

(

Throwable

)

Unit

)

infix fun <F, T> <ERROR CLASS><F>.flatMap(mapper: (F) -> <ERROR CLASS><T>): <ERROR CLASS><T>

java.nio.file.Path

Module Contents

div

(

other

String

)

fun <R>

use

(

block

(

java.time.temporal.Temporal

)

Module Contents

infix fun Int.checkedAdd(b: Int): Int

Temporal

until

(

endExclusive

)

Module Contents

Module Contents

Module Contents

infix fun Long.checkedAdd(b: Long): Long

fun String.abbreviate(maxWidth: Int): String

Module Contents

val String.bd:

val Throwable.rootCause: Throwable

kotlin.Throwable

Module Contents

fun <T, I : Comparable> Iterable<T>.isOrderedAndUnique(extractId: T.() -> I): Boolean

Module Contents

fun <T> Iterable<T>.noneOrSingle(predicate: (T) -> Boolean): T?

fun <T> Iterable<T>.noneOrSingle(): T?

kotlin.collections.List

Module Contents

fun <T> List<T>.indexOfOrThrow(item: T): Int

fun <T> logElapsedTime(label: String, logger: <ERROR CLASS>? = null, body: () -> T): T

infix fun <F, T> <ERROR CLASS><F>.map(mapper: (F) -> T): <ERROR CLASS><T>

fun random63BitValue(): Long

fun <T> <ERROR CLASS><T>.success(executor:

infix fun <T> <ERROR CLASS><T>.success(body: (T) -> Unit): <ERROR CLASS><T>

body

(

)

Unit

)

fun <T> <ERROR CLASS><T>.then(executor:

infix fun <T> <ERROR CLASS><T>.then(body: () -> Unit): <ERROR CLASS><T>

body

(

)

Unit

)

package com.r3corda.core.contracts

Module Contents

enum class AccrualAdjustment

Module Contents

Adjusted

Unadjusted

data class Amount<T> : Comparable<

Module Contents

Amount(amount:

Amount(quantity: Long, token: T)

currency

)

operator fun div(other: Long):

)

Int

operator fun div(other: Int):

operator fun minus(other:

)

operator fun plus(other:

)

operator fun times(other: Long):

val quantity: Long

operator fun times(other: Int):

val token: T

interface Attachment :

open fun extractFile(path: String, outputTo:

Module Contents

OutputStream

)

Unit

abstract fun open():

data class AuthenticatedObject<out T : Any>

open fun openAsJAR():

JarInputStream

Module Contents

AuthenticatedObject(signers: List<

signingParties

List

value

)

val signingParties: List<

interface BilateralNettableState<N :

val value: T

abstract val bilateralNetState: Any

Module Contents

abstract fun net(other: N): N

open class BusinessCalendar

Module Contents

val TEST_CALENDAR_DATA: <ERROR CLASS>

class UnknownCalendar :

UnknownCalendar(name: String)

Module Contents

open fun applyRollConvention(testDate:

dateRollConvention

)

val calendars: <ERROR CLASS>

fun createGenericSchedule(startDate:

period

calendar

dateRollConvention

noOfAdditionalPeriods

Int

endDate

periodOffset

Int

)

List

fun getInstance(vararg calname: String):

fun getOffsetDate(startDate:

period

steps

Int

)

val holidayDates: List<

open fun isWorkingDay(date:

fun moveBusinessDays(date:

)

Boolean

direction

Int

)

fun parseDateFromString(it: String):

val CHF:

sealed class ClientToServiceCommand

Module Contents

class ExitCash :

Module Contents

issueRef

)

Module Contents

issueRef

recipient

notary

)

Module Contents

recipient

)

Module Contents

key

)

signers

List

)

Commodity(commodityCode: String, displayName: String, defaultFractionDigits: Int = 0)

interface CommandData

data class Commodity

Module Contents

val commodityCode: String

val defaultFractionDigits: Int

val displayName: String

fun getInstance(commodityCode: String):

abstract val legalContractReference:

interface Contract

Module Contents

)

Unit

interface ContractState

Module Contents

abstract val contract:

open val encumbrance: Int?

abstract val participants: List<

fun DOLLARS(amount: Int):

fun DOLLARS(amount: Double):

enum class DateRollConvention

val DUMMY_PROGRAM_ID:

DummyContract

Module Contents

Actual

Module Contents

Following

Module Contents

ModifiedFollowing

Module Contents

ModifiedPrevious

Module Contents

Module Contents

abstract fun direction():

abstract val isModified: Boolean

enum class DateRollDirection

Module Contents

BACKWARD

FORWARD

val value: Long

enum class DayCountBasisDay

Module Contents

enum class DayCountBasisYear

Module Contents

interface DealState :

abstract fun generateAgreement(notary:

Module Contents

)

abstract val parties: List<

data class MultiOwnerState :

abstract val ref: String

class DummyContract :

Module Contents

Module Contents

Module Contents

Module Contents

MultiOwnerState(magicNumber: Int = 0, owners: List<

Module Contents

)

data class SingleOwnerState :

SingleOwnerState(magicNumber: Int = 0, owner:

Module Contents

)

)

interface State :

abstract val magicNumber: Int

Module Contents

fun generateInitial(owner:

magicNumber

Int

notary

)

newOwner

)

fun move(priors: List<

newOwner

)

)

Unit

data class DummyState :

DummyState(magicNumber: Int = 0)

Module Contents

val contract:

DummyContract

val magicNumber: Int

val EUR:

object ExpressionDeserializer

data class Expression

Module Contents

Expression(expr: String)

val expr: String

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ExpressionSerializer

Module Contents

fun serialize(expr:

generator

provider

)

Unit

val FCOJ:

FixOf(name: String, forDay:

fun FCOJ(amount: Int):

Module Contents

value

)

Module Contents

ofTenor

)

interface FixableDealState :

abstract fun generateFix(ptx:

Module Contents

oldState

fix

abstract fun nextFixingOf():

)

Unit

abstract val oracleType:

Module Contents

Module Contents

Long

)

Module Contents

Long

)

Module Contents

Long

)

Module Contents

Long

)

Module Contents

Long

)

Module Contents

Long

)

Module Contents

Long

)

val annualCompoundCount: Int

abstract fun offset(d:

Long

)

val GBP:

interface IssuanceDefinition

interface IssueCommand :

Module Contents

abstract val nonce: Long

data class Issued<out P>

Module Contents

Issued(issuer:

product

)

val issuer:

val product: P

interface LinearState :

Module Contents

class ClauseVerifier<S :

Unit

Module Contents

ClauseVerifier()

inputs

List

outputs

List

commands

List

abstract fun isRelevant(ourKeys: Set<

groupingKey

Unit

)

Set

)

Boolean

abstract val linearId:

interface MoveCommand :

abstract val contractHash:

Module Contents

interface MultilateralNettableState<out T : Any>

Module Contents

abstract val multilateralNetState: T

interface NamedByHash

Module Contents

interface NettableState<N :

interface NetCommand :

Module Contents

Module Contents

Any

MultilateralNettableState

interface OwnableState :

Module Contents

abstract val owner:

abstract fun withNewOwner(newOwner:

)

fun POUNDS(amount: Int):

data class PartyAndReference

Module Contents

PartyAndReference(party:

reference

)

infix fun String.by(expr: Boolean): Unit

enum class PaymentRule

Module Contents

Module Contents

fun SWISS_FRANCS(amount: Int):

interface SchedulableState :

abstract fun nextScheduledActivity(thisStateRef:

Module Contents

protocolLogicRefFactory

)

abstract val scheduledAt:

interface Scheduled

Module Contents

data class ScheduledActivity :

ScheduledActivity(logicRef:

Module Contents

scheduledAt

)

data class ScheduledStateRef :

data class StateAndRef<out T :

Module Contents

ScheduledStateRef(ref:

scheduledAt

)

Module Contents

ref

)

Module Contents

index

Int

)

val index: Int

fun daysToMaturity(startDate:

Module Contents

Module Contents

calendar

)

Int

class TransactionConflictException :

Module Contents

tolerance

)

before

)

TransactionConflictException(conflictRef:

Module Contents

tx1

tx2

)

data class TransactionForContract

Module Contents

TransactionForContract(inputs: List<

outputs

List

attachments

List

data class InOutGroup<out T :

commands

List

origHash

inputNotary

timestamp

)

InOutGroup(inputs: List<T>, outputs: List<T>, groupingKey: K)

out

Any

Module Contents

val groupingKey: K

val inputs: List<T>

val outputs: List<T>

Any

groupStates

(

ofType

selector

(

)

List

Any

groupStates

(

selector

(

)

List

class TransactionGraphSearch :

Any

~~groupStatesInternal~~

(

inGroups

Map

List

outGroups

Map

List

)

List

Callable

List

TransactionGraphSearch(transactions:

Module Contents

startPoints

List

)

class Query

Module Contents

Query(withCommandOfType:

out

followInputsOfType

out

)

val followInputsOfType:

out

val withCommandOfType:

out

val startPoints: List<

val transactions:

class TransactionResolutionException :

TransactionResolutionException(hash:

Module Contents

)

data class TransactionState<out T :

TransactionState(data: T, notary:

Module Contents

)

fun withNotary(newNotary:

)

sealed class TransactionType

Module Contents

Module Contents

Module Contents

)

)

fun addInputState(stateAndRef:

)

Unit

Module Contents

Module Contents

)

)

Unit

)

)

Unit

abstract fun getRequiredSigners(tx:

)

Set

)

Unit

fun verifySigners(tx:

)

Set

abstract fun verifyTransaction(tx:

sealed class TransactionVerificationException :

)

Unit

class ContractRejection :

Module Contents

Module Contents

ContractRejection(tx:

contract

class InvalidNotaryChange :

cause

Throwable

)

Module Contents

Module Contents

InvalidNotaryChange(tx:

class MoreThanOneNotary :

)

Module Contents

MoreThanOneNotary(tx:

class NotaryChangeInWrongTransactionType :

)

NotaryChangeInWrongTransactionType(tx:

Module Contents

outputNotary

)

class SignersMissing :

Module Contents

SignersMissing(tx:

missing

List

)

val missing: List<

class TransactionMissingEncumbranceException :

TransactionMissingEncumbranceException(tx:

Module Contents

abstract class TypeOnlyCommandData :

missing

Int

inOut

)

Module Contents

TypeOnlyCommandData()

val USD:

data class UniqueIdentifier : Comparable<

UniqueIdentifier(externalId: String? = null, id:

Module Contents

)

fun fromString(name: String):

)

Int

val externalId: String?

fun calculateDaysBetween(startDate:

endDate

dcbYear

dcbDay

)

Int

fun commodity(code: String):

fun currency(code: String):

hash

(

)

issued by

(

deposit

)

issued by

(

deposit

)

issuedBy

(

deposit

)

issuedBy

(

deposit

)

Module Contents

isWorkingDay

(

accordingToCalendar

)

Boolean

java.util.Currency

Module Contents

issued by

(

deposit

)

issuedBy

(

deposit

)

Module Contents

Module Contents

val Int.SWISS_FRANCS:

Module Contents

Collection

requireSingleCommand

(

)

Collection

requireSingleCommand

(

klass

)

Collection

select

(

signer

party

)

Collection

select

(

signers

Collection

parties

Collection

)

Module Contents

Iterable

filterStatesOfType

(

)

List

sumOrNull

(

)

Nothing

sumOrThrow

(

)

sumOrZero

(

currency

)

inline fun <R> requireThat(body:

Requirements

(

)

MoveCommand

verifyMoveCommand

(

inputs

List

)

MoveCommand

MoveCommand

verifyMoveCommand

(

inputs

List

commands

List

)

with notary

(

newNotary

)

withNotary

(

newNotary

)

withoutIssuer

(

)

package com.r3corda.core.contracts.clauses

Module Contents

class AllComposition<S :

Any

AllComposition(firstClause:

Module Contents

vararg

remainingClauses

)

)

List

inputs

List

outputs

List

commands

List

class AnyComposition<in S :

groupingKey

)

Set

Any

AnyComposition(vararg rawClauses:

Module Contents

)

val clauses: List<

)

List

inputs

List

outputs

List

commands

List

abstract class Clause<in S :

groupingKey

)

Set

Any

Module Contents

Clause()

)

List

out

inputs

List

outputs

List

commands

List

abstract class CompositeClause<in S :

groupingKey

)

Set

Any

Module Contents

abstract val clauses: List<

)

List

abstract fun matchedClauses(commands: List<

)

List

Any

Module Contents

filterStates

(

List

)

List

)

val filterStates: (List<

fun getExecutionPath(commands: List<

)

List

)

List

out

inputs

List

outputs

List

commands

List

class FirstComposition<S :

groupingKey

)

Set

Any

FirstComposition(firstClause:

Module Contents

vararg

remainingClauses

)

)

List

inputs

List

outputs

List

commands

List

abstract class GroupClauseVerifier<S :

groupingKey

)

Set

Any

Unit

Module Contents

GroupClauseVerifier(clause:

)

)

List

abstract fun groupStates(tx:

)

List

inputs

List

outputs

List

commands

List

groupingKey

Unit

)

Set

fun <C :

matches

(

commands

List

)

Boolean

fun <C :

verifyClause

(

clause

Unit

commands

List

package com.r3corda.core.crypto

)

Unit

Module Contents

open class DigitalSignature :

DigitalSignature(bits: ByteArray)

Module Contents

class LegallyIdentifiable :

LegallyIdentifiable(signer:

Module Contents

bits

ByteArray

)

Module Contents

bits

ByteArray

)

val by:

fun verifyWithECDSA(content: ByteArray): Unit

fun verifyWithECDSA(content:

)

Unit

class DummyPublicKey :

Comparable

DummyPublicKey(s: String)

Module Contents

)

Int

fun getEncoded(): <ERROR CLASS>

val s: String

object NullPublicKey :

Comparable

Module Contents

)

Int

fun getEncoded(): ByteArray

object NullSignature :

Party(name: String, owningKey:

data class Party

Module Contents

)

)

fun ref(vararg bytes: Byte):

sealed class PublicKeyTree

Module Contents

class Builder

Module Contents

Builder()

fun addKey(publicKey:

weight

Int

)

fun addKeys(vararg publicKeys:

)

fun addLeaves(publicKeys: List<

)

fun addLeaves(vararg publicKeys:

)

fun build(threshold: Int? = null):

Module Contents

)

Node(threshold: Int, children: List<

)

Module Contents

weights

List

Int

)

val children: List<

fun containsAny(keys: Iterable<

)

Boolean

val threshold: Int

val weights: List<Int>

abstract fun getKeys(): Set<

)

abstract fun isFulfilledBy(keys: Iterable<

)

Boolean

fun isFulfilledBy(key:

fun parseFromBase58(encoded: String): <ERROR CLASS>

)

fun toBase58String(): String

sealed class SecureHash :

Module Contents

class SHA256 :

fun parse(str: String): <ERROR CLASS>

Module Contents

SHA256(bits: ByteArray)

fun prefixChars(prefixLen: Int = 6): <ERROR CLASS>

fun randomSHA256():

fun sha256(bits: ByteArray):

fun sha256(str: String): <ERROR CLASS>

fun sha256Twice(bits: ByteArray):

open class SignedData<T : Any>

Module Contents

sig

)

protected open fun verifyData(data: T): Unit

class WhitelistTrustManager :

WhitelistTrustManager(originalProvider:

Module Contents

)

authType

String

socket

)

Unit

authType

String

engine

)

Unit

authType

String

)

Unit

authType

String

socket

)

Unit

authType

String

engine

)

Unit

val checker: HostnameChecker

authType

String

)

Unit

fun getAcceptedIssuers(): Array<out

object WhitelistTrustManagerProvider :

Provider

Module Contents

fun addWhitelistEntries(serverNames: List<String>): Unit

fun addWhitelistEntry(serverName: String): Unit

val originalTrustProviderAlgorithm: String

fun register(): Unit

val whitelist: Set<String>

class WhitelistTrustManagerSpi :

TrustManagerFactorySpi

Module Contents

WhitelistTrustManagerSpi()

protected fun engineGetTrustManagers(): Array<out

TrustManager

protected fun engineInit(keyStore:

protected fun engineInit(managerFactoryParameters:

)

Unit

ManagerFactoryParameters

)

Unit

CACertAndKey(certificate:

TrustManagerFactory

object X509Utilities

Module Contents

data class CACertAndKey

Module Contents

keyPair

)

val CORDA_CLIENT_CA: String

val CORDA_CLIENT_CA_PRIVATE_KEY: String

val CORDA_INTERMEDIATE_CA: String

val CORDA_INTERMEDIATE_CA_PRIVATE_KEY: String

val CORDA_ROOT_CA: String

val CORDA_ROOT_CA_PRIVATE_KEY: String

val ECDSA_CURVE: String

val KEYSTORE_TYPE: String

val KEY_GENERATION_ALGORITHM: String

val SIGNATURE_ALGORITHM: String

addOrReplaceCertificate

(

alias

String

cert

)

Unit

addOrReplaceKey

(

alias

String

key

Key

password

CharArray

chain

Array

fun createCAKeyStoreAndTrustStore(keyStoreFilePath:

)

Unit

storePassword

String

keyPassword

String

trustStoreFilePath

trustStorePassword

String

)

fun createCertificateSigningRequest(myLegalName: String, nearestCity: String, email: String, keyPair:

fun createIntermediateCert(domain: String, certificateAuthority:

)

)

fun createKeystoreForSSL(keyStoreFilePath:

storePassword

String

keyPassword

String

caKeyStore

caKeyPassword

String

)

fun createSelfSignedCACert(myLegalName: String):

fun createServerCert(subject: <ERROR CLASS>, publicKey:

certificateAuthority

subjectAlternativeNameDomains

List

String

subjectAlternativeNameIps

List

String

)

fun generateECDSAKeyPairForSSL():

fun getDevX509Name(domain: String): <ERROR CLASS>

fun getX509Name(myLegalName: String, nearestCity: String, email: String): <ERROR CLASS>

fun loadCertificateAndKey(keyStore:

keyPassword

String

alias

String

)

fun loadCertificateFromKeyStore(keyStoreFilePath:

storePassword

String

alias

String

)

fun loadCertificateFromPEMFile(filename:

)

fun loadKeyPairFromKeyStore(keyStoreFilePath:

storePassword

String

keyPassword

String

alias

String

)

fun loadKeyStore(keyStoreFilePath:

storePassword

String

)

fun loadKeyStore(input:

storePassword

String

)

fun loadOrCreateKeyPairFromKeyStore(keyStoreFilePath:

storePassword

String

keyPassword

String

alias

String

keyGenerator

(

)

)

fun loadOrCreateKeyStore(keyStoreFilePath:

storePassword

String

)

fun saveCertificateAsPEMFile(x509Certificate:

filename

fun saveKeyStore(keyStore:

)

Unit

keyStoreFilePath

val ed25519Curve: <ERROR CLASS>

storePassword

String

)

Unit

fun entropyToKeyPair(entropy:

BigInteger

)

fun generateKeyPair():

java.security.KeyPair

Module Contents

component1

(

)

component2

(

)

signWithECDSA

(

bitsToSign

ByteArray

)

signWithECDSA

(

bitsToSign

)

signWithECDSA

(

bitsToSign

party

)

signWithECDSA

(

bitsToSign

ByteArray

party

)

LegallyIdentifiable

java.security.PrivateKey

Module Contents

signWithECDSA

(

bits

ByteArray

)

signWithECDSA

(

bitsToSign

ByteArray

publicKey

)

java.security.PublicKey

Module Contents

toBase58String

(

)

toStringShort

(

)

String

tree

verifyWithECDSA

(

content

ByteArray

signature

)

Unit

Module Contents

fun ByteArray.sha256():

Module Contents

byKeys

(

)

getKeys

(

)

fun parsePublicKeyBase58(base58String: String): <ERROR CLASS>

toStringsShort

(

)

String

fun newSecureRandom():

SecureRandom

fun registerWhitelistTrustManager(): Unit

sha256

(

)

package com.r3corda.core.math

Module Contents

class CubicSplineInterpolator :

CubicSplineInterpolator(xs: DoubleArray, ys: DoubleArray)

Module Contents

CubicSplineInterpolator

abstract fun interpolate(x: Double): Double

interface Interpolator

Module Contents

interface InterpolatorFactory

Module Contents

abstract fun create(xs: DoubleArray, ys: DoubleArray):

class LinearInterpolator :

LinearInterpolator(xs: DoubleArray, ys: DoubleArray)

Module Contents

LinearInterpolator

Polynomial(coefficients: DoubleArray)

class Polynomial

Module Contents

fun getValue(x: Double): <ERROR CLASS>

class SplineFunction

Module Contents

SplineFunction(segmentMap:

TreeMap

Double

Polynomial

)

fun getValue(x: Double): Double

package com.r3corda.core.messaging

Module Contents

object Ack :

interface AllPossibleRecipients :

abstract val data: ByteArray

interface Message

Module Contents

abstract val debugTimestamp:

abstract fun serialise(): ByteArray

abstract val topicSession:

abstract val uniqueMessageId:

interface MessageHandlerRegistration

interface MessageRecipientGroup :

interface MessageRecipients

interface MessagingService

Module Contents

abstract fun addMessageHandler(topic: String = "", sessionID: Long = DEFAULT_SESSION_ID, executor:

callback

(

)

Unit

)

abstract fun addMessageHandler(topicSession:

executor

callback

(

)

Unit

)

abstract fun createMessage(topicSession:

data

ByteArray

uuid

)

abstract val myAddress:

abstract fun removeMessageHandler(registration:

abstract fun send(message:

)

Unit

target

interface SingleMessageRecipient :

)

Unit

TopicSession(topic: String, sessionID: Long = DEFAULT_SESSION_ID)

data class TopicSession

Module Contents

val Blank:

fun isBlank(): Boolean

object TopicStringValidator

val topic: String

Module Contents

fun check(tag: String): <ERROR CLASS>

createMessage

(

topic

String

sessionID

Long

data

ByteArray

)

fun <M : Any>

onNext

(

topic

String

sessionId

Long

executor

)

runOnNextMessage

(

topic

String

sessionID

Long

executor

callback

(

)

Unit

)

Unit

inline fun

runOnNextMessage

(

topicSession

executor

crossinline

callback

(

)

Unit

)

Unit

send

(

topic

String

sessionID

Long

payload

Any

uuid

)

Unit

send

(

topicSession

payload

Any

uuid

package com.r3corda.core.node

)

Unit

Module Contents

class AttachmentsClassLoader :

SecureClassLoader

Module Contents

AttachmentsClassLoader(attachments: List<

parent

class OverlappingAttachments :

)

OverlappingAttachments(path: String)

Module Contents

val path: String

protected fun findClass(name: String):

protected fun findResource(name: String):

fun getResourceAsStream(name: String):

operator fun get(name: String):

object CityDatabase

Module Contents

abstract class CordaPluginRegistry

Module Contents

CordaPluginRegistry()

open val requiredProtocols: Map<String, Set<String>>

open val servicePlugins: List<

open val staticServeDirs: Map<String, String>

open val webApis: List<

data class NodeInfo

Module Contents

NodeInfo(address:

legalIdentity

advertisedServices

List

ServiceEntry

physicalLocation

)

val address:

var advertisedServices: List<

val physicalLocation:

fun serviceIdentities(type:

)

List

data class PhysicalLocation

Module Contents

PhysicalLocation(coordinate:

description

String

)

val coordinate:

abstract val identityService:

val description: String

data class ServiceEntry

Module Contents

identity

)

Module Contents

abstract fun <T : Any> invokeProtocolAsync(logicType:

out

abstract val keyManagementService:

vararg

args

Any

)

open val legalIdentityKey:

open fun loadState(stateRef:

)

open val notaryIdentityKey:

abstract fun recordTransactions(txs: Iterable<

abstract val schedulerService:

)

Unit

abstract val storageService:

abstract val vaultService:

data class WorldCoordinate

Module Contents

WorldCoordinate(latitude: Double, longitude: Double)

val latitude: Double

val longitude: Double

fun project(screenWidth: Double, screenHeight: Double, topLatitude: Double, bottomLatitude: Double, leftLongitude: Double, rightLongitude: Double): <ERROR CLASS><Double, Double>

recordTransactions

(

vararg

txs

package com.r3corda.core.node.services

)

Unit

Module Contents

interface AttachmentStorage

Module Contents

abstract fun importAttachment(jar:

)

abstract fun openAttachment(id:

)

val DEFAULT_SESSION_ID: Long

interface IdentityService

Module Contents

abstract fun partyFromKey(key:

)

abstract fun partyFromName(name: String):

abstract fun registerIdentity(party:

interface KeyManagementService

)

Unit

Module Contents

abstract fun freshKey():

abstract val keys: Map<

open fun toKeyPair(publicKey:

)

open fun toPrivate(publicKey:

)

sealed class NetworkCacheError :

class DeregistrationFailed :

Module Contents

NetworkCacheError

Module Contents

DeregistrationFailed()

interface NetworkMapCache

Module Contents

Module Contents

prevNodeInfo

type

)

enum class MapChangeType

Module Contents

Added

Modified

Removed

abstract fun addMapService(net:

networkMapAddress

abstract fun addNode(node:

Boolean

ifChangedSinceVer

Int

)

Unit

abstract val changed: <ERROR CLASS><

)

Unit

abstract fun deregisterForUpdates(net:

service

abstract fun get(): Collection<

)

Unit

abstract fun get(serviceType:

)

Collection

abstract fun getNodeByLegalName(name: String):

abstract fun getNodeByPublicKey(publicKey:

)

abstract fun getRecommended(type:

contract

vararg

party

)

abstract val mapServiceRegistered: <ERROR CLASS><Unit>

abstract val networkMapNodes: List<

abstract val notaryNodes: List<

abstract val partyNodes: List<

abstract val regulators: List<

abstract fun removeNode(node:

abstract fun runWithoutMapService(): Unit

)

Unit

interface ReadOnlyTransactionStorage

Module Contents

abstract fun getTransaction(id:

)

interface SchedulerService

Module Contents

abstract fun scheduleStateActivity(action:

abstract fun unscheduleStateActivity(ref:

)

Unit

)

Unit

data class ServiceInfo

Module Contents

ServiceInfo(type:

fun parse(encoded: String):

name

String

)

val name: String?

sealed class ServiceType

Module Contents

val corda:

open operator fun equals(other: Any?): Boolean

fun getServiceType(namespace: String, typeId: String):

fun getSubType(subTypeId: String):

fun isSubTypeOf(superType:

val id: String

fun isNotary(): Boolean

)

Boolean

fun parse(id: String):

val regulator:

interface StateMachineRecordedTransactionMappingStorage

Module Contents

abstract fun addMapping(stateMachineRunId:

transactionId

)

Unit

data class StateMachineTransactionMapping

Module Contents

StateMachineTransactionMapping(stateMachineRunId:

transactionId

)

val stateMachineRunId:

val transactionId:

abstract val attachments:

interface StorageService

Module Contents

abstract val stateMachineRecordedTransactionMapping:

fun isValid(timestampCommand:

class TimestampChecker

Module Contents

TimestampChecker(clock:

tolerance

)

)

Boolean

val tolerance:

interface TransactionStorage :

abstract fun addTransaction(transaction:

Module Contents

interface TxWritableStorageService :

)

Unit

Module Contents

class UniquenessException :

UniquenessException(error:

Module Contents

)

interface UniquenessProvider

Module Contents

data class Conflict

Module Contents

Conflict(stateHistory: Map<

)

val stateHistory: Map<

data class ConsumingTx

Module Contents

ConsumingTx(id:

abstract fun commit(states: List<

inputIndex

Int

requestingParty

)

txId

callerIdentity

)

Unit

class Vault

Module Contents

Vault(states: Iterable<

)

Module Contents

Update(consumed: Set<

produced

Set

)

operator fun plus(rhs:

)

val states: Iterable<

statesOfType

(

)

List

abstract val currentVault:

interface VaultService

Module Contents

abstract val linearHeads: Map<

linearHeadsOfType_

(

stateType

abstract fun notifyAll(txns: Iterable<

)

Map

)

)

open fun statesForRefs(refs: List<

)

Map

abstract fun track(): <ERROR CLASS><

open fun whenConsumed(ref:

)

dealsWith

(

party

)

Module Contents

containsType

(

type

)

package com.r3corda.core.protocols

linearHeadsOfType

(

)

Module Contents

data class AppContext

Module Contents

AppContext(attachments: List<

)

val classLoader:

class IllegalProtocolLogicException :

IllegalArgumentException

Module Contents

IllegalProtocolLogicException(type:

abstract class ProtocolLogic<out T>

msg

String

)

Module Contents

ProtocolLogic()

abstract fun call(): T

)

lateinit var psm:

inline fun <reified T : Any> receive(otherParty:

)

inline fun <reified T : Any> sendAndReceive(otherParty:

receiveType

)

payload

Any

)

Unit

payload

Any

)

fun <R> subProtocol(subLogic:

payload

Any

receiveType

)

fun track(): <ERROR CLASS><String, <ERROR CLASS><String>>?

shareParentSessions

Boolean

)

data class ProtocolLogicRef

Module Contents

val appContext:

AppContext

class ProtocolLogicRefFactory :

ProtocolLogicRefFactory()

Module Contents

ProtocolLogicRefFactory(protocolWhitelist: Map<String, Set<String>>)

fun create(type:

out

vararg

args

Any

)

fun createKotlin(protocolLogicClassName: String, args: Map<String, Any?>, attachments: List<

)

fun createKotlin(type:

out

args

Map

String

Any

)

fun toProtocolLogic(ref:

)

class ProtocolSessionException :

ProtocolSessionException(message: String)

Module Contents

interface ProtocolStateMachine<R>

Module Contents

abstract val logger: <ERROR CLASS>

abstract fun <T : Any> receive(otherParty:

receiveType

sessionProtocol

)

abstract val resultFuture: <ERROR CLASS><R>

abstract fun send(otherParty:

payload

Any

sessionProtocol

abstract fun <T : Any> sendAndReceive(otherParty:

)

Unit

payload

Any

receiveType

sessionProtocol

)

abstract val serviceHub:

data class StateMachineRunId

Module Contents

fun createRandom():

val uuid:

package com.r3corda.core.schemas

Module Contents

abstract class MappedSchema

Module Contents

MappedSchema(schemaFamily:

version

Int

mappedTypes

Iterable

val mappedTypes: Iterable<

)

open class PersistentState

Module Contents

PersistentState(stateRef:

)

var stateRef:

data class PersistentStateRef :

Serializable

Module Contents

PersistentStateRef(stateRef:

PersistentStateRef(txId: String?, index: Int?)

)

PersistentStateRef()

var index: Int?

var txId: String?

interface QueryableState :

abstract fun generateMappedObject(schema:

Module Contents

)

abstract fun supportedSchemas(): Iterable<

package com.r3corda.core.serialization

Module Contents

val ATTACHMENT_STORAGE: String

interface DeserializeAsKotlinObjectDef

object Ed25519PrivateKeySerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: <ERROR CLASS>): Unit

)

object Ed25519PublicKeySerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: <ERROR CLASS>): Unit

)

class ImmutableClassSerializer<T : Any>

Module Contents

ImmutableClassSerializer(klass: KClass<T>)

val constructor: <ERROR CLASS>

val klass: KClass<T>

val props: <ERROR CLASS>

val propsByName: <ERROR CLASS>

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: T): Unit

)

object KotlinObjectSerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

)

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj:

class MissingAttachmentsException :

)

Unit

MissingAttachmentsException(ids: List<

Module Contents

)

val ids: List<

class NoReferencesSerializer<T>

Module Contents

NoReferencesSerializer(baseSerializer: <ERROR CLASS><T>)

val baseSerializer: <ERROR CLASS><T>

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: T): Unit

)

open class OpaqueBytes

Module Contents

OpaqueBytes(bits: ByteArray)

val bits: ByteArray

fun of(vararg b: Byte):

object ReferencesAwareJavaSerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: Any): Unit

Any

)

Any

interface SerializationToken

Module Contents

abstract fun fromToken(context:

interface SerializeAsToken

)

Any

Module Contents

abstract fun toToken(context:

)

class SerializeAsTokenContext

Module Contents

SerializeAsTokenContext(toBeTokenized: Any, kryo: <ERROR CLASS> = createKryo())

class SerializeAsTokenSerializer<T :

SerializeAsTokenSerializer()

Module Contents

fun clearContext(kryo: <ERROR CLASS>): Unit

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

fun setContext(kryo: <ERROR CLASS>, context:

)

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj: T): Unit

)

Unit

class SerializedBytes<T : Any> :

SerializedBytes(bits: ByteArray)

Module Contents

fun writeToFile(path:

)

object SerializedBytesSerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

Any

)

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj:

Any

data class SingletonSerializationToken :

Any

)

Unit

SingletonSerializationToken(toBeTokenized:

Module Contents

)

fun fromToken(context:

fun registerWithContext(token:

)

Any

SingletonSerializationToken

toBeTokenized

context

)

abstract class SingletonSerializeAsToken :

SingletonSerializeAsToken()

Module Contents

open fun toToken(context:

)

val THREAD_LOCAL_KRYO: <ERROR CLASS>

object WireTransactionSerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

)

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj:

var <ERROR CLASS>.attachmentStorage:

)

Unit

fun createKryo(k: <ERROR CLASS> = Kryo()): <ERROR CLASS>

fun <T : Any>

deserialize

(

kryo

)

deserialize

(

kryo

)

fun <T : Any>

deserialize

(

kryo

)

fun <T : Any> ByteArray.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): T

Module Contents

fun ByteArray.opaque():

fun ByteArray.toHexString(): <ERROR CLASS>

fun String.parseAsHex(): <ERROR CLASS>

Module Contents

inline fun <reified T : Any> <ERROR CLASS>.noReferencesWithin(): Unit

fun <ERROR CLASS>.readBytesWithLength(): ByteArray

fun <T : Any> T.serialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()):

inline fun <T> <ERROR CLASS>.useClassLoader(cl:

fun <ERROR CLASS>.writeBytesWithLength(byteArray: ByteArray): Unit

body

(

)

package com.r3corda.core.testing

Module Contents

class AmountGenerator<T>

Module Contents

AmountGenerator(tokenGenerator: <ERROR CLASS><T>)

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

val tokenGenerator: <ERROR CLASS><T>

class CurrencyGenerator

Module Contents

CurrencyGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class DurationGenerator

Module Contents

DurationGenerator()

open class InMemoryVaultService :

InMemoryVaultService(services:

Module Contents

protected class InnerState

)

Module Contents

InnerState()

val _updatesPublisher: <ERROR CLASS>

var vault:

open val currentVault:

open val linearHeads: Map<

protected open val log: <ERROR CLASS>

protected val mutex:

open fun notifyAll(txns: Iterable<

InnerState

)

protected val services:

open fun track(): <ERROR CLASS><

open val updates: <ERROR CLASS><

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class InstantGenerator

Module Contents

InstantGenerator()

IssuedGenerator(productGenerator: <ERROR CLASS><T>)

class IssuedGenerator<T>

Module Contents

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

val productGenerator: <ERROR CLASS><T>

class PartyAndReferenceGenerator

Module Contents

PartyAndReferenceGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class PartyGenerator

Module Contents

PartyGenerator()

class PrivateKeyGenerator

Module Contents

PrivateKeyGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class PublicKeyGenerator

Module Contents

PublicKeyGenerator()

class SecureHashGenerator

Module Contents

SecureHashGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class StateRefGenerator

Module Contents

StateRefGenerator()

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

class TimestampGenerator

Module Contents

TimestampGenerator()

class TransactionStateGenerator<T :

TransactionStateGenerator(stateGenerator: <ERROR CLASS><T>)

Module Contents

fun generate(random: <ERROR CLASS>, status: <ERROR CLASS>):

val stateGenerator: <ERROR CLASS><T>

fun <A> <ERROR CLASS><A>.generateList(random: <ERROR CLASS>, status: <ERROR CLASS>): List<A>

package com.r3corda.core.transactions

Module Contents

abstract class BaseTransaction :

BaseTransaction(inputs: List<*>, outputs: List<

Module Contents

notary

mustSign

List

type

timestamp

protected fun checkInvariants(): Unit

)

class LedgerTransaction :

open val inputs: List<*>

LedgerTransaction(inputs: List<

Module Contents

outputs

List

commands

List

attachments

List

notary

signers

List

timestamp

type

)

outRef

(

index

Int

)

fun toTransactionForContract():

data class SignedTransaction :

fun verify(): Unit

SignedTransaction(txBits:

Module Contents

sigs

List

class SignaturesMissingException :

)

SignaturesMissingException(missing: Set<

SignatureException

Module Contents

descriptions

List

String

val descriptions: List<String>

)

fun checkSignaturesAreValid(): Unit

operator fun plus(sig:

)

operator fun plus(sigList: Collection<

)

fun verifySignatures(vararg allowedToBeMissing:

)

)

fun withAdditionalSignature(sig:

)

fun withAdditionalSignatures(sigList: Iterable<

)

open class TransactionBuilder

Module Contents

TransactionBuilder(type:

notary

inputs

MutableList

attachments

MutableList

outputs

MutableList

commands

MutableList

signers

MutableSet

timestamp

fun addAttachment(attachmentId:

)

)

Unit

fun addCommand(arg:

)

Unit

vararg

keys

)

keys

List

open fun addInputState(stateAndRef:

)

Unit

)

Unit

)

Int

notary

)

Int

fun addSignatureUnchecked(sig:

)

Int

)

fun attachments(): List<

protected val attachments: MutableList<

fun checkAndAddSignature(sig:

)

Unit

fun checkSignature(sig:

)

Unit

fun commands(): List<

protected val commands: MutableList<

fun copy():

protected val currentSigs: <ERROR CLASS>

fun inputStates(): List<

protected val inputs: MutableList<

var notary:

fun outputStates(): List<

protected val outputs: MutableList<

timeTolerance

)

Unit

fun setTime(newTimestamp:

)

Unit

fun signWith(key:

)

protected val signers: MutableSet<

val time:

protected var timestamp:

fun toSignedTransaction(checkSufficientSignatures: Boolean = true):

fun toWireTransaction():

protected val type:

fun withItems(vararg items: Any):

class WireTransaction :

WireTransaction(inputs: List<

Module Contents

attachments

List

outputs

List

commands

List

notary

signers

List

type

timestamp

)

val commands: List<

fun deserialize(bits:

kryo

)

outRef

(

index

Int

)

outRef

(

state

)

)

package com.r3corda.core.utilities

Module Contents

val DUMMY_NOTARY_KEY:

Module Contents

const val CODE_BAG_OF_CASH: String

const val CODE_DIAMOND: String

const val CODE_GREEN_TICK: String

const val CODE_LEFT_ARROW: String

const val CODE_NEWSPAPER: String

const val CODE_PAPERCLIP: String

const val CODE_RIGHT_ARROW: String

val bagOfCash: String

val diamond: String

val hasEmojiTerminal: <ERROR CLASS>

val leftArrow: String

val newspaper: String

val paperclip: String

fun renderIfSupported(obj: Any): String

val rightArrow: String

object LogHelper

Module Contents

fun reset(vararg names: String): Unit

fun reset(vararg classes: KClass<*>): <ERROR CLASS>

fun setLevel(vararg loggerNames: String): Unit

fun setLevel(vararg classes: KClass<*>): <ERROR CLASS>

class NonEmptySet<T> : MutableSet<T>

Module Contents

NonEmptySet(initial: T)

inner class Iterator<out T, T> : MutableIterator<T>

Module Contents

Iterator(iterator: MutableIterator<T>)

fun hasNext(): Boolean

val iterator: MutableIterator<T>

fun next(): T

fun remove(): Unit

fun add(element: T): Boolean

fun addAll(elements: Collection<T>): Boolean

fun clear(): Nothing

fun contains(element: T): Boolean

fun containsAll(elements: Collection<T>): Boolean

fun iterator(): MutableIterator<T>

fun isEmpty(): Boolean

fun remove(element: T): Boolean

fun removeAll(elements: Collection<T>): Boolean

fun retainAll(elements: Collection<T>): Boolean

object NonEmptySetSerializer

Module Contents

fun read(kryo: <ERROR CLASS>, input: <ERROR CLASS>, type:

Any

)

fun write(kryo: <ERROR CLASS>, output: <ERROR CLASS>, obj:

Any

ProgressTracker(vararg steps:

Any

)

Unit

class ProgressTracker

Module Contents

)

Module Contents

Module Contents

newStep

)

Module Contents

ofStep

)

Module Contents

parent

)

Module Contents

inner class RelabelableStep :

RelabelableStep(currentLabel: String)

Module Contents

open val changes: <ERROR CLASS>

var currentLabel: String

open val changes: <ERROR CLASS><

class Step

Module Contents

Step(label: String)

open fun childProgressTracker():

object UNSTARTED :

Module Contents

val allSteps: List<<ERROR CLASS><Int,

var currentStep:

val currentStepRecursive:

fun getChildProgressTracker(step:

)

fun setChildProgressTracker(step:

childProgressTracker

class UntrustworthyData<out T>

)

Unit

data class TimeWindow

Module Contents

duration

)

Module Contents

UntrustworthyData(fromUntrustedWorld: T)

val data: T

inline fun <R> unwrap(validator: (T) -> R): R

inline fun <R> ~~validate~~(validator: (T) -> R): R

inline fun <ERROR CLASS>.debug(msg: () -> String): Unit

inline fun <reified T : Any> loggerFor(): <ERROR CLASS>

fun <T> nonEmptySetOf(initial: T, vararg elements: T):

fun suggestInterestRateAnnouncementTimeWindow(index: String, source: String, date:

inline fun <ERROR CLASS>.trace(msg: () -> String): Unit

)

TimeWindow

package com.r3corda.demos

Module Contents

sealed class CliParams

Module Contents

class DateChange :

DateChange(apiAddress: <ERROR CLASS>, dateString: String)

Module Contents

val dateString: String

Module Contents

dir

networkAddress

apiAddress

mapAddress

String

tradeWithIdentities

List

uploadRates

Boolean

defaultLegalName

String

autoSetup

Boolean

h2Port

Int

)

val autoSetup: Boolean

val dir:

val networkAddress: <ERROR CLASS>

val h2Port: Int

val mapAddress: String

val tradeWithIdentities: List<

val uploadRates: Boolean

Module Contents

dir

defaultLegalName

String

)

Trade(apiAddress: <ERROR CLASS>, tradeId: String)

Module Contents

val tradeId: String

class UploadRates :

UploadRates(apiAddress: <ERROR CLASS>)

Module Contents

val defaultBaseDirectory: String

fun legalName(node:

fun parse(options: <ERROR CLASS>):

)

String

val apiAddressArg: <ERROR CLASS>

object CliParamsSpec

Module Contents

val fakeTradeWithIdentityFile: <ERROR CLASS>

val h2PortArg: <ERROR CLASS>

val help: <ERROR CLASS>

val networkAddressArg: <ERROR CLASS>

val networkMapNetAddr: <ERROR CLASS>

val nonOptions: <ERROR CLASS>

val roleArg: <ERROR CLASS>

val DEFAULT_BASE_DIRECTORY: String

class DemoClock :

MutableClock

Module Contents

DemoClock(delegateClock:

)

)

fun updateDate(date:

)

Boolean

fun withZone(zone:

ZoneId

)

class IRSDemoPluginRegistry :

enum class IRSDemoNode

Module Contents

Module Contents

IRSDemoPluginRegistry()

val staticServeDirs: Map<String, String>

val webApis: List<

enum class IRSDemoRole

Module Contents

Module Contents

fun runIRSDemo(args: Array<String>): Int

fun runUploadRates(cliParams:

UploadRates

)

package com.r3corda.demos.api

Module Contents

class InterestRateSwapAPI

Module Contents

InterestRateSwapAPI(services:

fun exitServer(): <ERROR CLASS>

)

fun fetchDeal(ref: String): <ERROR CLASS>

fun fetchDeals(): Array<

fun storeDeal(newDeal:

fun storeDemoDate(newDemoDate:

)

)

object NodeInterestRates

Module Contents

class FixContainer

Module Contents

FixContainer(fixes: Set<

factory

)

operator fun get(fixOf:

)

class InterpolatingRateMap

Module Contents

InterpolatingRateMap(date:

inputRates

Map

calendar

factory

)

)

Module Contents

signingKey

clock

)

fun query(queries: List<

deadline

)

List

)

Module Contents

Module Contents

)

fun parseFile(s: String):

)

String

Module Contents

)

FixContainer

fun parseFix(s: String):

fun parseFixOf(key: String):

package com.r3corda.demos.attachment

Module Contents

val DEFAULT_BASE_DIRECTORY: String

val PROSPECTUS_HASH: <ERROR CLASS>

enum class Role

Module Contents

RECIPIENT

SENDER

val legalName: String

val other:

Role

val port: Int

package com.r3corda.demos.protocols

Module Contents

object AutoOfferProtocol

Module Contents

Module Contents

Requester(dealToBeOffered:

Module Contents

)

object DEALING :

Module Contents

Module Contents

)

Module Contents

object ExitServerProtocol

Module Contents

ExitMessage(exitCode: Int)

Boolean

Module Contents

Broadcast(exitCode: Int)

fun call(): Boolean

val exitCode: Int

data class ExitMessage

Module Contents

Module Contents

object UpdateBusinessDayProtocol

Module Contents

)

Module Contents

Unit

Module Contents

progressTracker

)

Module Contents

data class UpdateBusinessDayMessage

Module Contents

)

Module Contents

UpdateBusinessDayMessage(date:

)

val date:

package com.r3corda.demos.utilities

Module Contents

fun postJson(url:

data

String

)

Boolean

fun putJson(url:

data

String

)

Boolean

fun uploadFile(url:

file

String

)

Boolean

package com.r3corda.node

Module Contents

object ParamsSpec

Module Contents

package com.r3corda.node.api

Module Contents

interface APIServer

Module Contents

abstract fun buildTransaction(type:

steps

List

)

abstract fun commitTransaction(tx:

signatures

List

)

abstract fun fetchProtocolsRequiringAttention(query:

)

Map

abstract fun fetchStates(states: List<

)

Map

abstract fun fetchTransactions(txs: List<

)

Map

abstract fun generateTransactionSignature(tx:

)

abstract fun invokeProtocolSync(type:

abstract fun provideProtocolResponse(protocol:

args

Map

String

Any

)

Any

choice

abstract fun queryStates(query:

args

Map

String

Any

)

Unit

)

List

abstract fun serverTime():

abstract fun status(): <ERROR CLASS>

data class ContractClassRef :

ContractClassRef(className: String)

Module Contents

data class ContractLedgerRef :

interface ContractDefRef

Module Contents

ContractLedgerRef(hash:

)

data class ProtocolClassRef :

ProtocolClassRef(className: String)

Module Contents

data class ProtocolInstanceRef

Module Contents

ProtocolInstanceRef(protocolInstance:

protocolClass

protocolStepId

String

)

val protocolClass:

val protocolInstance:

val protocolStepId: String

interface ProtocolRef

data class ProtocolRequiringAttention

Module Contents

ProtocolRequiringAttention(ref:

prompt

String

choiceIdsToMessages

Map

String

dueBy

val choiceIdsToMessages: Map<

)

String

interface StatesQuery

Module Contents

Module Contents

Module Contents

data class Selection :

Module Contents

)

)

data class TransactionBuildStep

Module Contents

TransactionBuildStep(generateMethodName: String, args: Map<String, Any?>)

val generateMethodName: String

package com.r3corda.node.driver

Module Contents

class DriverDSL :

DriverDSLInternalInterface

Module Contents

DriverDSL(portAllocation:

debugPortAllocation

baseDirectory

String

isDebug

Boolean

)

Module Contents

val registeredProcesses:

LinkedList

val baseDirectory: String

val debugPortAllocation:

fun <A> pickA(array: Array<A>): A

val isDebug: Boolean

val name: Array<String>

val networkMapCache:

InMemoryNetworkMapCache

val portAllocation:

fun registerProcess(process:

)

Unit

fun shutdown(): Unit

fun startClient(providedName: String, serverAddress: <ERROR CLASS>):

fun startLocalServer():

fun startNode(providedName: String?, advertisedServices: Set<

)

fun waitForAllNodesToFinish(): Unit

interface DriverDSLExposedInterface

Module Contents

abstract fun startClient(providedName: String, serverAddress: <ERROR CLASS>):

abstract fun startLocalServer():

abstract fun startNode(providedName: String? = null, advertisedServices: Set<

)

abstract fun waitForAllNodesToFinish(): Unit

interface DriverDSLInternalInterface :

abstract fun shutdown(): Unit

Module Contents

abstract fun start(): Unit

sealed class PortAllocation

Module Contents

class Incremental :

Incremental(portCounter: Int)

Module Contents

Module Contents

fun nextHostAndPort(): <ERROR CLASS>

abstract fun nextPort(): Int

fun addressMustBeBound(hostAndPort: <ERROR CLASS>): Unit

fun addressMustNotBeBound(hostAndPort: <ERROR CLASS>): Unit

fun <A> driver(baseDirectory: String = "build/${getTimestampAsDirectoryName()}", portAllocation:

debugPortAllocation

isDebug

Boolean

dsl

(

)

fun <DI :

DriverDSLInternalInterface

genericDriver

(

driverDsl

coerce

(

)

dsl

(

)

fun <A> poll(pollName: String, pollIntervalMs: Long = 500, warnCount: Int = 120, f: () -> A?): A

startClient

(

localServer

)

startClient

(

remoteNodeInfo

providedName

String

)

fun writeConfig(path:

package com.r3corda.node.internal

filename

String

config

)

Unit

Module Contents

class APIServerImpl :

Module Contents

APIServerImpl(node:

fun buildTransaction(type:

)

steps

List

)

fun commitTransaction(tx:

signatures

List

)

fun fetchProtocolsRequiringAttention(query:

)

Map

fun fetchStates(states: List<

)

Map

fun fetchTransactions(txs: List<

)

Map

fun generateTransactionSignature(tx:

)

fun invokeProtocolSync(type:

args

Map

String

Any

)

Any

fun provideProtocolResponse(protocol:

choice

args

Map

String

Any

)

Unit

fun queryStates(query:

)

List

fun serverTime():

fun status(): <ERROR CLASS>

abstract class AbstractNode :

AbstractNode(configuration:

Module Contents

networkMapService

advertisedServices

Set

platformClock

class DatabaseConfigurationException :

)

DatabaseConfigurationException(msg: String)

Module Contents

val PRIVATE_KEY_FILE_NAME: String

val PUBLIC_IDENTITY_FILE_NAME: String

protected val _servicesThatAcceptUploads:

val advertisedServices: Set<

lateinit var api:

lateinit var checkpointStorage:

open val configuration:

protected open fun constructStorageService(attachments:

transactionStorage

stateMachineRecordedTransactionMappingStorage

protected fun createNodeDir(): Unit

)

StorageServiceImpl

val customServices:

lateinit var database: <ERROR CLASS>

Any

protected var dbCloser:

inline fun <reified T : Any> findService(): <ERROR CLASS>

protected open fun generateKeyPair():

lateinit var identity:

var inNodeNetworkMapService:

var inNodeNotaryService:

val info:

protected open fun initialiseCheckpointService(dir:

)

protected open fun initialiseDatabasePersistence(insideTransaction: () -> Unit): Unit

protected open fun initialiseStorageService(dir:

)

var isPreviousCheckpointsPresent: Boolean

lateinit var keyManagement:

protected abstract val log: <ERROR CLASS>

protected fun makeAttachmentStorage(dir:

)

protected open fun makeIdentityService():

protected open fun makeKeyManagementService():

protected abstract fun makeMessagingService():

protected open fun makeNetworkMapService(): Unit

protected open fun makeNotaryService(type:

)

protected open fun makeSchemaService():

protected abstract fun makeUniquenessProvider():

protected open fun makeVaultService():

lateinit var net:

lateinit var netMapCache:

val networkMapRegistrationFuture: <ERROR CLASS><Unit>

var networkMapSeq: Long

val networkMapService:

protected open fun noNetworkMapConfigured(): <ERROR CLASS><Unit>

protected fun obtainLegalIdentity():

protected fun obtainLegalIdentityKey():

protected val partyKeys: <ERROR CLASS>

val platformClock:

protected val pluginRegistries: List<

lateinit var protocolLogicFactory:

protected val runOnStop:

lateinit var scheduler:

lateinit var schemas:

protected abstract val serverThread:

val servicesThatAcceptUploads: List<

protected abstract fun startMessagingService(cordaRPCOps:

)

Unit

var started: Boolean

open fun stop(): Unit

lateinit var storage:

var uniquenessProvider:

lateinit var vault:

class ConfigurationException :

ConfigurationException(message: String)

Module Contents

class Node :

Module Contents

Node(configuration:

networkMapAddress

advertisedServices

Set

clock

)

val DEFAULT_PORT: Int

val configuration:

protected fun initialiseDatabasePersistence(insideTransaction: () -> Unit): Unit

protected fun makeMessagingService():

protected fun makeUniquenessProvider():

PersistentUniquenessProvider

var messageBroker:

protected val serverThread:

fun run(): Unit

ServiceAffinityExecutor

protected fun startMessagingService(cordaRPCOps:

)

Unit

lateinit var webServer: <ERROR CLASS>

class ServerRPCOps :

Module Contents

ServerRPCOps(services:

smm

class InputStateRefResolveFailed :

database

)

InputStateRefResolveFailed(stateRefs: List<

Module Contents

)

fun executeCommand(command:

)

fun stateMachineRecordedTransactionMapping(): <ERROR CLASS><List<

val protocolVersion: Int

fun stateMachinesAndUpdates(): <ERROR CLASS><List<

fun vaultAndUpdates(): <ERROR CLASS><List<

fun verifiedTransactions(): <ERROR CLASS><List<

package com.r3corda.node.serialization

Module Contents

class NodeClock :

Module Contents

NodeClock(delegateClock:

)

package com.r3corda.node.services

)

)

Module Contents

Module Contents

Module Contents

Module Contents

package com.r3corda.node.services.api

)

Module Contents

abstract class AbstractNodeService :

AbstractNodeService(services:

Module Contents

)

reified

Any

addMessageHandler

(

topic

String

crossinline

handler

(

)

crossinline

exceptionConsumer

(

)

Unit

)

reified

Any

addMessageHandler

(

topic

String

crossinline

handler

(

)

val net:

interface AcceptsFileUpload

Module Contents

abstract val acceptableFileExtensions: List<String>

abstract val dataTypePrefix: String

abstract fun upload(data:

Checkpoint(serializedFiber:

)

String

class Checkpoint

Module Contents

)

interface CheckpointStorage

Module Contents

abstract fun addCheckpoint(checkpoint:

abstract fun forEach(block: (

)

Unit

abstract fun removeCheckpoint(checkpoint:

)

Boolean

)

Unit

interface MessagingServiceBuilder<out T :

)

Unit

abstract fun start(): <ERROR CLASS><out T>

Module Contents

interface MessagingServiceInternal :

abstract fun stop(): Unit

Module Contents

class MonitoringService :

MonitoringService(metrics: <ERROR CLASS>)

Module Contents

val metrics: <ERROR CLASS>

interface RegulatorService

Module Contents

SchemaOptions(databaseSchema: String?, tablePrefix: String?)

interface SchemaService

Module Contents

data class SchemaOptions

Module Contents

val databaseSchema: String?

val tablePrefix: String?

abstract fun generateMappedObject(state:

schema

)

abstract val schemaOptions: Map<

abstract fun selectSchemas(state:

)

Iterable

abstract class ServiceHubInternal :

abstract fun getProtocolFactory(markerClass:

Module Contents

ServiceHubInternal()

)

(

)

open fun <T : Any> invokeProtocolAsync(logicType:

out

abstract val monitoringService:

vararg

args

Any

)

MonitoringService

abstract val protocolLogicRefFactory:

abstract fun registerProtocolInitiator(markerClass: KClass<*>, protocolFactory: (

)

abstract val schemaService:

)

Unit

abstract fun <T> startProtocol(logic:

package com.r3corda.node.services.clientapi

)

Module Contents

object FixingSessionInitiation

Module Contents

Module Contents

Module Contents

package com.r3corda.node.services.config

)

Module Contents

object ConfigHelper

Module Contents

fun loadConfig(baseDirectoryPath:

configFileOverride

allowMissingConfig

Boolean

configOverrides

Map

String

Any

)

class FullNodeConfiguration :

FullNodeConfiguration(config: <ERROR CLASS>)

Module Contents

val artemisAddress: <ERROR CLASS>

val dataSourceProperties:

val extraAdvertisedServiceIds: String

val devMode: Boolean

val emailAddress: String

val exportJMXto: String

val keyStorePassword: String

val messagingServerAddress: <ERROR CLASS>?

val myLegalName: String

val nearestCity: String

val networkMapAddress: <ERROR CLASS>?

val trustStorePassword: String

val useHTTPS: Boolean

val webAddress: <ERROR CLASS>

interface NodeConfiguration :

Module Contents

abstract val basedir:

open val certificatesPath:

open val dataSourceProperties:

abstract val devMode: Boolean

abstract val emailAddress: String

abstract val exportJMXto: String

abstract val myLegalName: String

abstract val nearestCity: String

interface NodeSSLConfiguration

Module Contents

abstract val certificatesPath:

abstract val keyStorePassword: String

open val keyStorePath:

abstract val trustStorePassword: String

open val trustStorePath:

class OptionalConfig<out T>

Module Contents

OptionalConfig(conf: <ERROR CLASS>, lambda: () -> T)

val conf: <ERROR CLASS>

operator fun getValue(receiver: Any, metadata: KProperty<*>): T

val lambda: () -> T

fun <T> <ERROR CLASS>.getOrElse(lambda: () -> T):

configureWithDevSSLCertificate

(

)

Unit

OptionalConfig

fun <ERROR CLASS>.getProperties(path: String):

operator fun <T> <ERROR CLASS>.getValue(receiver: Any, metadata: KProperty<*>): T

package com.r3corda.node.services.events

Module Contents

class NodeSchedulerService :

NodeSchedulerService(services:

Module Contents

protocolLogicRefFactory

schedulerTimerExecutor

fun scheduleStateActivity(action:

)

fun unscheduleStateActivity(ref:

)

Unit

class ScheduledActivityObserver

)

Unit

Module Contents

ScheduledActivityObserver(services:

)

package com.r3corda.node.services.identity

Module Contents

class InMemoryIdentityService :

InMemoryIdentityService()

Module Contents

fun partyFromKey(key:

)

fun partyFromName(name: String):

fun registerIdentity(party:

package com.r3corda.node.services.keys

)

Unit

Module Contents

class E2ETestKeyManagementService :

E2ETestKeyManagementService(initialKeys: Set<

Module Contents

)

class PersistentKeyManagementService :

PersistentKeyManagementService(initialKeys: Set<

Module Contents

)

package com.r3corda.node.services.messaging

Module Contents

abstract class ArtemisMessagingComponent :

ArtemisMessagingComponent(config:

Module Contents

protected interface ArtemisAddress

)

Module Contents

abstract val hostAndPort: <ERROR CLASS>

abstract val queueName: <ERROR CLASS>

const val CLIENTS_PREFIX: String

protected enum class ConnectionDirection

Module Contents

INBOUND

OUTBOUND

protected val NETWORK_MAP_ADDRESS: <ERROR CLASS>

protected data class NetworkMapAddress :

NetworkMapAddress(hostAndPort: <ERROR CLASS>)

Module Contents

data class NodeAddress :

Module Contents

NodeAddress(identity:

hostAndPort

)

const val PEERS_PREFIX: String

const val RPC_REQUESTS_QUEUE: String

fun checkStorePasswords(): Unit

fun configureWithDevSSLCertificate(): Unit

protected fun parseKeyFromQueueName(name: String):

protected fun tcpTransport(direction:

ConnectionDirection

host

String

port

Int

)

fun toHostAndPort(target:

protected fun toQueueName(target:

)

class ArtemisMessagingServer :

)

ArtemisMessagingServer(config:

Module Contents

myHostPort

networkMapCache

fun bridgeToNetworkMapService(networkMapService:

)

)

Unit

val myHostPort: <ERROR CLASS>

data class ClientRPCRequestMessage

Module Contents

ClientRPCRequestMessage(args:

const val METHOD_NAME: String

Array

Any

replyToAddress

String

observationsToAddress

String

methodName

String

)

const val OBSERVATIONS_TO: String

const val REPLY_TO: String

val args:

val observationsToAddress: String?

Array

Any

val methodName: String

val replyToAddress: String

interface CordaRPCOps :

RPCOps

Module Contents

abstract fun executeCommand(command:

)

@RPCReturnsObservables abstract fun stateMachineRecordedTransactionMapping(): <ERROR CLASS><List<

@RPCReturnsObservables abstract fun stateMachinesAndUpdates(): <ERROR CLASS><List<

@RPCReturnsObservables abstract fun vaultAndUpdates(): <ERROR CLASS><List<

@RPCReturnsObservables abstract fun verifiedTransactions(): <ERROR CLASS><List<

data class MarshalledObservation

Module Contents

MarshalledObservation(forHandle: Int, what: <ERROR CLASS><out <ERROR CLASS>>)

val forHandle: Int

val what: <ERROR CLASS><out <ERROR CLASS>>

class NodeMessagingClient :

NodeMessagingClient(config:

Module Contents

serverHostPort

myIdentity

executor

persistentInbox

Boolean

persistenceTx

(

)

Unit

)

Unit

)

data class Handler :

Module Contents

Handler(executor:

topicSession

callback

(

)

Unit

)

val callback: (

val SESSION_ID_PROPERTY: String

)

Unit

val TOPIC_PROPERTY: String

fun addMessageHandler(topic: String, sessionID: Long, executor:

callback

(

)

Unit

)

fun addMessageHandler(topicSession:

executor

callback

(

)

Unit

)

fun createMessage(topicSession:

data

ByteArray

uuid

)

fun makeNetworkMapAddress(hostAndPort: <ERROR CLASS>):

val myAddress:

val myIdentity:

val persistenceTx: (() -> Unit) -> Unit

val persistentInbox: Boolean

fun removeMessageHandler(registration:

val serverHostPort: <ERROR CLASS>

)

Unit

target

)

Unit

fun start(rpcOps:

)

Unit

abstract class RPCDispatcher

Module Contents

RPCDispatcher(target: Any)

fun dispatch(msg:

ClientRPCRequestMessage

)

Unit

abstract fun send(bits:

fun start(rpcConsumer: <ERROR CLASS>, rpcNotificationConsumer: <ERROR CLASS>?, onExecutor:

toAddress

String

)

Unit

open class RPCException :

)

Unit

val target: Any

RuntimeException

Module Contents

RPCException(msg: String)

RPCException(msg: String, cause: Throwable?)

class DeadlineExceeded :

RPCException

Module Contents

DeadlineExceeded(rpcName: String)

interface RPCOps

Module Contents

abstract val protocolVersion: Int

@Target([AnnotationTarget.FUNCTION]) annotation class RPCReturnsObservables

Module Contents

RPCReturnsObservables()

@Target([AnnotationTarget.FUNCTION]) annotation class RPCSinceVersion

Module Contents

RPCSinceVersion(version: Int)

data class StateMachineInfo

Module Contents

StateMachineInfo(id:

fun fromProtocolStateMachineImpl(psm:

protocolLogicClassName

String

progressTrackerStepAndUpdates

String

String

)

)

val progressTrackerStepAndUpdates: <ERROR CLASS><String, <ERROR CLASS><String>>?

sealed class StateMachineUpdate

Module Contents

Module Contents

Added(stateMachineInfo:

fun fromStateMachineChange(change:

)

val stateMachineInfo:

Module Contents

)

)

sealed class TransactionBuildResult

Module Contents

Module Contents

class ProtocolStarted :

Module Contents

ProtocolStarted(id:

transaction

message

String

)

fun createRPCKryo(observableSerializer: <ERROR CLASS><<ERROR CLASS><Any>>? = null): <ERROR CLASS>

val rpcLog: <ERROR CLASS>

fun <ERROR CLASS>.toRPCRequestMessage():

ClientRPCRequestMessage

package com.r3corda.node.services.network

Module Contents

abstract class AbstractNetworkMapService :

AbstractNetworkMapService(services:

AbstractNodeService

Module Contents

protected val _mapVersion:

)

AtomicInteger

fun getUnacknowledgedCount(subscriber:

mapVersion

Int

)

Int

val maxSizeRegistrationRequestBytes: Int

val maxUnacknowledgedUpdates: Int

open val nodes: List<

fun notifySubscribers(wireReg:

fun processAcknowledge(req:

mapVersion

Int

)

Unit

UpdateAcknowledge

)

Unit

fun processFetchAllRequest(req:

FetchMapRequest

)

FetchMapResponse

fun processQueryRequest(req:

QueryIdentityRequest

)

QueryIdentityResponse

fun processRegistrationChangeRequest(req:

RegistrationRequest

)

RegistrationResponse

fun processSubscriptionRequest(req:

SubscribeRequest

)

SubscribeResponse

protected abstract val registeredNodes: MutableMap<

protected fun setup(): Unit

protected abstract val subscribers:

MutableMap

fun unregisterNetworkHandlers(): Unit

open class InMemoryNetworkMapCache :

InMemoryNetworkMapCache()

Module Contents

open fun addMapService(net:

networkMapAddress

Boolean

ifChangedSinceVer

Int

)

Unit

open fun addNode(node:

open val changed: <ERROR CLASS><

)

Unit

open fun deregisterForUpdates(net:

service

open fun get(): <ERROR CLASS>

)

Unit

open fun get(serviceType:

open fun getNodeByLegalName(name: String): <ERROR CLASS>

)

open fun getNodeByPublicKey(publicKey:

open fun getRecommended(type:

)

contract

vararg

party

)

open val mapServiceRegistered: <ERROR CLASS><Unit>

open val networkMapNodes: List<

open val notaryNodes: List<

open val partyNodes: List<

fun processUpdatePush(req:

protected var registeredNodes: MutableMap<

)

Unit

open val regulators: List<

open fun removeNode(node:

open fun runWithoutMapService(): Unit

)

Unit

class InMemoryNetworkMapService :

InMemoryNetworkMapService(services:

Module Contents

)

protected val subscribers: <ERROR CLASS>

data class LastAcknowledgeInfo

Module Contents

LastAcknowledgeInfo(mapVersion: Int)

interface NetworkMapService

Module Contents

val DEFAULT_EXPIRATION_PERIOD:

Period

val FETCH_PROTOCOL_TOPIC: String

class FetchMapRequest :

FetchMapRequest(: Boolean, ifChangedSinceVersion: Int?, replyTo:

Module Contents

val ifChangedSinceVersion: Int?

sessionID

Long

)

data class FetchMapResponse

Module Contents

FetchMapResponse(nodes: Collection<

version

Int

)

val nodes: Collection<

val PUSH_ACK_PROTOCOL_TOPIC: String

val PUSH_PROTOCOL_TOPIC: String

val QUERY_PROTOCOL_TOPIC: String

class QueryIdentityRequest :

QueryIdentityRequest(identity:

Module Contents

replyTo

sessionID

Long

)

data class QueryIdentityResponse

Module Contents

QueryIdentityResponse(node:

)

val REGISTER_PROTOCOL_TOPIC: String

class RegistrationRequest :

RegistrationRequest(wireReg:

Module Contents

replyTo

sessionID

Long

)

val wireReg:

data class RegistrationResponse

Module Contents

RegistrationResponse(success: Boolean)

val success: Boolean

val SUBSCRIPTION_PROTOCOL_TOPIC: String

class SubscribeRequest :

SubscribeRequest(: Boolean, replyTo:

Module Contents

sessionID

Long

)

data class SubscribeResponse

Module Contents

SubscribeResponse(confirmed: Boolean)

val confirmed: Boolean

data class Update

Module Contents

Update(wireReg:

data class UpdateAcknowledge

mapVersion

Int

replyTo

)

Module Contents

UpdateAcknowledge(mapVersion: Int, replyTo:

)

abstract val nodes: List<

sealed class NodeMapError :

Module Contents

class InvalidSignature :

class InvalidSubscriber :

Module Contents

InvalidSignature()

class UnknownChangeType :

Module Contents

InvalidSubscriber()

Module Contents

UnknownChangeType()

class NodeRegistration

Module Contents

NodeRegistration(node:

serial

Long

type

expires

)

data class NodeRegistrationInfo

fun toWire(privateKey:

)

Module Contents

NodeRegistrationInfo(reg:

mapVersion

Int

)

val reg:

class PersistentNetworkMapService :

PersistentNetworkMapService(services:

Module Contents

)

protected val subscribers:

JDBCHashMap

class WireNodeRegistration :

SignedData

WireNodeRegistration(raw:

Module Contents

sig

protected fun verifyData(data:

)

package com.r3corda.node.services.persistence

)

Unit

Module Contents

class DBCheckpointStorage :

Module Contents

DBCheckpointStorage()

)

Unit

)

Boolean

)

Unit

)

Unit

Module Contents

Module Contents

Module Contents

class NotifyTransactionHandler :

)

NotifyTransactionHandler(otherParty:

Unit

Module Contents

)

class TransactionRejectedError :

TransactionRejectedError(msg: String)

Module Contents

class InMemoryStateMachineRecordedTransactionMappingStorage :

InMemoryStateMachineRecordedTransactionMappingStorage()

Module Contents

fun addMapping(stateMachineRunId:

transactionId

)

Unit

class NodeAttachmentService :

NodeAttachmentService(storePath:

Module Contents

class OnDiskHashMismatch :

metrics

)

Module Contents

OnDiskHashMismatch(file:

actual

)

var automaticallyExtractAttachments: Boolean

var checkAttachmentsOnLoad: Boolean

fun importAttachment(jar:

)

class PerFileCheckpointStorage :

fun openAttachment(id:

)

)

PerFileCheckpointStorage(storeDir:

Module Contents

)

)

Unit

)

Boolean

)

Unit

)

Unit

val storeDir:

class PerFileTransactionStorage :

PerFileTransactionStorage(storeDir:

Module Contents

fun addTransaction(transaction:

)

)

Unit

fun getTransaction(id:

)

val transactions: Iterable<

open class StorageServiceImpl :

StorageServiceImpl(attachments:

Module Contents

validatedTransactions

stateMachineRecordedTransactionMapping

)

open val attachments:

open val stateMachineRecordedTransactionMapping:

open val validatedTransactions:

package com.r3corda.node.services.schema

Module Contents

class HibernateObserver

Module Contents

HibernateObserver(services:

class NodeDatabaseConnectionProvider

)

Module Contents

NodeDatabaseConnectionProvider()

fun closeConnection(conn:

)

Unit

fun getConnection():

fun isUnwrappableAs(unwrapType:

fun supportsAggressiveRelease(): Boolean

)

Boolean

fun <T> unwrap(unwrapType:

)

val schemaService:

val sessionFactories:

ConcurrentHashMap

class NodeSchemaService :

fun generateMappedObject(state:

Module Contents

NodeSchemaService()

schema

)

val schemaOptions: Map<

fun selectSchemas(state:

)

Iterable

package com.r3corda.node.services.statemachine

Module Contents

interface ProtocolIORequest

Module Contents

abstract val session:

ProtocolSession

abstract val stackTraceInCaseOfProblems:

class ProtocolStateMachineImpl<R> :

ProtocolStateMachineImpl(id:

Module Contents

logic

fun currentStateMachine():

scheduler

FiberScheduler

)

val logic:

val resultFuture: <ERROR CLASS><R>

receiveType

sessionProtocol

)

fun run(): R

fun send(otherParty:

payload

Any

sessionProtocol

)

Unit

payload

Any

receiveType

sessionProtocol

)

lateinit var serviceHub:

data class ReceiveOnly<T :

Module Contents

receiveType

)

interface ReceiveRequest<T :

abstract val receiveType:

Module Contents

data class SendAndReceive<T :

SendRequest

ReceiveRequest

Module Contents

SendAndReceive(session:

message

receiveType

)

data class SendOnly :

Module Contents

message

)

interface SendRequest :

Module Contents

abstract val message:

class StackSnapshot : Throwable

Module Contents

StackSnapshot()

class StateMachineManager

Module Contents

StateMachineManager(serviceHub:

tokenizableServices

List

Any

checkpointStorage

executor

interface ExistingSessionMessage :

database

)

Module Contents

addOrRemove

)

abstract val recipientSessionId: Long

Module Contents

inner class FiberScheduler

Module Contents

FiberScheduler()

data class ProtocolSession

Module Contents

ProtocolSession(protocol:

otherParty

ourSessionId

Long

otherPartySessionId

Long

waitingForResponse

Boolean

)

val otherParty:

var otherPartySessionId: Long?

val ourSessionId: Long

val protocol:

val psm:

val receivedMessages:

ConcurrentLinkedQueue

var waitingForResponse: Boolean

data class SessionConfirm :

SessionConfirm(initiatorSessionId: Long, initiatedSessionId: Long)

Module Contents

val initiatedSessionId: Long

data class SessionData :

SessionData(recipientSessionId: Long, payload: Any)

Module Contents

val payload: Any

data class SessionEnd :

SessionEnd(recipientSessionId: Long)

Module Contents

data class SessionInit :

SessionInit(initiatorSessionId: Long, initiatorParty:

Module Contents

protocolName

String

)

val initiatorParty:

interface SessionInitResponse :

val protocolName: String

data class SessionReject :

interface SessionMessage

SessionReject(initiatorSessionId: Long, errorMessage: String)

Module Contents

val errorMessage: String

fun <T> add(logic:

)

val allStateMachines: List<

val checkpointStorage:

findStateMachines

(

protocolClass

)

List

package com.r3corda.node.services.transactions

Module Contents

class InMemoryUniquenessProvider :

InMemoryUniquenessProvider()

Module Contents

txId

callerIdentity

abstract class NotaryService :

)

Unit

Module Contents

NotaryService(services:

abstract fun createProtocol(otherParty:

)

)

class PersistentUniquenessProvider :

PersistentUniquenessProvider()

Module Contents

txId

callerIdentity

class SimpleNotaryService :

)

Unit

SimpleNotaryService(services:

Module Contents

timestampChecker

uniquenessProvider

)

)

class ValidatingNotaryService :

ValidatingNotaryService(services:

Module Contents

timestampChecker

uniquenessProvider

)

)

ValidatingNotaryProtocol

package com.r3corda.node.services.vault

Module Contents

class CashBalanceAsMetricsObserver

Module Contents

CashBalanceAsMetricsObserver(serviceHubInternal:

)

val serviceHubInternal:

class NodeVaultService :

NodeVaultService(services:

Module Contents

)

val currentVault:

val linearHeads: Map<

fun notifyAll(txns: Iterable<

)

fun track(): <ERROR CLASS><

package com.r3corda.node.servlets

Module Contents

class AttachmentDownloadServlet

Module Contents

AttachmentDownloadServlet()

fun doGet(req: <ERROR CLASS>, resp: <ERROR CLASS>): Unit

class Config

Module Contents

Config(services:

val defaultObjectMapper: <ERROR CLASS>

)

)

class DataUploadServlet

Module Contents

DataUploadServlet()

fun doPost(req: <ERROR CLASS>, resp: <ERROR CLASS>): Unit

class ResponseFilter

Module Contents

ResponseFilter()

fun filter(requestContext: <ERROR CLASS>, responseContext: <ERROR CLASS>): Unit

package com.r3corda.node.utilities

Module Contents

class ANSIProgressObserver

Module Contents

ANSIProgressObserver(smm:

)

val smm:

object ANSIProgressRenderer

Module Contents

var progressTracker:

abstract class AbstractJDBCHashMap<K : Any, V : Any, out T :

AbstractJDBCHashMap(table: T, loadOnInit: Boolean = false)

MutableMap

AbstractMap

Module Contents

protected abstract fun addKeyToInsert(insert: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit

protected abstract fun addValueToInsert(insert: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit

open fun containsValue(value: V): Boolean

open val entries: MutableSet<MutableEntry<K, V>>

open fun get(key: K): V?

protected abstract fun keyFromRow(row: <ERROR CLASS>): K

val loadOnInit: Boolean

open fun put(key: K, value: V): V?

open fun remove(key: K): V?

protected abstract fun valueFromRow(row: <ERROR CLASS>): V

val table: T

open val values: MutableCollection<V>

abstract class AbstractJDBCHashSet<K : Any, out T :

AbstractJDBCHashSet(table: T, loadOnInit: Boolean = false)

MutableSet

AbstractSet

Module Contents

open fun add(element: K): Boolean

protected abstract fun addElementToInsert(insert: <ERROR CLASS>, entry: K, finalizables: MutableList<() -> Unit>): Unit

open fun contains(element: K): Boolean

protected abstract fun elementFromRow(row: <ERROR CLASS>): K

protected val innerMap:

Unit

open fun iterator(): MutableIterator<K>

open fun remove(element: K): Boolean

interface AffinityExecutor :

protected val table: T

enum class AddOrRemove

Module Contents

ADD

REMOVE

Module Contents

class Gate :

Gate(alwaysQueue: Boolean = false)

Module Contents

fun execute(command:

)

Unit

val taskQueueSize: Int

fun waitAndRun(): Unit

val SAME_THREAD:

class ServiceAffinityExecutor :

ServiceAffinityExecutor(threadName: String, numThreads: Int)

ThreadPoolExecutor

Module Contents

protected fun afterExecute(r:

Throwable

)

Unit

open fun checkOnThread(): Unit

open fun executeASAP(runnable: () -> Unit): Unit

open fun <T> fetchFrom(fetcher: () -> T): T

open fun flush(): Unit

abstract val isOnThread: Boolean

class FiberBox<out T>

Module Contents

FiberBox(content: T, lock:

Lock

)

fun <R> read(body: T.() -> R): R

fun <R> readWithDeadline(clock:

deadline

fun <R> write(body: T.() -> R): R

body

(

)

class JDBCHashMap<K : Any, V : Any> :

JDBCHashMap(tableName: String, loadOnInit: Boolean = false)

BlobMapTable

Module Contents

class BlobMapTable :

BlobMapTable(tableName: String)

Module Contents

protected fun addKeyToInsert(insert: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit

val value: <ERROR CLASS>

protected fun addValueToInsert(insert: <ERROR CLASS>, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit

protected fun keyFromRow(row: <ERROR CLASS>): K

protected fun valueFromRow(row: <ERROR CLASS>): V

class JDBCHashSet<K : Any> :

AbstractJDBCHashSet

BlobSetTable

Module Contents

JDBCHashSet(tableName: String, loadOnInit: Boolean = false)

class BlobSetTable :

BlobSetTable(tableName: String)

Module Contents

protected fun addElementToInsert(insert: <ERROR CLASS>, entry: K, finalizables: MutableList<() -> Unit>): Unit

protected fun elementFromRow(row: <ERROR CLASS>): K

open class JDBCHashedTable

Module Contents

JDBCHashedTable(tableName: String)

val keyHash: <ERROR CLASS>

val seqNo: <ERROR CLASS>

object JsonSupport

Module Contents

object CalendarDeserializer

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object LocalDateDeserializer

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object LocalDateKeyDeserializer

Module Contents

fun deserializeKey(text: String, p1: <ERROR CLASS>): Any?

object PartyDeserializer

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object PartySerializer

Module Contents

object PublicKeyDeserializer

generator

provider

)

Unit

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): <ERROR CLASS>

object PublicKeySerializer

Module Contents

fun serialize(obj: <ERROR CLASS>, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit

object PublicKeyTreeDeserializer

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object PublicKeyTreeSerializer

Module Contents

class SecureHashDeserializer<T :

generator

provider

)

Unit

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>): T

Module Contents

SecureHashDeserializer()

object SecureHashSerializer

Module Contents

class ServiceHubObjectMapper

generator

provider

)

Unit

Module Contents

ServiceHubObjectMapper(identities:

)

val identities:

object ToStringSerializer

Module Contents

fun serialize(obj: Any, generator: <ERROR CLASS>, provider: <ERROR CLASS>): Unit

fun createDefaultMapper(identities:

object LocalDateColumnType

)

Module Contents

fun nonNullValueToString(value: Any): String

abstract class MutableClock :

val mutations: <ERROR CLASS><Long>

Module Contents

MutableClock()

val mutationCount: Long

protected fun notifyMutationObservers(): Unit

const val NODE_DATABASE_PREFIX: String

data class PartyColumns

Module Contents

PartyColumns(name: <ERROR CLASS><String>, owningKey: <ERROR CLASS><

val name: <ERROR CLASS><String>

)

val owningKey: <ERROR CLASS><

object PublicKeyColumnType

Module Contents

object SecureHashColumnType

Module Contents

data class StateRefColumns

Module Contents

StateRefColumns(txId: <ERROR CLASS><

val index: <ERROR CLASS><Int>

index

Int

)

val txId: <ERROR CLASS><

class StrandLocalTransactionManager

Module Contents

StrandLocalTransactionManager(initWithDatabase: <ERROR CLASS>)

fun currentOrNull(): <ERROR CLASS>?

var database: <ERROR CLASS>

fun newTransaction(isolation: Int): <ERROR CLASS>

fun restoreThreadLocalTx(context: <ERROR CLASS><<ERROR CLASS>?, <ERROR CLASS>?>): Unit

fun setThreadLocalTx(tx: <ERROR CLASS>?): <ERROR CLASS><<ERROR CLASS>?, <ERROR CLASS>?>

object UUIDStringColumnType

Module Contents

fun <T : Any> bytesFromBlob(blob:

)

fun bytesToBlob(value:

finalizables

MutableList

(

)

Unit

)

fun configureDatabase(props:

fun createDatabaseTransaction(db: <ERROR CLASS>): <ERROR CLASS>

)

Closeable

fun <T> databaseTransaction(db: <ERROR CLASS>, statement: <ERROR CLASS>.() -> T): T

fun <T : Any> deserializeFromBlob(blob:

fun <T> isolatedTransaction(database: <ERROR CLASS>, block: <ERROR CLASS>.() -> T): T

)

java.time.Clock

Module Contents

awaitWithDeadline

(

deadline

future

fun <ERROR CLASS>.localDate(name: String): <ERROR CLASS>

)

Boolean

fun <ERROR CLASS>.party(nameColumnName: String, keyColumnName: String): <ERROR CLASS>

fun <ERROR CLASS>.publicKey(name: String): <ERROR CLASS>

fun <ERROR CLASS>.secureHash(name: String): <ERROR CLASS>

fun serializeToBlob(value: Any, finalizables: MutableList<() -> Unit>):

fun <ERROR CLASS>.stateRef(txIdColumnName: String, indexColumnName: String): <ERROR CLASS>

fun <ERROR CLASS>.uuidString(name: String): <ERROR CLASS>

package com.r3corda.node.utilities.certsigning

Module Contents

class CertificateSigner

Module Contents

CertificateSigner(config:

certService

fun buildKeyStore(): Unit

)

val certService:

val pollInterval:

interface CertificateSigningService

Module Contents

abstract fun retrieveCertificates(requestId: String): Array<

abstract fun submitRequest(request: <ERROR CLASS>): String

class HTTPCertificateSigningService :

HTTPCertificateSigningService(server:

Module Contents

val clientVersion: String

)

fun retrieveCertificates(requestId: String): Array<

val server:

fun submitRequest(request: <ERROR CLASS>): String

object ParamsSpec

Module Contents

package com.r3corda.protocols

Module Contents

abstract class AbstractStateReplacementProtocol<T>

Module Contents

AbstractStateReplacementProtocol()

abstract class Acceptor<T> :

Unit

Module Contents

progressTracker

)

protected abstract fun verifyProposal(maybeProposal:

)

abstract class Instigator<out S :

Module Contents

protected abstract fun assembleProposal(stateRef:

modification

progressTracker

)

modification

stx

)

protected abstract fun assembleTx(): <ERROR CLASS><

List

interface Proposal<out T>

Module Contents

abstract val modification: T

abstract val stateRef:

Module Contents

)

)

class BroadcastTransactionProtocol :

BroadcastTransactionProtocol(notarisedTransaction:

Unit

Module Contents

events

Set

participants

Set

data class NotifyTxRequest

)

Module Contents

NotifyTxRequest(tx:

events

Set

)

val events: Set<

val notarisedTransaction:

class FetchAttachmentsProtocol :

FetchAttachmentsProtocol(requests: Set<

ByteArray

Module Contents

otherSide

protected fun convert(wire: ByteArray):

)

)

protected fun maybeWriteToDisk(downloaded: List<

abstract class FetchDataProtocol<T :

)

Unit

Any

FetchDataProtocol(requests: Set<

Module Contents

otherSide

)

open class BadAnswer :

class DownloadedVsRequestedDataMismatch :

Module Contents

BadAnswer()

BadAnswer

Module Contents

DownloadedVsRequestedDataMismatch(requested:

got

)

Module Contents

HashNotFound(requested:

)

Module Contents

Request(hashes: List<

)

val hashes: List<

data class Result<out T :

Result(fromDisk: List<T>, downloaded: List<T>)

Module Contents

val downloaded: List<T>

val fromDisk: List<T>

open fun call():

protected open fun convert(wire: W): T

protected abstract fun load(txid:

protected open fun maybeWriteToDisk(downloaded: List<T>): Unit

)

protected val otherSide:

protected val requests: Set<

class FetchTransactionsProtocol :

FetchTransactionsProtocol(requests: Set<

Module Contents

otherSide

)

)

class FinalityProtocol :

FinalityProtocol(transaction:

Unit

Module Contents

events

Set

participants

Set

progressTracker

)

object BROADCASTING :

object NotaryChangeProtocol :

AbstractStateReplacementProtocol

Module Contents

Module Contents

progressTracker

)

protected fun verifyProposal(maybeProposal:

)

Module Contents

newNotary

progressTracker

protected fun assembleProposal(stateRef:

)

modification

stx

)

protected fun assembleTx(): <ERROR CLASS><

List

data class Proposal :

Module Contents

modification

stx

)

sealed class NotaryError

Module Contents

Module Contents

conflict

)

val tx:

class SignaturesMissing :

SignaturesMissing(missingSigners: Set<

Module Contents

)

val missingSigners: Set<

class TimestampInvalid :

class TransactionInvalid :

Module Contents

TimestampInvalid()

Module Contents

TransactionInvalid()

class NotaryException :

Module Contents

NotaryException(error:

)

lateinit var notaryParty:

object NotaryProtocol

Module Contents

Module Contents

progressTracker

)

open fun beforeCommit(stx:

Module Contents

Module Contents

)

Module Contents

)

Unit

Module Contents

timestampChecker

uniquenessProvider

)

reqIdentity

)

Unit

open class RatesFixProtocol :

Module Contents

callerIdentity

)

Unit

Module Contents

oracle

fixOf

expectedRate

rateTolerance

progressTracker

)

class FixOutOfRange :

Module Contents

FixOutOfRange(byAmount:

)

val byAmount:

class FixQueryProtocol :

Module Contents

FixQueryProtocol(fixOf:

oracle

)

class FixSignProtocol :

Module Contents

oracle

)

Module Contents

QUERYING(name: String)

QueryRequest(queries: List<

data class QueryRequest

Module Contents

deadline

)

protected open fun beforeSigning(fix:

Module Contents

)

)

Unit

fun tracker(fixName: String):

protected val tx:

class ResolveTransactionsProtocol :

List

ResolveTransactionsProtocol(stx:

Module Contents

otherSide

ResolveTransactionsProtocol(wtx:

)

otherSide

ResolveTransactionsProtocol(txHashes: Set<

)

otherSide

class ExcessivelyLargeTransactionGraph :

)

ExcessivelyLargeTransactionGraph()

Module Contents

fun call(): List<

var transactionCountLimit: Int

interface ServiceRequestMessage

Module Contents

abstract val replyTo:

abstract val sessionID: Long

class StateReplacementException :

StateReplacementException(error:

Module Contents

)

class StateReplacementRefused

Module Contents

StateReplacementRefused(identity:

state

detail

String

)

object TwoPartyDealProtocol

Module Contents

Module Contents

progressTracker

)

protected open fun assembleSharedTX(handshake:

)

List

protected open fun validateHandshake(handshake:

)

Module Contents

dealBeingOffered

)

val dealBeingOffered:

class DealMismatchException :

DealMismatchException(expectedDeal:

Module Contents

actualDeal

)

class DealRefMismatchException :

DealRefMismatchException(expectedDeal:

Module Contents

actualDeal

)

protected fun assembleSharedTX(handshake:

Module Contents

progressTracker

)

)

List

protected fun validateHandshake(handshake:

)

class FixingRoleDecider :

data class Handshake<out T>

Unit

Module Contents

FixingRoleDecider(ref:

progressTracker

)

Module Contents

data class FixingSession

Module Contents

oracleType

)

Module Contents

payload

progressTracker

)

Module Contents

Handshake(payload: T, publicKey:

)

Module Contents

Instigator(otherParty:

payload

myKeyPair

progressTracker

)

interface MarkerForBogusRegulatorProtocol

abstract class Primary :

Module Contents

Primary(progressTracker:

)

object COPYING_TO_REGULATOR :

)

fun getPartialTransaction():

abstract val myKeyPair:

abstract val notaryNode:

abstract val payload: Any

fun verifyPartialTransaction(untrustedPartialTX:

)

)

abstract class Secondary :

Secondary(progressTracker:

Module Contents

)

object VERIFYING :

protected abstract fun assembleSharedTX(handshake:

)

List

protected abstract fun validateHandshake(handshake:

)

class SignaturesFromPrimary

Module Contents

SignaturesFromPrimary(sellerSig:

notarySig

)

object TwoPartyTradeProtocol

Module Contents

class AssetMismatchException :

AssetMismatchException(expectedTypeName: String, typeName: String)

Module Contents

val expectedTypeName: String

Module Contents

notary

acceptablePrice

typeToBuy

out

)

out

Module Contents

notaryNode

assetToSell

price

myKeyPair

progressTracker

)

object NOTARY :

data class SellerTradeInfo

)

Module Contents

SellerTradeInfo(assetForSale:

price

sellerOwnerKey

)

data class SignaturesFromSeller

Module Contents

SignaturesFromSeller(sellerSig:

notarySig

)

class UnacceptablePriceException :

UnacceptablePriceException(givenPrice:

Module Contents

)

class ValidatingNotaryProtocol :

ValidatingNotaryProtocol(otherSide:

Module Contents

timestampChecker

uniquenessProvider

)

fun beforeCommit(stx:

reqIdentity

)

Unit

fun <R : Any>

sendRequest

(

topic

String

request

target

executor

package com.r3corda.schemas

)

Module Contents

object CashSchema

object CashSchemaV1 :

class PersistentCashState :

Module Contents

PersistentCashState(encumbrance: Int?, owner: String, pennies: Long, currency: String, issuerParty: String, issuerRef: ByteArray)

Module Contents

object CommercialPaperSchema

var encumbrance: Int?

var issuerParty: String

var issuerRef: ByteArray

var owner: String

var pennies: Long

object CommercialPaperSchemaV1 :

class PersistentCommericalPaperState :

Module Contents

PersistentCommericalPaperState(issuanceParty: String, issuanceRef: ByteArray, owner: String, maturity:

Module Contents

faceValue

Long

currency

String

faceValueIssuerParty

String

faceValueIssuerRef

ByteArray

)

var faceValueIssuerParty: String

var faceValue: Long

var faceValueIssuerRef: ByteArray

var issuanceParty: String

var issuanceRef: ByteArray

var maturity:

package com.r3corda.simulation

var owner: String

Module Contents

class IRSSimulation :

IRSSimulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, latencyInjector: <ERROR CLASS>?)

Module Contents

fun iterate(): <ERROR CLASS>?

val om: <ERROR CLASS>

protected fun startMainSimulation(): <ERROR CLASS><Unit>

abstract class Simulation

Module Contents

Simulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, latencyInjector: <ERROR CLASS>?)

inner class BankFactory

Module Contents

network

networkMapAddr

advertisedServices

Set

Int

keyPair

)

fun createAll(): List<

object NetworkMapNodeFactory

Module Contents

network

networkMapAddr

advertisedServices

Set

Int

keyPair

)

object NotaryNodeFactory

Module Contents

network

networkMapAddr

advertisedServices

Set

Int

keyPair

object RatesOracleFactory

)

Module Contents

network

networkMapAddr

advertisedServices

Set

Int

keyPair

)

object RegulatorFactory

Module Contents

network

networkMapAddr

advertisedServices

Set

Int

keyPair

)

open class SimulatedNode

Module Contents

SimulatedNode(config:

mockNet

networkMapAddress

advertisedServices

Set

Int

keyPair

)

val allProtocolSteps: <ERROR CLASS><<ERROR CLASS><

val bankLocations: <ERROR CLASS>

val banks: List<

val clocks: <ERROR CLASS>

var currentDateAndTime:

val dateChanges: <ERROR CLASS><

val doneSteps: <ERROR CLASS><Collection<

val extraNodeLabels: MutableMap<

open fun iterate(): <ERROR CLASS>?

String

val network: <ERROR CLASS>

val networkInitialisationFinished: <ERROR CLASS><out <ERROR CLASS>>

val networkMap:

val networkSendManuallyPumped: Boolean

val regulators: List<

val serviceProviders: List<

protected fun showConsensusFor(nodes: List<

protected fun showProgressFor(nodes: List<

)

Unit

fun start(): <ERROR CLASS><Unit>

)

Unit

protected open fun startMainSimulation(): <ERROR CLASS><Unit>

fun startTradingCircle(tradeBetween: (Int, Int) -> <ERROR CLASS><out <ERROR CLASS>>): Unit

class TradeSimulation :