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 fetchFlowsRequiringAttention(query:

)

Map

abstract fun fetchStates(states: List<

)

Map

abstract fun fetchTransactions(txs: List<

)

Map

abstract fun generateTransactionSignature(tx:

)

abstract fun invokeFlowSync(type:

abstract fun provideFlowResponse(flow:

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 fetchFlowsRequiringAttention(query:

)

Map

fun fetchStates(states: List<

)

Map

fun fetchTransactions(txs: List<

)

Map

fun generateTransactionSignature(tx:

)

fun invokeFlowSync(type:

args

Map

String

Any

)

Any

fun provideFlowResponse(flow:

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

(

)

)

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, maxBuckets: Int = 256)

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?

val maxBuckets: Int

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, maxBuckets: Int = 256)

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:

protected open fun acceptableLiveFiberCountOnStop(): Int

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:

open fun findMyLocation():

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

lateinit var flowLogicFactory:

protected open fun generateKeyPair():

lateinit var identity:

var inNodeNetworkMapService:

var inNodeNotaryService:

lateinit var info:

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(type:

)

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:

val pluginRegistries: List<

CordaPluginRegistry

protected val runOnStop:

lateinit var scheduler:

NodeSchedulerService

lateinit var schemas:

protected abstract val serverThread:

val servicesThatAcceptUploads: List<

protected abstract fun startMessagingService(rpcOps:

)

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 AbstractStateReplacementFlow<T>

Module Contents

AbstractStateReplacementFlow()

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:

open class ServiceAffinityExecutor :

)

Unit

fun flush(): Unit

val isOnThread: Boolean

val taskQueueSize: Int

fun waitAndRun(): Unit

ServiceAffinityExecutor(threadName: String, numThreads: Int)

ThreadPoolExecutor

Module Contents

protected open fun afterExecute(r:

open val isOnThread: Boolean

Throwable

)

Unit

open fun flush(): Unit

open fun checkOnThread(): Unit

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

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

abstract 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

fun withParty(partyKeyStr: String, notFound: (String) -> <ERROR CLASS> = defaultNotFound, found: (

groupingKey

)

Set

Module Contents

)

AppContext(attachments: List<

)

)

data class AppContext

Module Contents

)

val classLoader:

abstract class ArtemisMessagingComponent :

ArtemisMessagingComponent()

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

abstract val config:

fun configureWithDevSSLCertificate(): Unit

protected fun

protected fun parseKeyFromQueueName(name: String):

expectedOnDefaultFileSystem

(

)

Unit

protected fun tcpTransport(direction:

ConnectionDirection

host

String

port

Int

)

fun toHostAndPort(target:

protected fun toMyAddress(myIdentity:

)

myHostPort

)

protected fun toQueueName(target:

class ArtemisMessagingServer :

)

ArtemisMessagingServer(config:

Module Contents

myHostPort

myIdentity

networkMapCache

userService

const val NODE_USER: String

)

class NodeLoginModule :

LoginModule

Module Contents

NodeLoginModule()

fun abort(): Boolean

fun commit(): Boolean

fun initialize(subject:

Subject

callbackHandler

CallbackHandler

sharedState

Map

String

options

Map

String

)

Unit

fun login(): Boolean

fun logout(): Boolean

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

)

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<

abstract class BaseTransaction :

val value: T

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 BroadcastTransactionFlow :

BroadcastTransactionFlow(notarisedTransaction:

Unit

Module Contents

participants

Set

data class NotifyTxRequest

)

Module Contents

)

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

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

Frequency

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:

sealed class CashFlowResult

sealed class CashCommand

Module Contents

Module Contents

issueRef

)

Module Contents

issueRef

recipient

notary

)

Module Contents

recipient

)

Module Contents

)

Module Contents

CashFlowResult

Module Contents

Module Contents

transaction

message

String

)

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

data class ClientRPCRequestMessage

groupingKey

)

Set

Module Contents

ClientRPCRequestMessage(args:

Array

Any

replyToAddress

String

observationsToAddress

String

methodName

String

user

const val METHOD_NAME: String

)

const val OBSERVATIONS_TO: String

const val REPLY_TO: String

val args:

val observationsToAddress: String?

Array

Any

val methodName: String

val replyToAddress: String

Module Contents

key

)

signers

List

)

val value:

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

)

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

sealed class CompositeKey

Module Contents

Module Contents

weight

Int

)

fun addKeys(vararg keys:

)

fun addKeys(keys: List<

)

fun build(threshold: Int? = null):

Module Contents

)

)

class Node :

Node(threshold: Int, children: List<

Module Contents

weights

List

Int

)

val children: List<

)

Boolean

val keys: Set<

val threshold: Int

fun containsAny(otherKeys: Iterable<

val weights: List<Int>

abstract fun isFulfilledBy(keys: Iterable<

)

)

Boolean

fun isFulfilledBy(key:

)

abstract val keys: Set<

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

val singleKey:

fun toBase58String(): String

object CompositeKeyColumnType

Module Contents

class CompositeKeyGenerator

Module Contents

CompositeKeyGenerator()

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

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 cash: ObservableList<

class ContractStateModel

Module Contents

ContractStateModel()

val cashStates: ObservableList<

abstract class CordaPluginRegistry

Module Contents

CordaPluginRegistry()

open fun registerRPCKryoTypes(kryo: <ERROR CLASS>): Boolean

open val requiredFlows: 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>, config:

Module Contents

)

val host: <ERROR CLASS>

fun proxy(timeout:

minVersion

Int

)

fun start(username: String, password: String): Unit

class CordaRPCClientImpl

Module Contents

CordaRPCClientImpl(session: <ERROR CLASS>, sessionLock:

username

String

)

proxyFor

(

rpcInterface

timeout

minVersion

Int

)

interface CordaRPCOps :

abstract fun addVaultTransactionNote(txnId:

Module Contents

abstract fun getVaultTransactionNotes(txnId:

txnNote

String

)

Unit

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

)

Iterable

String

abstract fun nodeIdentity():

@RPCReturnsObservables abstract fun <T : Any> startFlowDynamic(logicType:

out

vararg

args

Any

)

@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 CordaRPCOpsImpl :

CordaRPCOpsImpl(services:

Module Contents

smm

fun addVaultTransactionNote(txnId:

database

)

txnNote

String

)

Unit

fun getVaultTransactionNotes(txnId:

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

)

Iterable

String

val protocolVersion: Int

fun <T : Any> startFlowDynamic(logicType:

out

vararg

args

Any

)

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

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

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

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 :

fun addCheckpoint(checkpoint:

Module Contents

DBCheckpointStorage()

)

Unit

fun forEach(block: (

fun removeCheckpoint(checkpoint:

)

Boolean

)

Unit

class DBTransactionMappingStorage :

)

Unit

DBTransactionMappingStorage()

Module Contents

transactionId

)

Unit

class DBTransactionStorage :

fun addTransaction(transaction:

Module Contents

DBTransactionStorage()

)

Boolean

fun getTransaction(id:

)

val transactions: Iterable<

val updatesPublisher: <ERROR CLASS>

class DataUploadServlet

Module Contents

DataUploadServlet()

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

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<

interface DeserializeAsKotlinObjectDef

abstract val ref: String

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:

class DistributedImmutableMap<K : Any, V : Any>

)

Unit

Module Contents

DistributedImmutableMap(db: <ERROR CLASS>, tableName: String)

Module Contents

Module Contents

Module Contents

PutAll(entries: Map<K, V>)

fun compaction(): <ERROR CLASS>

val entries: Map<K, V>

class Size

Module Contents

Size()

val db: <ERROR CLASS>

fun get(commit: <ERROR CLASS><

Get

)

fun install(reader: <ERROR CLASS>): Unit

fun put(commit: <ERROR CLASS><

PutAll

)

Map

fun size(commit: <ERROR CLASS><

Size

)

Int

fun snapshot(writer: <ERROR CLASS>): Unit

open class DriverDSL :

DriverDSLInternalInterface

Module Contents

DriverDSL(portAllocation:

debugPortAllocation

driverDirectory

useTestClock

Boolean

isDebug

Boolean

)

Module Contents

val registeredProcesses:

LinkedList

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

val debugPortAllocation:

val name: Array<String>

val portAllocation:

fun registerProcess(process:

open fun shutdown(): Unit

)

Unit

open fun start(): Unit

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

rpcUsers

List

customOverrides

Map

String

Any

)

open fun startNotaryCluster(notaryName: String, clusterSize: Int, type:

)

Unit

open fun waitForAllNodesToFinish(): Unit

interface DriverDSLExposedInterface

Module Contents

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

rpcUsers

List

customOverrides

Map

String

Any

)

abstract fun startNotaryCluster(notaryName: String, clusterSize: Int = 3, type:

abstract fun waitForAllNodesToFinish(): Unit

)

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_COOL_GUY: 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

Any

val hasEmojiTerminal: <ERROR CLASS>

val leftArrow: String

val newspaper: String

val paperclip: String

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

fun renderIfSupported(obj: Any): String

val rightArrow: String

data class ErrorOr<out A>

Module Contents

ErrorOr(value: A)

)

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

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

EventGenerator(parties: List<

Nothing

val value: A?

class EventGenerator

Module Contents

notary

val amountGenerator: <ERROR CLASS>

)

val amountIssuedGenerator: <ERROR CLASS>

val bankOfCordaCommandGenerator: <ERROR CLASS>

val cashStateGenerator: <ERROR CLASS>

val clientCommandGenerator: <ERROR CLASS>

val consumedGenerator:

Set

val currencyGenerator: <ERROR CLASS>

val exitCashGenerator: <ERROR CLASS>

val issueCashGenerator: <ERROR CLASS>

val issueRefGenerator:

val issuedGenerator: <ERROR CLASS>

val issuerGenerator:

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 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:

class FetchAttachmentsFlow :

generator

provider

)

Unit

FetchAttachmentsFlow(requests: Set<

ByteArray

Module Contents

otherSide

protected fun convert(wire: ByteArray):

)

)

protected fun maybeWriteToDisk(downloaded: List<

abstract class FetchDataFlow<T :

)

Unit

Any

FetchDataFlow(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 FetchTransactionsFlow :

FetchTransactionsFlow(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

(

)

class FilterFuns

Module Contents

FilterFuns(filterInputs: (

)

Boolean

filterOutputs

(

)

Boolean

filterAttachments

(

)

Boolean

filterCommands

(

)

Boolean

)

val filterAttachments: (

)

Boolean

val filterCommands: (

)

Boolean

val filterInputs: (

)

Boolean

val filterOutputs: (

fun <T : Any> genericFilter(elem: T): Boolean

)

Boolean

Any

Module Contents

filterStates

(

List

)

List

)

val filterStates: (List<

fun getExecutionPath(commands: List<

)

List

)

List

out

inputs

List

outputs

List

commands

List

FilteredLeaves(inputs: List<

groupingKey

)

Set

class FilteredLeaves

Module Contents

outputs

List

attachments

List

commands

List

)

val commands: List<

fun getFilteredHashes(): List<

class FilteredTransaction

Module Contents

FilteredTransaction(filteredLeaves:

FilteredLeaves

partialMerkleTree

fun buildMerkleTransaction(wtx:

)

filterFuns

)

val partialMerkleTree:

)

Boolean

class FinalityFlow :

FinalityFlow(transaction:

Unit

Module Contents

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

abstract fun nextFixingOf():

fix

Fix

)

Unit

FixOf

abstract val oracleType:

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

data class FlowClassRef :

FlowClassRef(className: String)

Module Contents

data class FlowHandle<A>

Module Contents

FlowHandle(id:

progress

returnValue

)

val progress: <ERROR CLASS><

val returnValue: <ERROR CLASS><A>

interface FlowIORequest

Module Contents

abstract val session:

FlowSession

abstract val stackTraceInCaseOfProblems:

data class FlowInstanceRef

Module Contents

FlowInstanceRef(flowInstance:

abstract class FlowLogic<out T>

flowClass

FlowClassRef

flowStepId

String

)

val flowStepId: String

Module Contents

FlowLogic()

abstract fun call(): T

lateinit var fsm:

)

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

)

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

receiveType

)

payload

Any

)

Unit

payload

Any

)

fun <R> subFlow(subLogic:

payload

Any

receiveType

)

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

shareParentSessions

Boolean

)

data class FlowLogicRef

Module Contents

val appContext:

AppContext

class FlowLogicRefFactory :

FlowLogicRefFactory(flowWhitelist: Map<String, Set<String>>)

Module Contents

FlowLogicRefFactory()

fun create(type:

out

vararg

args

Any

)

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

)

fun createKotlin(type:

out

data class FlowRequiringAttention

args

Map

String

Any

)

)

Module Contents

FlowRequiringAttention(ref:

prompt

String

choiceIdsToMessages

Map

String

dueBy

val choiceIdsToMessages: Map<

)

String

class FlowSessionException :

FlowSessionException(message: String)

Module Contents

interface FlowStateMachine<R>

Module Contents

abstract val logger: <ERROR CLASS>

abstract fun <T : Any> receive(otherParty:

receiveType

sessionFlow

)

abstract val resultFuture: <ERROR CLASS><R>

abstract fun send(otherParty:

payload

Any

sessionFlow

abstract fun <T : Any> sendAndReceive(otherParty:

)

Unit

payload

Any

receiveType

sessionFlow

)

abstract val serviceHub:

class FlowStateMachineImpl<R> :

Module Contents

FlowStateMachineImpl(id:

logic

fun currentStateMachine():

scheduler

FiberScheduler

)

val logic:

val resultFuture: <ERROR CLASS><R>

receiveType

sessionFlow

)

fun run(): R

fun send(otherParty:

payload

Any

sessionFlow

)

Unit

payload

Any

receiveType

sessionFlow

)

lateinit var serviceHub:

FlowStatus(status: String)

data class FlowStatus

Module Contents

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 basedir:

val dataSourceProperties:

fun createNode():

Node

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 notaryClusterAddresses: List<<ERROR CLASS>>

val notaryNodeAddress: <ERROR CLASS>?

val rpcUsers: List<

val trustStorePassword: String

val useHTTPS: Boolean

val webAddress: <ERROR CLASS>

interface FungibleAsset<T> :

Module Contents

Module Contents

Module Contents

abstract val exitKeys: Collection<

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 partiallyResolvedTransactions: <ERROR CLASS>

class Generator<out A : Any>

Module Contents

Generator(generate: (

)

)

)

fun <A : Any> choice(generators: List<

)

function

(

)

other2

function

(

)

other2

other3

function

(

)

other2

other3

other4

function

(

)

fun <A : Any> fail(error:

)

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

)

)

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

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

fun product(other:

(

)

fun <A : Any> pure(value: A):

fun <A : Any> sequence(generators: List<

)

fun <A : Any> 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

interface IdentityService

Module Contents

abstract fun getAllIdentities(): Iterable<

abstract fun partyFromKey(key:

)

abstract fun partyFromName(name: String):

abstract fun registerIdentity(party:

class IllegalFlowLogicException :

)

Unit

IllegalArgumentException

Module Contents

IllegalFlowLogicException(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 getAllIdentities(): Iterable<

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 getAnyNotary(type:

)

)

open fun getNodeByCompositeKey(compositeKey:

)

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

open fun getNotary(name: String):

open fun getRecommended(type:

contract

vararg

party

)

open fun getRepresentativeNode(party:

)

open fun isNotary(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

open fun track(): <ERROR CLASS><List<

class InMemoryNetworkMapService :

InMemoryNetworkMapService(services:

Module Contents

)

protected val subscribers: <ERROR CLASS>

class InMemoryStateMachineRecordedTransactionMappingStorage :

InMemoryStateMachineRecordedTransactionMappingStorage()

Module Contents

transactionId

)

Unit

class InMemoryUniquenessProvider :

InMemoryUniquenessProvider()

Module Contents

txId

callerIdentity

class InputStateRefResolveFailed :

)

Unit

InputStateRefResolveFailed(stateRefs: List<

Module Contents

)

object InstantColumnType

Module Contents

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

class InstantGenerator

Module Contents

InstantGenerator()

class InsufficientBalanceException :

InsufficientBalanceException(amountMissing:

Module Contents

)

val amountMissing:

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, maxBuckets: Int = 256)

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, maxBuckets: Int = 256)

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 CompositeKeyDeserializer

Module Contents

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

object CompositeKeySerializer

Module Contents

object LocalDateDeserializer

generator

provider

)

Unit

Module Contents

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

object LocalDateKeyDeserializer

Module Contents

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

object NodeInfoDeserializer

Module Contents

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

object NodeInfoSerializer

Module Contents

fun serialize(value:

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

gen

serializers

)

Unit

object PartyDeserializer

Module Contents

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

class SecureHashDeserializer<T :

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 toKeyPair(publicKeys: Iterable<

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

object LocalDateTimeColumnType

Module Contents

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

sealed class MerkleTree

Module Contents

class DuplicatedLeaf :

fun getMerkleTree(allLeavesHashes: List<

Module Contents

DuplicatedLeaf(value:

)

Module Contents

)

Module Contents

left

right

)

)

)

class MerkleTreeException :

MerkleTreeException(reason: String)

Module Contents

val reason: String

abstract val data: ByteArray

interface Message

Module Contents

abstract val debugTimestamp:

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, callback: (

)

Unit

)

abstract fun addMessageHandler(topicSession:

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

class NetworkIdentityModel

Module Contents

NetworkIdentityModel()

fun lookup(compositeKey:

)

ObservableValue

fun lookup(publicKey:

)

ObservableValue

val myIdentity: ObservableValue<

val networkIdentities: ObservableList<

val notaries: ObservableList<

val parties: ObservableList<

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 getAnyNotary(type:

)

abstract fun getNodeByCompositeKey(compositeKey:

)

abstract fun getNodeByLegalName(name: String):

abstract fun getNotary(name: String):

abstract fun getRecommended(type:

contract

vararg

party

)

abstract fun getRepresentativeNode(party:

)

abstract fun isNotary(party:

)

Boolean

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_FLOW_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_FLOW_TOPIC: String

val PUSH_FLOW_TOPIC: String

val QUERY_FLOW_TOPIC: String

class QueryIdentityRequest :

QueryIdentityRequest(identity:

Module Contents

replyTo

sessionID

Long

)

data class QueryIdentityResponse

Module Contents

QueryIdentityResponse(node:

)

val REGISTER_FLOW_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_FLOW_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 configuration:

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

protected fun makeMessagingService():

protected fun makeUniquenessProvider(type:

)

var messageBroker:

protected val serverThread:

fun run(): Unit

ServiceAffinityExecutor

protected fun startMessagingService(rpcOps:

)

Unit

lateinit var webServer: <ERROR CLASS>

class NodeAttachmentService :

NodeAttachmentService(storePath:

Module Contents

class OnDiskHashMismatch :

metrics

)

Module Contents

OnDiskHashMismatch(file:

actual

)

val acceptableFileExtensions: <ERROR CLASS>

var automaticallyExtractAttachments: Boolean

var checkAttachmentsOnLoad: Boolean

val dataTypePrefix: String

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

data class NodeInfoAndConfig

Module Contents

NodeInfoAndConfig(nodeInfo:

config

)

val nodeInfo:

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

database

networkMapRegistrationFuture

Unit

)

data class Handler :

Module Contents

Handler(topicSession:

callback

(

)

Unit

)

val callback: (

)

Unit

val topicSession:

val SESSION_ID_PROPERTY: String

val TOPIC_PROPERTY: String

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

)

Unit

)

fun addMessageHandler(topicSession:

callback

(

)

Unit

)

fun createMessage(topicSession:

data

ByteArray

uuid

)

fun makeNetworkMapAddress(hostAndPort: <ERROR CLASS>):

val myAddress:

val myIdentity:

val networkMapRegistrationFuture: <ERROR CLASS><Unit>

fun removeMessageHandler(registration:

val serverHostPort: <ERROR CLASS>

)

Unit

target

)

Unit

fun start(rpcOps:

userService

)

Unit

val clientToService: <ERROR CLASS><

class NodeMonitorModel

Module Contents

NodeMonitorModel()

CashCommand

val networkMap: <ERROR CLASS><

val progressTracking: <ERROR CLASS><

val proxyObservable: SimpleObjectProperty<

fun register(nodeHostAndPort: <ERROR CLASS>, sslConfig:

val stateMachineTransactionMapping: <ERROR CLASS><

username

String

password

String

)

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(database: <ERROR CLASS>, services:

Module Contents

flowLogicRefFactory

schedulerTimerExecutor

)

class RunScheduled :

RunScheduled(scheduledState:

Unit

Module Contents

scheduler

)

fun scheduleStateActivity(action:

fun unscheduleStateActivity(ref:

)

Unit

fun start(): Unit

class NodeSchemaService :

)

Unit

fun generateMappedObject(state:

Module Contents

NodeSchemaService()

schema

)

val schemaOptions: Map<

fun selectSchemas(state:

)

Iterable

class NodeVaultService :

NodeVaultService(services:

Module Contents

fun addNoteToTransaction(txnId:

)

noteText

String

)

Unit

val currentVault:

fun generateSpend(tx:

amount

onlyFromParties

Set

)

List

fun getTransactionNotes(txnId:

)

Iterable

String

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 NotaryChangeFlow :

)

AbstractStateReplacementFlow

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:

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 :

data class SignRequest

Module Contents

callerIdentity

)

Module Contents

NotaryService(services:

abstract fun createFlow(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():

OpaqueBytes(bytes: ByteArray)

open class OpaqueBytes

Module Contents

val bytes: 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

object OrderedSerializer

Module Contents

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

Any

)

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

Any

Any

)

Unit

interface OwnableState :

Module Contents

abstract val owner:

abstract fun withNewOwner(newOwner:

)

Module Contents

val baseDirectoryArg: <ERROR CLASS>

val configFileArg: <ERROR CLASS>

val parser: <ERROR CLASS>

class PartialMerkleTree

Module Contents

PartialMerkleTree(root:

PartialTree

)

sealed class PartialTree

Module Contents

Module Contents

)

Module Contents

)

Module Contents

right

)

fun build(merkleRoot:

includeHashes

List

)

hashesToCheck

List

data class PartiallyResolvedTransaction

)

Boolean

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

)

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

class PermissionException :

enum class PaymentRule

Module Contents

InAdvance

InArrears

PermissionException(msg: 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:

interface PluginServiceHub :

val description: String

abstract fun getFlowFactory(markerClass:

Module Contents

)

(

)

abstract fun registerFlowInitiator(markerClass: KClass<*>, flowFactory: (

)

Polynomial(coefficients: DoubleArray)

)

Unit

class Polynomial

Module Contents

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

sealed class PortAllocation

Module Contents

class Incremental :

Incremental(startingPort: 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:

object PublicKeyColumnType

Module Contents

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

class PublicKeyGenerator

Module Contents

PublicKeyGenerator()

interface QueryableState :

abstract fun generateMappedObject(schema:

Module Contents

)

abstract fun supportedSchemas(): Iterable<

abstract class RPCDispatcher

Module Contents

userService

)

ClientRPCRequestMessage

)

Unit

protected open fun getUser(message: <ERROR CLASS>):

val ops:

abstract fun send(data:

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

toAddress

String

)

Unit

)

Unit

val userService:

open class RPCException :

RPCException(msg: String)

Module Contents

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)

abstract fun getUser(username: String):

interface RPCUserService

Module Contents

abstract val users: List<

class RPCUserServiceImpl :

RPCUserServiceImpl(config:

Module Contents

fun getUser(username: String):

)

val users: List<

class RaftUniquenessProvider :

RaftUniquenessProvider(storagePath:

Module Contents

myAddress

clusterAddresses

List

config

)

txId

callerIdentity

class RaftValidatingNotaryService :

)

Unit

RaftValidatingNotaryService(services:

Module Contents

timestampChecker

uniquenessProvider

)

)

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

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

object Requirements

Module Contents

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

class ResolveTransactionsFlow :

List

ResolveTransactionsFlow(stx:

Module Contents

otherSide

ResolveTransactionsFlow(wtx:

)

otherSide

ResolveTransactionsFlow(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

interface SchedulableState :

abstract fun nextScheduledActivity(thisStateRef:

Module Contents

flowLogicRefFactory

)

Module Contents

abstract val scheduledAt:

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(bytes: ByteArray)

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

fun randomSHA256():

fun sha256(bytes: ByteArray):

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

fun sha256Twice(bytes: ByteArray):

open fun toString(): <ERROR CLASS>

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(bytes: 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

abstract val identityService:

Any

)

Unit

data class ServiceEntry

Module Contents

identity

)

Module Contents

abstract fun <T : Any> invokeFlowAsync(logicType:

out

vararg

args

Any

)

abstract val keyManagementService:

open val legalIdentityKey:

open fun loadState(stateRef:

)

abstract val networkMapCache:

open val notaryIdentityKey:

abstract fun recordTransactions(txs: Iterable<

abstract val schedulerService:

)

Unit

abstract val storageService:

abstract val vaultService:

abstract class ServiceHubInternal :

abstract val flowLogicRefFactory:

Module Contents

ServiceHubInternal()

open fun <T : Any> invokeFlowAsync(logicType:

out

vararg

args

Any

)

abstract val monitoringService:

MonitoringService

abstract val schemaService:

abstract fun <T> startFlow(logic:

)

object ServiceIdentityGenerator

Module Contents

fun generateToDisk(dirs: List<

serviceId

String

serviceName

String

threshold

Int

)

Unit

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

)

)

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:

flowStatus

ObservableValue

stateMachineStatus

ObservableValue

val flowStatus: ObservableValue<

)

val stateMachineStatus: ObservableValue<

data class StateMachineInfo

Module Contents

StateMachineInfo(id:

flowLogicClassName

String

progressTrackerStepAndUpdates

String

String

)

fun fromFlowStateMachineImpl(psm:

)

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 FlowSession

Module Contents

FlowSession(flow:

otherParty

var otherPartySessionId: Long?

ourSessionId

Long

otherPartySessionId

Long

waitingForResponse

Boolean

)

val ourSessionId: Long

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

flowName

String

firstPayload

Any

)

val firstPayload: Any?

val flowName: String

val initiatorParty:

interface SessionInitResponse :

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

(

flowClass

fun stop(allowedUnsuspendedFiberCount: Int = 0): Unit

)

List

interface StateMachineRecordedTransactionMappingStorage

Module Contents

abstract fun addMapping(stateMachineRunId:

transactionId

)

Unit

data class StateMachineRunId

Module Contents

fun createRandom():

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

)

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

class TestClock :

MutableClock

Module Contents

TestClock(delegateClock:

)

)

fun updateDate(date:

)

Boolean

fun withZone(zone:

ZoneId

)

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>

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

)

Boolean

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 TwoPartyDealFlow

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

)

data class Handshake<out T>

Module Contents

Handshake(payload: T, publicKey:

)

Module Contents

Instigator(otherParty:

payload

myKeyPair

progressTracker

)

interface MarkerForBogusRegulatorFlow

abstract class Primary :

Module Contents

Primary(progressTracker:

)

object COPYING_TO_REGULATOR :

open fun computeOurSignature(partialTX:

)

)

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 TwoPartyTradeFlow

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 :

open fun calculateOurSignature(partialTX:

)

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

data class TxnNoteColumns

Module Contents

TxnNoteColumns(txId: <ERROR CLASS><

val note: <ERROR CLASS><String>

note

String

)

abstract class TypeOnlyCommandData :

Module Contents

TypeOnlyCommandData()

object UUIDStringColumnType

Module Contents

data class UniqueIdentifier : Comparable<

UniqueIdentifier(externalId: String? = null, id:

Module Contents

)

)

Int

fun fromString(name: String):

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

class UntrustworthyData<out T>

)

Unit

Module Contents

UntrustworthyData(fromUntrustedWorld: T)

val data: T

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

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

data class User

Module Contents

User(username: String, password: String, permissions: Set<String>)

val password: String

val permissions: Set<String>

class ValidatingNotaryFlow :

val username: String

ValidatingNotaryFlow(otherSide:

Module Contents

timestampChecker

uniquenessProvider

)

fun beforeCommit(stx:

reqIdentity

class ValidatingNotaryService :

)

Unit

ValidatingNotaryService(services:

Module Contents

timestampChecker

uniquenessProvider

)

)

class Vault

Module Contents

Vault(states: Iterable<

)

Module Contents

Update(consumed: Set<

produced

Set

)

operator fun plus(rhs:

)

val states: Iterable<

statesOfType

(

)

List

abstract fun addNoteToTransaction(txnId:

interface VaultService

Module Contents

open val cashBalances: Map<

noteText

String

)

Unit

abstract val currentVault:

abstract fun generateSpend(tx:

amount

onlyFromParties

Set

)

List

abstract fun getTransactionNotes(txnId:

abstract val linearHeads: Map<

)

Iterable

String

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 allLeavesHashes: List<

)

fun deserialize(data:

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.io.InputStream

Module Contents

copyTo

(

target

vararg

options

CopyOption

)

Long

java.nio.file.Path

Module Contents

createDirectories

(

vararg

attrs

)

createDirectory

(

vararg

attrs

)

deleteIfExists

(

)

Boolean

div

(

other

String

)

exists

(

vararg

options

)

Boolean

isDirectory

(

vararg

options

)

Boolean

isRegularFile

(

vararg

options

)

Boolean

list

(

block

(

)

moveTo

(

target

vararg

options

)

read

(

vararg

options

block

(

)

readAll

(

)

ByteArray

readLines

(

charset

block

(

Stream

String

)

val

size

Long

inline fun

write

(

createDirs

Boolean

vararg

options

block

(

)

Unit

)

Unit

writeLines

(

lines

Iterable

CharSequence

charset

vararg

options

)

java.security.KeyPair

Module Contents

component1

(

)

component2

(

)

signWithECDSA

(

bytesToSign

ByteArray

)

signWithECDSA

(

bytesToSign

)

signWithECDSA

(

bytesToSign

party

)

signWithECDSA

(

bytesToSign

ByteArray

party

)

LegallyIdentifiable

java.security.PrivateKey

Module Contents

signWithECDSA

(

bytes

ByteArray

)

signWithECDSA

(

bytesToSign

ByteArray

publicKey

)

java.security.PublicKey

Module Contents

composite

toBase58String

(

)

toStringShort

(

)

String

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

)

java.util.concurrent.Future

Module Contents

fun <T>

javafx.beans.value.ObservableValue

getOrThrow

(

)

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 ObservableValue<*>.isNotNull(): BooleanBinding

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<A>.firstOrDefault(default: ObservableValue<A?>, predicate: (A) -> Boolean): ObservableValue<A?>

fun <A> ObservableList<A>.firstOrNullObservable(predicate: (A) -> Boolean): 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

fun <T : Any> ObservableList<T>.unique(): ObservableList<T>

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

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

fun String.parseAsHex(): <ERROR CLASS>

Module Contents

fun String.abbreviate(maxWidth: Int): String

Module Contents

val String.bd:

val Throwable.rootCause: Throwable

kotlin.Throwable

Module Contents

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

sumFungibleOrNull

(

)

sumFungibleOrZero

(

token

)

sumOrNull

(

)

Nothing

sumOrThrow

(

)

sumOrZero

(

currency

)

Module Contents

byKeys

(

)

val Iterable<

keys

Set

Module Contents

containsType

(

type

)

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

Module Contents

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

sum

(

)

Module Contents

sumCash

(

)

sumCashBy

(

owner

)

sumCashOrNull

(

)

sumCashOrZero

(

currency

)

sumCommodities

(

)

sumCommoditiesOrNull

(

)

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

sumCommoditiesOrZero

(

currency

)

sumObligations

(

)

sumObligationsOrNull

(

)

sumObligationsOrZero

(

issuanceDef

)

kotlin.collections.List

Module Contents

fun <T> List<T>.randomOrNull(): T?

fun <T> List<T>.randomOrNull(predicate: (T) -> Boolean): <ERROR CLASS>

package net.corda.client

Module Contents

class CordaRPCClient :

Closeable

CordaRPCClient(host: <ERROR CLASS>, config:

Module Contents

)

val host: <ERROR CLASS>

fun proxy(timeout:

minVersion

Int

)

fun start(username: String, password: String): Unit

package net.corda.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 ObservableValue<*>.isNotNull(): BooleanBinding

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<A>.firstOrDefault(default: ObservableValue<A?>, predicate: (A) -> Boolean): ObservableValue<A?>

fun <A> ObservableList<A>.firstOrNullObservable(predicate: (A) -> Boolean): 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

fun <T : Any> ObservableList<T>.unique(): ObservableList<T>

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

Module Contents

class CordaRPCClientImpl

Module Contents

CordaRPCClientImpl(session: <ERROR CLASS>, sessionLock:

username

String

)

proxyFor

(

rpcInterface

timeout

package net.corda.client.mock

minVersion

Int

)

Module Contents

class EventGenerator

Module Contents

EventGenerator(parties: List<

notary

val amountGenerator: <ERROR CLASS>

)

val amountIssuedGenerator: <ERROR CLASS>

val bankOfCordaCommandGenerator: <ERROR CLASS>

val cashStateGenerator: <ERROR CLASS>

val clientCommandGenerator: <ERROR CLASS>

val consumedGenerator:

Set

val currencyGenerator: <ERROR CLASS>

val exitCashGenerator: <ERROR CLASS>

val issueCashGenerator: <ERROR CLASS>

val issueRefGenerator:

val issuedGenerator: <ERROR CLASS>

val issuerGenerator:

val moveCashGenerator: <ERROR CLASS>

val producedGenerator:

Set

val publicKeyGenerator: <ERROR CLASS>

class Generator<out A : Any>

Module Contents

Generator(generate: (

)

)

)

fun <A : Any> choice(generators: List<

)

function

(

)

other2

function

(

)

other2

other3

function

(

)

other2

other3

other4

function

(

)

fun <A : Any> fail(error:

)

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

)

)

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

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

fun product(other:

(

)

fun <A : Any> pure(value: A):

fun <A : Any> sequence(generators: List<

)

fun <A : Any> success(generate: (

List

)

fun Generator.Companion.bytes(size: Int):

fun Generator.Companion.double():

ByteArray

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

Double

fun <A : Any> Generator.Companion.frequency(vararg generators: <ERROR CLASS><Double,

Double

fun <T : Any> generateAmount(min: Long, max: Long, tokenGenerator:

)

)

fun generateCurrency():

fun generateCurrencyAmount(min: Long, max: Long):

fun generateIssueRef(size: Int):

generateOrFail

(

random

fun Generator.Companion.int():

numberOfTries

Int

)

fun Generator.Companion.intRange(range: IntRange):

Int

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

Int

fun Generator.Companion.longRange(range: LongRange):

Int

fun Generator.Companion.longRange(from: Long, to: Long):

Long

fun <A : Any> Generator.Companion.pickN(number: Int, list: List<A>):

Long

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

List

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

)

fun <A : Any> 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 net.corda.client.model

List

Module Contents

class ContractStateModel

Module Contents

ContractStateModel()

val cash: ObservableList<

val cashStates: ObservableList<

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

FlowStatus(status: String)

data class FlowStatus

Module Contents

val status: String

data class GatheredTransactionData

Module Contents

GatheredTransactionData(transaction:

stateMachines

ObservableList

out

val stateMachines: ObservableList<out

)

class GatheredTransactionDataModel

Module Contents

GatheredTransactionDataModel()

val partiallyResolvedTransactions: <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 NetworkIdentityModel

Module Contents

NetworkIdentityModel()

fun lookup(compositeKey:

)

ObservableValue

fun lookup(publicKey:

)

ObservableValue

val myIdentity: ObservableValue<

val networkIdentities: ObservableList<

val notaries: ObservableList<

val parties: ObservableList<

val clientToService: <ERROR CLASS><

class NodeMonitorModel

Module Contents

NodeMonitorModel()

CashCommand

val networkMap: <ERROR CLASS><

val progressTracking: <ERROR CLASS><

val proxyObservable: SimpleObjectProperty<

fun register(nodeHostAndPort: <ERROR CLASS>, sslConfig:

val stateMachineTransactionMapping: <ERROR CLASS><

username

String

password

String

)

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 StateMachineData

Module Contents

StateMachineData(id:

flowStatus

ObservableValue

stateMachineStatus

ObservableValue

val flowStatus: 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 net.corda.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

)

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

owned by

(

owner

)

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

)

with notary

(

notary

)

package net.corda.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>

OBLIGATION

OBLIGATION_DEF

val OBLIGATION_PROGRAM_ID:

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():

STATE

(

dueBefore

)

between

(

parties

)

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

(

)

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

sumCommoditiesOrZero

(

currency

)

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

Module Contents

abstract class AbstractConserveAmount<S :

Any

Module Contents

AbstractConserveAmount()

amountIssued

assetStates

List

deriveState

(

)

generateMoveCommand

(

)

generateExitCommand

(

)

)

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

issuedBy

issuerKey

)

package net.corda.core

Module Contents

Module Contents

ErrorOr(value: A)

)

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

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:

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

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>

fun <T> future(block: () -> T): <ERROR CLASS><T>

java.io.InputStream

Module Contents

copyTo

(

target

vararg

options

CopyOption

)

Long

java.nio.file.Path

Module Contents

createDirectories

(

vararg

attrs

)

createDirectory

(

vararg

attrs

)

deleteIfExists

(

)

Boolean

div

(

other

String

)

exists

(

vararg

options

)

Boolean

isDirectory

(

vararg

options

)

Boolean

isRegularFile

(

vararg

options

)

Boolean

list

(

block

(

)

moveTo

(

target

vararg

options

)

read

(

vararg

options

block

(

)

readAll

(

)

ByteArray

readLines

(

charset

block

(

Stream

String

)

val

size

Long

inline fun

write

(

createDirs

Boolean

vararg

options

block

(

)

Unit

)

Unit

writeLines

(

lines

Iterable

CharSequence

charset

vararg

options

)

java.time.temporal.Temporal

Module Contents

Temporal

until

(

endExclusive

Temporal

)

java.util.concurrent.Future

Module Contents

fun <T>

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

getOrThrow

(

)

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> Iterable<T>.noneOrSingle(predicate: (T) -> Boolean): T?

Module Contents

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

sum

(

)

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

kotlin.collections.List

Module Contents

fun <T> List<T>.randomOrNull(): T?

fun <T> List<T>.randomOrNull(predicate: (T) -> Boolean): <ERROR CLASS>

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

)

fun <A> <ERROR CLASS><A>.toObservable(): <ERROR CLASS><A>

package net.corda.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

)

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

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

Frequency

steps

Int

)

val holidayDates: List<

open fun isWorkingDay(date:

fun moveBusinessDays(date:

)

Boolean

direction

Int

)

fun parseDateFromString(it: String):

Module Contents

key

)

signers

List

)

val value:

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

abstract fun nextFixingOf():

fix

Fix

)

Unit

FixOf

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

)

interface FungibleAsset<T> :

Module Contents

Module Contents

Module Contents

abstract val exitKeys: Collection<

abstract fun move(newAmount:

newOwner

)

class InsufficientBalanceException :

InsufficientBalanceException(amountMissing:

Module Contents

)

val amountMissing:

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

)

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

enum class PaymentRule

Module Contents

InAdvance

InArrears

object Requirements

Module Contents

fun SWISS_FRANCS(amount: Int):

interface SchedulableState :

abstract fun nextScheduledActivity(thisStateRef:

Module Contents

flowLogicRefFactory

)

Module Contents

abstract val scheduledAt:

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

)

)

Int

fun fromString(name: String):

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

sumFungibleOrNull

(

)

sumFungibleOrZero

(

token

)

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

)

Unit

Module Contents

sealed class CompositeKey

Module Contents

Module Contents

weight

Int

)

fun addKeys(vararg keys:

)

fun addKeys(keys: List<

)

fun build(threshold: Int? = null):

Module Contents

)

)

class Node :

Node(threshold: Int, children: List<

Module Contents

weights

List

Int

)

val children: List<

)

Boolean

val keys: Set<

val threshold: Int

fun containsAny(otherKeys: Iterable<

val weights: List<Int>

abstract fun isFulfilledBy(keys: Iterable<

)

)

Boolean

fun isFulfilledBy(key:

)

abstract val keys: Set<

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

val singleKey:

fun toBase58String(): String

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

class MerkleTreeException :

MerkleTreeException(reason: String)

Module Contents

val reason: String

val NullCompositeKey:

object NullPublicKey :

Comparable

Module Contents

)

Int

fun getEncoded(): ByteArray

object NullSignature :

class PartialMerkleTree

Module Contents

PartialMerkleTree(root:

PartialTree

)

sealed class PartialTree

Module Contents

Module Contents

)

Module Contents

)

Module Contents

right

)

fun build(merkleRoot:

includeHashes

List

)

hashesToCheck

List

)

Boolean

data class Party

Module Contents

)

fun ref(vararg bytes: Byte):

)

)

sealed class SecureHash :

Module Contents

class SHA256 :

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

Module Contents

SHA256(bytes: ByteArray)

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

fun randomSHA256():

fun sha256(bytes: ByteArray):

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

fun sha256Twice(bytes: ByteArray):

open fun toString(): <ERROR CLASS>

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

(

bytesToSign

ByteArray

)

signWithECDSA

(

bytesToSign

)

signWithECDSA

(

bytesToSign

party

)

signWithECDSA

(

bytesToSign

ByteArray

party

)

LegallyIdentifiable

java.security.PrivateKey

Module Contents

signWithECDSA

(

bytes

ByteArray

)

signWithECDSA

(

bytesToSign

ByteArray

publicKey

)

java.security.PublicKey

Module Contents

composite

toBase58String

(

)

toStringShort

(

)

String

verifyWithECDSA

(

content

ByteArray

signature

)

Unit

Module Contents

fun ByteArray.sha256():

Module Contents

byKeys

(

)

val Iterable<

keys

Set

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

fun newSecureRandom():

SecureRandom

fun registerWhitelistTrustManager(): Unit

sha256

(

)

package net.corda.core.flows

Module Contents

data class AppContext

Module Contents

AppContext(attachments: List<

)

val classLoader:

abstract class FlowLogic<out T>

Module Contents

FlowLogic()

abstract fun call(): T

lateinit var fsm:

)

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

)

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

receiveType

)

payload

Any

)

Unit

payload

Any

)

fun <R> subFlow(subLogic:

payload

Any

receiveType

)

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

shareParentSessions

Boolean

)

data class FlowLogicRef

Module Contents

val appContext:

AppContext

class FlowLogicRefFactory :

FlowLogicRefFactory(flowWhitelist: Map<String, Set<String>>)

Module Contents

FlowLogicRefFactory()

fun create(type:

out

vararg

args

Any

)

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

)

fun createKotlin(type:

out

class FlowSessionException :

args

Map

String

Any

)

)

FlowSessionException(message: String)

Module Contents

interface FlowStateMachine<R>

Module Contents

abstract val logger: <ERROR CLASS>

abstract fun <T : Any> receive(otherParty:

receiveType

sessionFlow

)

abstract val resultFuture: <ERROR CLASS><R>

abstract fun send(otherParty:

payload

Any

sessionFlow

abstract fun <T : Any> sendAndReceive(otherParty:

)

Unit

payload

Any

receiveType

sessionFlow

)

abstract val serviceHub:

class IllegalFlowLogicException :

IllegalArgumentException

Module Contents

IllegalFlowLogicException(type:

data class StateMachineRunId

msg

String

)

Module Contents

fun createRandom():

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

Module Contents

object Ack :

interface AllPossibleRecipients :

abstract val data: ByteArray

interface Message

Module Contents

abstract val debugTimestamp:

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, callback: (

)

Unit

)

abstract fun addMessageHandler(topicSession:

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

)

runOnNextMessage

(

topic

String

sessionID

Long

callback

(

)

Unit

)

Unit

inline fun

runOnNextMessage

(

topicSession

crossinline

callback

(

)

Unit

)

Unit

send

(

topic

String

sessionID

Long

payload

Any

uuid

)

Unit

send

(

topicSession

payload

Any

uuid

package net.corda.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 fun registerRPCKryoTypes(kryo: <ERROR CLASS>): Boolean

open val requiredFlows: 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:

interface PluginServiceHub :

val description: String

abstract fun getFlowFactory(markerClass:

Module Contents

)

(

)

abstract fun registerFlowInitiator(markerClass: KClass<*>, flowFactory: (

)

abstract val identityService:

)

Unit

data class ServiceEntry

Module Contents

identity

)

Module Contents

abstract fun <T : Any> invokeFlowAsync(logicType:

out

vararg

args

Any

)

abstract val keyManagementService:

open val legalIdentityKey:

open fun loadState(stateRef:

)

abstract val networkMapCache:

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 net.corda.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 getAllIdentities(): Iterable<

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 toKeyPair(publicKeys: Iterable<

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 getAnyNotary(type:

)

abstract fun getNodeByCompositeKey(compositeKey:

)

abstract fun getNodeByLegalName(name: String):

abstract fun getNotary(name: String):

abstract fun getRecommended(type:

contract

vararg

party

)

abstract fun getRepresentativeNode(party:

)

abstract fun isNotary(party:

)

Boolean

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 :

)

Boolean

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 fun addNoteToTransaction(txnId:

interface VaultService

Module Contents

open val cashBalances: Map<

noteText

String

)

Unit

abstract val currentVault:

abstract fun generateSpend(tx:

amount

onlyFromParties

Set

)

List

abstract fun getTransactionNotes(txnId:

abstract val linearHeads: Map<

)

Iterable

String

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

linearHeadsOfType

(

)

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 net.corda.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(bytes: ByteArray)

val bytes: ByteArray

fun of(vararg b: Byte):

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

object OrderedSerializer

Module Contents

Any

)

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

Any

object ReferencesAwareJavaSerializer

Any

)

Unit

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(bytes: 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>

fun extendKryoHash(kryo: <ERROR CLASS>): <ERROR CLASS>

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 net.corda.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 CompositeKeyGenerator

Module Contents

CompositeKeyGenerator()

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

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

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

Module Contents

abstract class BaseTransaction :

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

Module Contents

notary

mustSign

List

type

timestamp

protected fun checkInvariants(): Unit

)

FilterFuns(filterInputs: (

open val inputs: List<*>

Module Contents

)

Boolean

filterOutputs

(

)

Boolean

filterAttachments

(

)

Boolean

filterCommands

(

)

Boolean

)

val filterAttachments: (

)

Boolean

val filterCommands: (

)

Boolean

val filterInputs: (

)

Boolean

val filterOutputs: (

fun <T : Any> genericFilter(elem: T): Boolean

)

Boolean

class FilteredLeaves

Module Contents

FilteredLeaves(inputs: List<

outputs

List

attachments

List

commands

List

)

val commands: List<

fun getFilteredHashes(): List<

class FilteredTransaction

Module Contents

FilteredTransaction(filteredLeaves:

FilteredLeaves

partialMerkleTree

fun buildMerkleTransaction(wtx:

)

filterFuns

)

val partialMerkleTree:

class LedgerTransaction :

)

Boolean

LedgerTransaction(inputs: List<

Module Contents

outputs

List

commands

List

attachments

List

notary

signers

List

timestamp

type

)

outRef

(

index

Int

)

fun toTransactionForContract():

fun verify(): Unit

sealed class MerkleTree

Module Contents

class DuplicatedLeaf :

fun getMerkleTree(allLeavesHashes: List<

Module Contents

DuplicatedLeaf(value:

)

Module Contents

)

Module Contents

left

right

)

)

)

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<

)

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 allLeavesHashes: List<

)

fun deserialize(data:

kryo

)

outRef

(

index

Int

)

outRef

(

state

)

)

buildFilteredTransaction

(

filterFuns

)

calculateLeavesHashes

(

)

List

hashConcat

(

other

fun <T : Any> serializedHash(x: T):

)

package net.corda.core.utilities

Module Contents

Module Contents

)

fun withParty(partyKeyStr: String, notFound: (String) -> <ERROR CLASS> = defaultNotFound, found: (

const val CODE_BAG_OF_CASH: String

)

)

val DUMMY_NOTARY_KEY:

Module Contents

const val CODE_COOL_GUY: 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

Any

val hasEmojiTerminal: <ERROR CLASS>

val leftArrow: String

val newspaper: String

val paperclip: String

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

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

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

package net.corda.flows

Module Contents

abstract class AbstractStateReplacementFlow<T>

Module Contents

AbstractStateReplacementFlow()

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 BroadcastTransactionFlow :

BroadcastTransactionFlow(notarisedTransaction:

Unit

Module Contents

participants

Set

data class NotifyTxRequest

)

Module Contents

)

val notarisedTransaction:

sealed class CashFlowResult

sealed class CashCommand

Module Contents

Module Contents

issueRef

)

Module Contents

issueRef

recipient

notary

)

Module Contents

recipient

)

Module Contents

)

Module Contents

CashFlowResult

Module Contents

Module Contents

transaction

message

String

)

class FetchAttachmentsFlow :

FetchAttachmentsFlow(requests: Set<

ByteArray

Module Contents

otherSide

protected fun convert(wire: ByteArray):

)

)

protected fun maybeWriteToDisk(downloaded: List<

abstract class FetchDataFlow<T :

)

Unit

Any

FetchDataFlow(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 FetchTransactionsFlow :

FetchTransactionsFlow(requests: Set<

Module Contents

otherSide

)

FinalityFlow(transaction:

)

Unit

Module Contents

participants

Set

progressTracker

)

object BROADCASTING :

class InputStateRefResolveFailed :

InputStateRefResolveFailed(stateRefs: List<

Module Contents

object NotaryChangeFlow :

)

AbstractStateReplacementFlow

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:

Module Contents

Module Contents

progressTracker

)

open fun beforeCommit(stx:

Module Contents

Module Contents

)

Module Contents

)

Unit

Module Contents

timestampChecker

uniquenessProvider

)

reqIdentity

)

Unit

class ResolveTransactionsFlow :

data class SignRequest

Module Contents

callerIdentity

)

List

ResolveTransactionsFlow(stx:

Module Contents

otherSide

ResolveTransactionsFlow(wtx:

)

otherSide

ResolveTransactionsFlow(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

)

protected open fun assembleSharedTX(handshake:

object TwoPartyDealFlow

Module Contents

Module Contents

progressTracker

)

)

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

)

data class Handshake<out T>

Module Contents

Handshake(payload: T, publicKey:

)

Module Contents

Instigator(otherParty:

payload

myKeyPair

progressTracker

)

interface MarkerForBogusRegulatorFlow

abstract class Primary :

Module Contents

Primary(progressTracker:

)

object COPYING_TO_REGULATOR :

open fun computeOurSignature(partialTX:

)

)

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 TwoPartyTradeFlow

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 :

open fun calculateOurSignature(partialTX:

)

data class SellerTradeInfo

Module Contents

SellerTradeInfo(assetForSale:

price

sellerOwnerKey

)

data class SignaturesFromSeller

Module Contents

SignaturesFromSeller(sellerSig:

notarySig

)

class UnacceptablePriceException :

UnacceptablePriceException(givenPrice:

Module Contents

)

class ValidatingNotaryFlow :

ValidatingNotaryFlow(otherSide:

Module Contents

timestampChecker

uniquenessProvider

)

fun beforeCommit(stx:

reqIdentity

)

Unit

fun <R : Any>

sendRequest

(

topic

String

request

target

fun main(args: Array<String>): Unit

)

package net.corda.node

Module Contents

fun printBasicNodeInfo(description: String, info: String? = null): Unit

package net.corda.node.api

Module Contents

interface APIServer

Module Contents

abstract fun buildTransaction(type:

steps

List

)

abstract fun commitTransaction(tx:

signatures

List

)

abstract fun fetchFlowsRequiringAttention(query:

)

Map

abstract fun fetchStates(states: List<

)

Map

abstract fun fetchTransactions(txs: List<

)

Map

abstract fun generateTransactionSignature(tx:

)

abstract fun invokeFlowSync(type:

abstract fun provideFlowResponse(flow:

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 FlowClassRef :

FlowClassRef(className: String)

Module Contents

data class FlowInstanceRef

Module Contents

FlowInstanceRef(flowInstance:

data class FlowRequiringAttention

flowClass

FlowClassRef

flowStepId

String

)

val flowStepId: String

interface FlowRef

Module Contents

FlowRequiringAttention(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 net.corda.node.driver

Module Contents

open class DriverDSL :

DriverDSLInternalInterface

Module Contents

DriverDSL(portAllocation:

debugPortAllocation

driverDirectory

useTestClock

Boolean

isDebug

Boolean

)

Module Contents

val registeredProcesses:

LinkedList

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

val debugPortAllocation:

val name: Array<String>

val portAllocation:

fun registerProcess(process:

open fun shutdown(): Unit

)

Unit

open fun start(): Unit

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

rpcUsers

List

customOverrides

Map

String

Any

)

open fun startNotaryCluster(notaryName: String, clusterSize: Int, type:

)

Unit

open fun waitForAllNodesToFinish(): Unit

interface DriverDSLExposedInterface

Module Contents

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

rpcUsers

List

customOverrides

Map

String

Any

)

abstract fun startNotaryCluster(notaryName: String, clusterSize: Int = 3, type:

abstract fun waitForAllNodesToFinish(): Unit

)

Unit

interface DriverDSLInternalInterface :

abstract fun shutdown(): Unit

Module Contents

abstract fun start(): Unit

data class NodeInfoAndConfig

Module Contents

NodeInfoAndConfig(nodeInfo:

config

)

val nodeInfo:

sealed class PortAllocation

Module Contents

class Incremental :

Incremental(startingPort: 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(driverDirectory:

portAllocation

debugPortAllocation

useTestClock

Boolean

isDebug

Boolean

dsl

(

)

fun <DI :

DriverDSLInternalInterface

genericDriver

(

driverDsl

coerce

(

)

dsl

(

)

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

fun writeConfig(path:

package net.corda.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 fetchFlowsRequiringAttention(query:

)

Map

fun fetchStates(states: List<

)

Map

fun fetchTransactions(txs: List<

)

Map

fun generateTransactionSignature(tx:

)

fun invokeFlowSync(type:

args

Map

String

Any

)

Any

fun provideFlowResponse(flow:

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:

protected open fun acceptableLiveFiberCountOnStop(): Int

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:

open fun findMyLocation():

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

lateinit var flowLogicFactory:

protected open fun generateKeyPair():

lateinit var identity:

var inNodeNetworkMapService:

var inNodeNotaryService:

lateinit var info:

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(type:

)

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:

val pluginRegistries: List<

CordaPluginRegistry

protected val runOnStop:

lateinit var scheduler:

NodeSchedulerService

lateinit var schemas:

protected abstract val serverThread:

val servicesThatAcceptUploads: List<

protected abstract fun startMessagingService(rpcOps:

)

Unit

var started: Boolean

open fun stop(): Unit

lateinit var storage:

var uniquenessProvider:

lateinit var vault:

class ConfigurationException :

ConfigurationException(message: String)

Module Contents

class CordaRPCOpsImpl :

CordaRPCOpsImpl(services:

Module Contents

smm

fun addVaultTransactionNote(txnId:

database

)

txnNote

String

)

Unit

fun getVaultTransactionNotes(txnId:

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

)

Iterable

String

val protocolVersion: Int

fun <T : Any> startFlowDynamic(logicType:

out

vararg

args

Any

)

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

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

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

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

Module Contents

networkMapAddress

advertisedServices

Set

clock

)

val configuration:

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

protected fun makeMessagingService():

protected fun makeUniquenessProvider(type:

)

var messageBroker:

protected val serverThread:

fun run(): Unit

ServiceAffinityExecutor

protected fun startMessagingService(rpcOps:

)

Unit

lateinit var webServer: <ERROR CLASS>

package net.corda.node.serialization

Module Contents

class NodeClock :

Module Contents

NodeClock(delegateClock:

)

package net.corda.node.services

)

)

Module Contents

Module Contents

Module Contents

Module Contents

abstract fun getUser(username: String):

)

interface RPCUserService

Module Contents

abstract val users: List<

class RPCUserServiceImpl :

RPCUserServiceImpl(config:

Module Contents

fun getUser(username: String):

)

Module Contents

User(username: String, password: String, permissions: Set<String>)

val password: String

val permissions: Set<String>

val username: String

fun <P :

startFlowPermission

(

clazz

)

String

inline fun <reified P :

package net.corda.node.services.api

startFlowPermission

(

)

String

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 val flowLogicRefFactory:

Module Contents

ServiceHubInternal()

open fun <T : Any> invokeFlowAsync(logicType:

out

vararg

args

Any

)

abstract val monitoringService:

MonitoringService

abstract val schemaService:

abstract fun <T> startFlow(logic:

)

package net.corda.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 basedir:

val dataSourceProperties:

fun createNode():

Node

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 notaryClusterAddresses: List<<ERROR CLASS>>

val notaryNodeAddress: <ERROR CLASS>?

val rpcUsers: List<

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 configureTestSSL():

inline fun <reified T : Any> <ERROR CLASS>.getListOrElse(path: String, default: <ERROR CLASS>.() -> List<T>): List<T>

configureWithDevSSLCertificate

(

)

Unit

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

OptionalConfig

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

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

package net.corda.node.services.events

Module Contents

class NodeSchedulerService :

NodeSchedulerService(database: <ERROR CLASS>, services:

Module Contents

flowLogicRefFactory

schedulerTimerExecutor

)

class RunScheduled :

RunScheduled(scheduledState:

Unit

Module Contents

scheduler

)

fun scheduleStateActivity(action:

fun unscheduleStateActivity(ref:

)

Unit

fun start(): Unit

class ScheduledActivityObserver

)

Unit

Module Contents

ScheduledActivityObserver(services:

)

package net.corda.node.services.identity

Module Contents

class InMemoryIdentityService :

InMemoryIdentityService()

Module Contents

fun getAllIdentities(): Iterable<

fun partyFromKey(key:

)

fun partyFromName(name: String):

fun registerIdentity(party:

package net.corda.node.services.keys

)

Unit

Module Contents

class E2ETestKeyManagementService :

E2ETestKeyManagementService(initialKeys: Set<

Module Contents

)

class PersistentKeyManagementService :

PersistentKeyManagementService(initialKeys: Set<

Module Contents

)

package net.corda.node.services.messaging

Module Contents

abstract class ArtemisMessagingComponent :

ArtemisMessagingComponent()

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

abstract val config:

fun configureWithDevSSLCertificate(): Unit

protected fun

protected fun parseKeyFromQueueName(name: String):

expectedOnDefaultFileSystem

(

)

Unit

protected fun tcpTransport(direction:

ConnectionDirection

host

String

port

Int

)

fun toHostAndPort(target:

protected fun toMyAddress(myIdentity:

)

myHostPort

)

protected fun toQueueName(target:

class ArtemisMessagingServer :

)

ArtemisMessagingServer(config:

Module Contents

myHostPort

myIdentity

networkMapCache

userService

const val NODE_USER: String

)

class NodeLoginModule :

LoginModule

Module Contents

NodeLoginModule()

fun abort(): Boolean

fun commit(): Boolean

fun initialize(subject:

Subject

callbackHandler

CallbackHandler

sharedState

Map

String

options

Map

String

)

Unit

fun login(): Boolean

fun logout(): Boolean

fun bridgeToNetworkMapService(networkMapService:

)

Unit

val myHostPort: <ERROR CLASS>

val CURRENT_RPC_USER:

ThreadLocal

data class ClientRPCRequestMessage

Module Contents

ClientRPCRequestMessage(args:

Array

Any

replyToAddress

String

observationsToAddress

String

methodName

String

user

const val METHOD_NAME: String

)

const val OBSERVATIONS_TO: String

const val REPLY_TO: String

val args:

val observationsToAddress: String?

Array

Any

val methodName: String

val replyToAddress: String

val user:

interface CordaRPCOps :

abstract fun addVaultTransactionNote(txnId:

Module Contents

abstract fun getVaultTransactionNotes(txnId:

txnNote

String

)

Unit

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

)

Iterable

String

abstract fun nodeIdentity():

@RPCReturnsObservables abstract fun <T : Any> startFlowDynamic(logicType:

out

vararg

args

Any

)

@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 FlowHandle<A>

Module Contents

FlowHandle(id:

progress

returnValue

)

val progress: <ERROR CLASS><

val returnValue: <ERROR CLASS><A>

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

database

networkMapRegistrationFuture

Unit

)

data class Handler :

Module Contents

Handler(topicSession:

callback

(

)

Unit

)

val callback: (

)

Unit

val topicSession:

val SESSION_ID_PROPERTY: String

val TOPIC_PROPERTY: String

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

)

Unit

)

fun addMessageHandler(topicSession:

callback

(

)

Unit

)

fun createMessage(topicSession:

data

ByteArray

uuid

)

fun makeNetworkMapAddress(hostAndPort: <ERROR CLASS>):

val myAddress:

val myIdentity:

val networkMapRegistrationFuture: <ERROR CLASS><Unit>

fun removeMessageHandler(registration:

val serverHostPort: <ERROR CLASS>

)

Unit

target

)

Unit

fun start(rpcOps:

userService

)

Unit

class PermissionException :

PermissionException(msg: String)

Module Contents

abstract class RPCDispatcher

Module Contents

userService

)

ClientRPCRequestMessage

)

Unit

protected open fun getUser(message: <ERROR CLASS>):

val ops:

abstract fun send(data:

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

toAddress

String

)

Unit

)

Unit

val userService:

open class RPCException :

RPCException(msg: String)

Module Contents

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:

flowLogicClassName

String

progressTrackerStepAndUpdates

String

String

)

fun fromFlowStateMachineImpl(psm:

)

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

sealed class StateMachineUpdate

Module Contents

Module Contents

Added(stateMachineInfo:

fun fromStateMachineChange(change:

)

val stateMachineInfo:

Module Contents

)

)

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

fun requirePermission(permission: String): Unit

val rpcLog: <ERROR CLASS>

inline fun <T : Any, reified R :

inline fun <T : Any, A, reified R :

startFlow

(

flowConstructor

(

)

inline fun <T : Any, A, B, reified R :

startFlow

(

flowConstructor

(

)

arg0

)

inline fun <T : Any, A, B, C, reified R :

startFlow

(

flowConstructor

(

)

arg0

arg1

)

inline fun <T : Any, A, B, C, D, reified R :

startFlow

(

flowConstructor

(

)

arg0

arg1

arg2

)

package net.corda.node.services.network

startFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

)

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 getAnyNotary(type:

)

)

open fun getNodeByCompositeKey(compositeKey:

)

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

open fun getNotary(name: String):

open fun getRecommended(type:

contract

vararg

party

)

open fun getRepresentativeNode(party:

)

open fun isNotary(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

open fun track(): <ERROR CLASS><List<

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_FLOW_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_FLOW_TOPIC: String

val PUSH_FLOW_TOPIC: String

val QUERY_FLOW_TOPIC: String

class QueryIdentityRequest :

QueryIdentityRequest(identity:

Module Contents

replyTo

sessionID

Long

)

data class QueryIdentityResponse

Module Contents

QueryIdentityResponse(node:

)

val REGISTER_FLOW_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_FLOW_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 net.corda.node.services.persistence

)

Unit

Module Contents

class DBCheckpointStorage :

fun addCheckpoint(checkpoint:

Module Contents

DBCheckpointStorage()

)

Unit

fun forEach(block: (

fun removeCheckpoint(checkpoint:

)

Boolean

)

Unit

class DBTransactionMappingStorage :

)

Unit

DBTransactionMappingStorage()

Module Contents

transactionId

)

Unit

class DBTransactionStorage :

fun addTransaction(transaction:

Module Contents

DBTransactionStorage()

)

Boolean

fun getTransaction(id:

)

val transactions: Iterable<

val updatesPublisher: <ERROR CLASS>

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

transactionId

)

Unit

class NodeAttachmentService :

NodeAttachmentService(storePath:

Module Contents

class OnDiskHashMismatch :

metrics

)

Module Contents

OnDiskHashMismatch(file:

actual

)

val acceptableFileExtensions: <ERROR CLASS>

var automaticallyExtractAttachments: Boolean

var checkAttachmentsOnLoad: Boolean

val dataTypePrefix: String

fun importAttachment(jar:

)

open class StorageServiceImpl :

fun openAttachment(id:

)

)

StorageServiceImpl(attachments:

Module Contents

validatedTransactions

stateMachineRecordedTransactionMapping

)

open val attachments:

open val stateMachineRecordedTransactionMapping:

open val validatedTransactions:

package net.corda.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 net.corda.node.services.statemachine

Module Contents

interface FlowIORequest

Module Contents

abstract val session:

FlowSession

abstract val stackTraceInCaseOfProblems:

class FlowStateMachineImpl<R> :

Module Contents

FlowStateMachineImpl(id:

logic

fun currentStateMachine():

scheduler

FiberScheduler

)

val logic:

val resultFuture: <ERROR CLASS><R>

receiveType

sessionFlow

)

fun run(): R

fun send(otherParty:

payload

Any

sessionFlow

)

Unit

payload

Any

receiveType

sessionFlow

)

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 FlowSession

Module Contents

FlowSession(flow:

otherParty

var otherPartySessionId: Long?

ourSessionId

Long

otherPartySessionId

Long

waitingForResponse

Boolean

)

val ourSessionId: Long

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

flowName

String

firstPayload

Any

)

val firstPayload: Any?

val flowName: String

val initiatorParty:

interface SessionInitResponse :

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

(

flowClass

fun stop(allowedUnsuspendedFiberCount: Int = 0): Unit

)

List

package net.corda.node.services.transactions

Module Contents

class DistributedImmutableMap<K : Any, V : Any>

Module Contents

DistributedImmutableMap(db: <ERROR CLASS>, tableName: String)

Module Contents

Module Contents

Module Contents

PutAll(entries: Map<K, V>)

fun compaction(): <ERROR CLASS>

val entries: Map<K, V>

class Size

Module Contents

Size()

val db: <ERROR CLASS>

fun get(commit: <ERROR CLASS><

Get

)

fun install(reader: <ERROR CLASS>): Unit

fun put(commit: <ERROR CLASS><

PutAll

)

Map

fun size(commit: <ERROR CLASS><

Size

)

Int

fun snapshot(writer: <ERROR CLASS>): Unit

class InMemoryUniquenessProvider :

InMemoryUniquenessProvider()

Module Contents

txId

callerIdentity

abstract class NotaryService :

)

Unit

Module Contents

NotaryService(services:

abstract fun createFlow(otherParty:

)

)

class PersistentUniquenessProvider :

PersistentUniquenessProvider()

Module Contents

txId

callerIdentity

class RaftUniquenessProvider :

)

Unit

RaftUniquenessProvider(storagePath:

Module Contents

myAddress

clusterAddresses

List

config

)

txId

callerIdentity

class RaftValidatingNotaryService :

)

Unit

RaftValidatingNotaryService(services:

Module Contents

timestampChecker

uniquenessProvider

)

)

class SimpleNotaryService :

SimpleNotaryService(services:

Module Contents

timestampChecker

uniquenessProvider

)

)

class ValidatingNotaryService :

ValidatingNotaryService(services:

Module Contents

timestampChecker

uniquenessProvider

)

)

package net.corda.node.services.vault

Module Contents

class CashBalanceAsMetricsObserver

Module Contents

CashBalanceAsMetricsObserver(serviceHubInternal:

)

val serviceHubInternal:

class NodeVaultService :

NodeVaultService(services:

Module Contents

fun addNoteToTransaction(txnId:

)

noteText

String

)

Unit

val currentVault:

fun generateSpend(tx:

amount

onlyFromParties

Set

)

List

fun getTransactionNotes(txnId:

)

Iterable

String

val linearHeads: Map<

fun notifyAll(txns: Iterable<

)

fun track(): <ERROR CLASS><

package net.corda.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 net.corda.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, maxBuckets: Int = 256)

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?

val maxBuckets: Int

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, maxBuckets: Int = 256)

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:

open class ServiceAffinityExecutor :

)

Unit

fun flush(): Unit

val isOnThread: Boolean

val taskQueueSize: Int

fun waitAndRun(): Unit

ServiceAffinityExecutor(threadName: String, numThreads: Int)

ThreadPoolExecutor

Module Contents

protected open fun afterExecute(r:

open val isOnThread: Boolean

Throwable

)

Unit

open fun flush(): Unit

open fun checkOnThread(): Unit

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

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

abstract fun flush(): Unit

abstract val isOnThread: Boolean

object CompositeKeyColumnType

Module Contents

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

(

)

object InstantColumnType

Module Contents

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

JDBCHashMap(tableName: String, loadOnInit: Boolean = false, maxBuckets: Int = 256)

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, maxBuckets: Int = 256)

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 CompositeKeyDeserializer

Module Contents

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

object CompositeKeySerializer

Module Contents

object LocalDateDeserializer

generator

provider

)

Unit

Module Contents

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

object LocalDateKeyDeserializer

Module Contents

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

object NodeInfoDeserializer

Module Contents

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

object NodeInfoSerializer

Module Contents

fun serialize(value:

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

gen

serializers

)

Unit

object PartyDeserializer

Module Contents

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

class SecureHashDeserializer<T :

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

object LocalDateTimeColumnType

Module Contents

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

object ServiceIdentityGenerator

Module Contents

fun generateToDisk(dirs: List<

data class StateRefColumns

serviceId

String

serviceName

String

threshold

Int

)

Unit

Module Contents

StateRefColumns(txId: <ERROR CLASS><

val index: <ERROR CLASS><Int>

index

Int

)

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>?>

class TestClock :

MutableClock

Module Contents

TestClock(delegateClock:

)

)

fun updateDate(date:

)

Boolean

fun withZone(zone:

ZoneId

)

data class TxnNoteColumns

Module Contents

TxnNoteColumns(txId: <ERROR CLASS><

val note: <ERROR CLASS><String>

note

String

)

object UUIDStringColumnType

Module Contents

fun <T : Any> bytesFromBlob(blob:

)

fun bytesToBlob(value:

finalizables

MutableList

(

)

Unit

)

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

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 <ERROR CLASS>.instant(name: String): <ERROR CLASS>

)

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>.localDateTime(name: String): <ERROR CLASS>

fun main(args: Array<String>): Unit

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>.txnNote(txIdColumnName: String, txnNoteColumnName: String): <ERROR CLASS>

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

package net.corda.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

val baseDirectoryArg: <ERROR CLASS>

val configFileArg: <ERROR CLASS>

val parser: <ERROR CLASS>

fun main(args: Array<String>): Unit

package net.corda.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: